From 68110d524bcfba75f766f04fa9c66349994e8c83 Mon Sep 17 00:00:00 2001 From: Gerhard Hoffmann Date: Mon, 23 Jan 2023 15:50:37 +0100 Subject: [PATCH] Add new calculate_price-projet. --- calculate_parking.pro | 5 + calculate_parking_tickets/.gdb_history | 4 + .../calculate_parking_tickets.cpp | 5 + .../calculate_parking_tickets.h | 12 + .../calculate_parking_tickets.pro | 46 + .../calculate_parking_tickets.pro.user | 314 + .../calculate_parking_tickets_algorithms.cpp | 323 + .../calculate_parking_tickets_algorithms.h | 35 + .../calculate_parking_tickets_day.cpp | 4 + .../calculate_parking_tickets_day.h | 85 + .../calculate_parking_tickets_global.h | 59 + ...calculate_parking_tickets_parse_tariff.cpp | 184 + .../calculate_parking_tickets_parse_tariff.h | 16 + .../calculate_parking_tickets_tariff.cpp | 217 + .../calculate_parking_tickets_tariff.h | 218 + .../calculate_parking_tickets_tariff_step.cpp | 3 + .../calculate_parking_tickets_tariff_step.h | 78 + .../calculate_parking_tickets_utils.cpp | 158 + .../calculate_parking_tickets_utils.h | 64 + calculate_parking_tickets/erlangen.conf | 562 + calculate_parking_tickets/erlangen.conf.bck | 557 + calculate_parking_tickets/germersheim.conf | 30319 ++++++++++++++++ .../germersheim.conf.bck | 368 + .../germersheim.conf.bck1 | 368 + main/kate.txt | 10100 +++++ main/main.cpp | 70 + main/main.cpp.bck.1 | 160 + main/main.pro | 29 + main/message_handler.cpp | 140 + main/message_handler.h | 20 + 30 files changed, 44523 insertions(+) create mode 100644 calculate_parking.pro create mode 100644 calculate_parking_tickets/.gdb_history create mode 100644 calculate_parking_tickets/calculate_parking_tickets.cpp create mode 100644 calculate_parking_tickets/calculate_parking_tickets.h create mode 100644 calculate_parking_tickets/calculate_parking_tickets.pro create mode 100644 calculate_parking_tickets/calculate_parking_tickets.pro.user create mode 100644 calculate_parking_tickets/calculate_parking_tickets_algorithms.cpp create mode 100644 calculate_parking_tickets/calculate_parking_tickets_algorithms.h create mode 100644 calculate_parking_tickets/calculate_parking_tickets_day.cpp create mode 100644 calculate_parking_tickets/calculate_parking_tickets_day.h create mode 100644 calculate_parking_tickets/calculate_parking_tickets_global.h create mode 100644 calculate_parking_tickets/calculate_parking_tickets_parse_tariff.cpp create mode 100644 calculate_parking_tickets/calculate_parking_tickets_parse_tariff.h create mode 100644 calculate_parking_tickets/calculate_parking_tickets_tariff.cpp create mode 100644 calculate_parking_tickets/calculate_parking_tickets_tariff.h create mode 100644 calculate_parking_tickets/calculate_parking_tickets_tariff_step.cpp create mode 100644 calculate_parking_tickets/calculate_parking_tickets_tariff_step.h create mode 100644 calculate_parking_tickets/calculate_parking_tickets_utils.cpp create mode 100644 calculate_parking_tickets/calculate_parking_tickets_utils.h create mode 100644 calculate_parking_tickets/erlangen.conf create mode 100644 calculate_parking_tickets/erlangen.conf.bck create mode 100644 calculate_parking_tickets/germersheim.conf create mode 100644 calculate_parking_tickets/germersheim.conf.bck create mode 100644 calculate_parking_tickets/germersheim.conf.bck1 create mode 100644 main/kate.txt create mode 100644 main/main.cpp create mode 100644 main/main.cpp.bck.1 create mode 100644 main/main.pro create mode 100644 main/message_handler.cpp create mode 100644 main/message_handler.h diff --git a/calculate_parking.pro b/calculate_parking.pro new file mode 100644 index 0000000..9ae010e --- /dev/null +++ b/calculate_parking.pro @@ -0,0 +1,5 @@ +TEMPLATE = subdirs +CONFIG += ordered +SUBDIRS = calculate_parking_tickets main + +main.depends = calculate_parking_tickets diff --git a/calculate_parking_tickets/.gdb_history b/calculate_parking_tickets/.gdb_history new file mode 100644 index 0000000..a5d7f03 --- /dev/null +++ b/calculate_parking_tickets/.gdb_history @@ -0,0 +1,4 @@ +p 24*60 +p 24*60*7 +p 24*60*7*2 +quit diff --git a/calculate_parking_tickets/calculate_parking_tickets.cpp b/calculate_parking_tickets/calculate_parking_tickets.cpp new file mode 100644 index 0000000..8ff946a --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets.cpp @@ -0,0 +1,5 @@ +#include "calculate_parking_tickets.h" + +Calculate_parking_tickets::Calculate_parking_tickets() +{ +} diff --git a/calculate_parking_tickets/calculate_parking_tickets.h b/calculate_parking_tickets/calculate_parking_tickets.h new file mode 100644 index 0000000..4464ceb --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets.h @@ -0,0 +1,12 @@ +#ifndef CALCULATE_PARKING_TICKETS_H +#define CALCULATE_PARKING_TICKETS_H + +#include "calculate_parking_tickets_global.h" + +class CALCULATE_PARKING_TICKETS_EXPORT Calculate_parking_tickets +{ +public: + Calculate_parking_tickets(); +}; + +#endif // CALCULATE_PARKING_TICKETS_H diff --git a/calculate_parking_tickets/calculate_parking_tickets.pro b/calculate_parking_tickets/calculate_parking_tickets.pro new file mode 100644 index 0000000..0f0474b --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets.pro @@ -0,0 +1,46 @@ +QT -= gui + +TEMPLATE = lib +DEFINES += CALCULATE_PARKING_TICKETS_LIBRARY + +CONFIG += c++11 + +QMAKE_CXXFLAGS += -Wno-deprecated-copy + +INCLUDEPATH += ./rapidjson + +# The following define makes your compiler emit warnings if you use +# any Qt feature that has been marked deprecated (the exact warnings +# depend on your compiler). Please consult the documentation of the +# deprecated API in order to know how to port your code away from it. +DEFINES += QT_DEPRECATED_WARNINGS + +# You can also make your code fail to compile if it uses deprecated APIs. +# In order to do so, uncomment the following line. +# You can also select to disable deprecated APIs only up to a certain version of Qt. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + +SOURCES += \ + calculate_parking_tickets.cpp \ + calculate_parking_tickets_utils.cpp \ + calculate_parking_tickets_day.cpp \ + calculate_parking_tickets_algorithms.cpp \ + calculate_parking_tickets_tariff.cpp \ + calculate_parking_tickets_tariff_step.cpp + +HEADERS += \ + calculate_parking_tickets_global.h \ + calculate_parking_tickets.h \ + calculate_parking_tickets_utils.h \ + calculate_parking_tickets_tariff_step.h \ + calculate_parking_tickets_day.h \ + calculate_parking_tickets_algorithms.h \ + calculate_parking_tickets_tariff.h + +OTHER_FILES += germersheim.conf + +# Default rules for deployment. +unix { + target.path = /usr/lib +} +!isEmpty(target.path): INSTALLS += target diff --git a/calculate_parking_tickets/calculate_parking_tickets.pro.user b/calculate_parking_tickets/calculate_parking_tickets.pro.user new file mode 100644 index 0000000..1b21d87 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets.pro.user @@ -0,0 +1,314 @@ + + + + + + EnvironmentId + {c2bbab97-5376-485d-80a0-17f0450f5730} + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + 80 + true + true + 1 + true + false + 0 + true + true + 0 + 8 + true + 1 + true + true + true + false + + + + ProjectExplorer.Project.PluginSettings + + + + ProjectExplorer.Project.Target.0 + + Desktop + Desktop + {fb1cff28-cc0f-4303-b6a9-21ad8289ece7} + 0 + 0 + 0 + + /home/linux/build-calculate_parking_tickets-Desktop-Debug + + + true + QtProjectManager.QMakeBuildStep + true + + false + false + false + + + true + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Erstellen + Erstellen + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Bereinigen + Bereinigen + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Debug + Qt4ProjectManager.Qt4BuildConfiguration + 2 + + + /home/linux/build-calculate_parking_tickets-Desktop-Release + + + true + QtProjectManager.QMakeBuildStep + false + + false + false + false + + + true + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Erstellen + Erstellen + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Bereinigen + Bereinigen + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Release + Qt4ProjectManager.Qt4BuildConfiguration + 0 + + + /home/linux/build-calculate_parking_tickets-Desktop-Profile + + + true + QtProjectManager.QMakeBuildStep + true + + false + true + false + + + true + Qt4ProjectManager.MakeStep + + false + + + false + + 2 + Erstellen + Erstellen + ProjectExplorer.BuildSteps.Build + + + + true + Qt4ProjectManager.MakeStep + + true + clean + + false + + 1 + Bereinigen + Bereinigen + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Profile + Qt4ProjectManager.Qt4BuildConfiguration + 0 + + 3 + + + 0 + Deploy + Deploy + ProjectExplorer.BuildSteps.Deploy + + 1 + ProjectExplorer.DefaultDeployConfiguration + + 1 + + + dwarf + + cpu-cycles + + + 250 + + -e + cpu-cycles + --call-graph + dwarf,4096 + -F + 250 + + -F + true + 4096 + false + false + 1000 + + true + + false + false + false + false + true + 0.01 + 10 + true + kcachegrind + 1 + 25 + + 1 + true + false + true + valgrind + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + + 2 + + + ProjectExplorer.CustomExecutableRunConfiguration + + + false + + false + true + false + false + true + + + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.FileVersion + 22 + + + Version + 22 + + diff --git a/calculate_parking_tickets/calculate_parking_tickets_algorithms.cpp b/calculate_parking_tickets/calculate_parking_tickets_algorithms.cpp new file mode 100644 index 0000000..2fa17d2 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_algorithms.cpp @@ -0,0 +1,323 @@ +#include "calculate_parking_tickets_algorithms.h" +#include "calculate_parking_tickets_global.h" +#include "calculate_parking_tickets_tariff_step.h" +#include "calculate_parking_tickets_utils.h" +#include "calculate_parking_tickets_tariff.h" +#include "calculate_parking_tickets_day.h" + +#include +#include +#include + + +/* BEGRIFFE + bezahltes Parken am Ende der Parkdauer vor Einsteigen ins Auto: + pay on foot parking + bezahltes Parken am Anfang der Parkdauer und Quittung an der Windschutzscheibe + pay and display parking + Parkdauer + parking time + Parkschein + parking voucher + Parkgutschein + parking voucher + Maximale Parkdauer + maximal parking time +*/ + +#if 0 + bool get_price(parking_tariff_t const *tariff, QDateTime const &qdt, + uint32_t &price_units) { + QDate const &qdate = qdt.date(); + QTime const &qtime = qdt.time(); + qDebug() << qdate << qtime; + if (!TUtils::isHoliday(tariff, qdate)) { + int const dayOfWeek = qdate.dayOfWeek(); + switch (dayOfWeek) { + case Qt::Monday: + return Monday::price(tariff, qtime, &price_units); + case Qt::Tuesday: + return Tuesday::price(tariff, qtime, &price_units); + case Qt::Wednesday: + return Wednesday::price(tariff, qtime, &price_units); + case Qt::Thursday: + return Thursday::price(tariff, qtime, &price_units); + case Qt::Friday: + return Friday::price(tariff, qtime, &price_units); + case Qt::Saturday: + return Saturday::price(tariff, qtime, &price_units); + case Qt::Sunday: + return Sunday::price(tariff, qtime, &price_units); + } + } + return false; + // return Holiday::price(tariff, qtime, &price_units); + } +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +static bool checkCalculatePreConditions(parking_tariff_t const* tariff, + minute_t startMinute, // CET + minute_t endMinute, // CET + struct price_t *price) { + + if (startMinute > endMinute) { + qCritical() << "startMinute > endMinute (" + << startMinute << endMinute << ")"; + return false; + } + + minute_t const parkingTime = endMinute - startMinute; + + if (parkingTime == 0) { + qCritical() << "startMinute == endMinute => no parking time"; + return false; + } + + if (tariff->max_parking_time != -1) { + if (parkingTime > tariff->max_parking_time) { + qCritical() << "parkingTime" << parkingTime + << ">" << tariff->max_parking_time; + return false; + } + } + + minute_t const effectiveStartMinute = startMinute + tariff->free_of_charge; + QDateTime const start = TUtils::fromMinutes(startMinute); + //QDateTime const effStart = TUtils::fromMinutes(effectiveStartMinute); + QDateTime const end = TUtils::fromMinutes(endMinute); + + if (effectiveStartMinute > endMinute) { + fprintf(stderr, + "[start:%02d:%02d, ende:%02d:%02d]: %ld free minutes. no charge.\n", + start.time().hour(), start.time().minute(), + end.time().hour(), end.time().minute(), tariff->free_of_charge); + memset(price, 0x00, sizeof(*price)); + return false; + } + + // start algorithm + return true; +} + +#define DEBUG_INTERNAL 1 + +TariffStep const * +compute_price_for_parking_ticket_internal(parking_tariff_t const *tariff, + minute_t startMinute, // CET + minute_t endMinute, // CET + struct price_t *price) { + TariffStep const *stepDbg = nullptr; + + QDateTime const start = TUtils::fromMinutes(startMinute); + QDateTime const end = TUtils::fromMinutes(endMinute); + + int const minute = start.time().minute(); + int const hour = start.time().hour(); + int const day = start.date().dayOfWeek()-Qt::Monday; + int const week = 0; + +// printf("%d%d%04d\n", week, day, hour*60+minute); + + TariffStep const *step = &tariff->m_tariffSteps[week][day][hour*60+minute]; + + // TODO: tageslimit muss beruecksichtigt werden + stepDbg = step; + + + uint32_t price_units = 0; + if (tariff->max_price_for_24_hours == (uint32_t)(-1)) { + while (step->dateTime() < end) { + price_units += step->price(); + step = step->next(); + } + } else { + QDateTime stepDateTime = step->dateTime(); + QDateTime nextStepDateTime; + // QDateTime prevStepDateTime; + QDateTime _24hDateTime = stepDateTime; + uint32_t _24h_price_units = 0; + long t0 = _24hDateTime.toSecsSinceEpoch(); + bool dbg = true; + while (stepDateTime < end) { + long const t1 = stepDateTime.toSecsSinceEpoch(); + uint32_t const price_units_tmp = step->price(); + step = step->next(); + nextStepDateTime = step->dateTime(); + long const diff = t1 - t0; + if (diff < SECS_PER_DAY) { + _24h_price_units += price_units_tmp; + if (_24h_price_units > tariff->max_price_for_24_hours) { + _24h_price_units = tariff->max_price_for_24_hours; + if (dbg) { +#if DEBUG_INTERNAL + fprintf(stderr, + "[%s:%02d:%02d %d]\n", + stepDateTime.date().toString().toStdString().c_str(), + stepDateTime.time().hour(), stepDateTime.time().minute(), + _24h_price_units); + dbg = false; +#endif + } + } else { +#if DEBUG_INTERNAL + dbg = true; + fprintf(stderr, + "[%s:%02d:%02d %d]\n", + stepDateTime.date().toString().toStdString().c_str(), + stepDateTime.time().hour(), stepDateTime.time().minute(), + _24h_price_units); +#endif + } + } else { + price_units += _24h_price_units; + _24h_price_units = price_units_tmp; +#if DEBUG_INTERNAL + fprintf(stderr, + "[%s:%02d:%02d 24h max. %d]\n", + stepDateTime.date().toString().toStdString().c_str(), + stepDateTime.time().hour(), stepDateTime.time().minute(), + price_units); + fprintf(stderr, + "[%s:%02d:%02d %d]\n", + stepDateTime.date().toString().toStdString().c_str(), + stepDateTime.time().hour(), stepDateTime.time().minute(), + _24h_price_units); +#endif + + _24hDateTime = stepDateTime; + t0 = _24hDateTime.toSecsSinceEpoch(); + } + // prevStepDateTime = stepDateTime; + stepDateTime = nextStepDateTime; + } + price_units += _24h_price_units; + } + + price->units = price_units; + price->netto = roundf((price->units * tariff->unit_scale_factor) / tariff->unit_definition); + price->vat_percentage = tariff->vat; + price->vat = price->netto * price->vat_percentage; + price->brutto = price->netto + price->vat; + + return stepDbg; +} + +bool compute_price_for_parking_ticket(parking_tariff_t const *tariff, + minute_t startMinute, // CET + minute_t endMinute, // CET + struct price_t *price) { + + if (!checkCalculatePreConditions(tariff, startMinute, endMinute, price)) { // CET + return false; + } + + // minute_t const parkingTime = endMinute - startMinute; + memset(price, 0x00, sizeof(*price)); + + minute_t const effectiveStartMinute = startMinute + tariff->free_of_charge; + QDateTime const start = TUtils::fromMinutes(startMinute); + QDateTime const effStart = TUtils::fromMinutes(effectiveStartMinute); + QDateTime const end = TUtils::fromMinutes(endMinute); + + //qDebug() << effStart; + //qDebug() << end; + + TariffStep const *stepDbg = + compute_price_for_parking_ticket_internal(tariff, + effectiveStartMinute, + endMinute, price); + if (stepDbg) { +#if 0 + if (tariff->free_of_charge == 0) { + fprintf(stderr, + "[EINFAHRT: %s:%02d:%02d, AUSFAHRT: %s:%02d:%02d]\n\t", + effStart.date().toString().toStdString().c_str(), + effStart.time().hour(), effStart.time().minute(), + end.date().toString().toStdString().c_str(), + end.time().hour(), end.time().minute()); + } else { + fprintf(stderr, + "[EINFAHRT: %s:%02d:%02d, %ld Minuten frei -> " + "EFF. EINFAHRT: %s:%02d:%02d, AUSFAHRT: %s:%02d:%02d]\n\t", + start.date().toString().toStdString().c_str(), + start.time().hour(), start.time().minute(), + tariff->free_of_charge, + effStart.date().toString().toStdString().c_str(), + effStart.time().hour(), effStart.time().minute(), + end.date().toString().toStdString().c_str(), + end.time().hour(), end.time().minute()); + } + int cnt = -1; + while (stepDbg->dateTime() < end) { + // qDebug() << price_units << step->price(); + fprintf(stderr, "%s %02d:%02d +%u |", + (++cnt == 0) ? "|" : "", + stepDbg->dateTime().time().hour(), + stepDbg->dateTime().time().minute(), + stepDbg->price()); + //price_units += stepDbg->price(); + //qDebug() << price_units << step->price(); + stepDbg = stepDbg->next(); + } +#endif + + if (price->units > tariff->max_parking_price_units) { + qCritical() << "gesamt" << price->units + << ">" << tariff->max_parking_price_units; + return false; + } + + fprintf(stderr, " : gesamt %.2f (netto: %.2f)\n", price->brutto/100, price->netto/100); + return true; + + } else { + qCritical() << "compute_price_for_parking_ticket"; + } + + return false; +} + +bool compute_duration_for_parking_ticket(parking_tariff_t const *tariff, + minute_t start_parking_time, + minute_t *end_parking_time, + struct price_t const *price) { + price_t p; + for (int i = 0; i < tariff->max_parking_time; ++i) { + minute_t end_time = start_parking_time + i; + if (compute_price_for_parking_ticket(tariff, start_parking_time, + end_time, &p)) { + if (p.netto >= price->netto) { + *end_parking_time = end_time; + return true; + } + } + } + return false; +} + +bool compute_price_for_tages_ticket(parking_tariff_t *tariff, + time_t parking_time_start, // minutes + struct price_t *price) { + QDateTime dateTime = TUtils::fromMinutes(parking_time_start).addDays(1); + dateTime.setTime(QTime(0, 0)); + time_t parking_time_end = dateTime.toSecsSinceEpoch() / 60; + return compute_price_for_parking_ticket(tariff, parking_time_start, + parking_time_end, price); +} + +bool compute_price_for_24h_ticket(parking_tariff_t *tariff, + time_t parking_time_start, // minutes + struct price_t *price) { + QDateTime dateTime = TUtils::fromMinutes(parking_time_start).addDays(1); + time_t parking_time_end = dateTime.toSecsSinceEpoch() / 60; + return compute_price_for_parking_ticket(tariff, parking_time_start, + parking_time_end, price); +} + +#ifdef __cplusplus +} +#endif diff --git a/calculate_parking_tickets/calculate_parking_tickets_algorithms.h b/calculate_parking_tickets/calculate_parking_tickets_algorithms.h new file mode 100644 index 0000000..a6fb80e --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_algorithms.h @@ -0,0 +1,35 @@ +#ifndef CALCULATE_PARKING_TICKETS_ALGORITHMS_H_INCLUDED +#define CALCULATE_PARKING_TICKETS_ALGORITHMS_H_INCLUDED + +#include +#include "calculate_parking_tickets_global.h" +#include "calculate_parking_tickets_tariff.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +bool compute_price_for_parking_ticket(parking_tariff_t const *tariff, + minute_t start_parking_time, + minute_t end_parking_time, + struct price_t *price); + +bool compute_duration_for_parking_ticket(parking_tariff_t const *tariff, + minute_t start_parking_time, + minute_t *end_parking_time, + struct price_t const *price); + +bool compute_price_for_tages_ticket(parking_tariff_t *tariff, + time_t parking_time_start, + struct price_t *price); + +bool compute_price_for_24h_ticket(parking_tariff_t *tariff, + time_t start_parking_time, + struct price_t *price); + +#ifdef __cplusplus +} +#endif + +#endif // CALCULATE_PARKING_TICKETS_ALGORITHMS_H_INCLUDED diff --git a/calculate_parking_tickets/calculate_parking_tickets_day.cpp b/calculate_parking_tickets/calculate_parking_tickets_day.cpp new file mode 100644 index 0000000..a00bd45 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_day.cpp @@ -0,0 +1,4 @@ +#include "calculate_parking_tickets_day.h" +#include + + diff --git a/calculate_parking_tickets/calculate_parking_tickets_day.h b/calculate_parking_tickets/calculate_parking_tickets_day.h new file mode 100644 index 0000000..b3fd6e2 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_day.h @@ -0,0 +1,85 @@ +#ifndef CALCULATE_PARKING_TICKETS_DAY_H_INCLUDED +#define CALCULATE_PARKING_TICKETS_DAY_H_INCLUDED + +#include "calculate_parking_tickets_global.h" +#include "calculate_parking_tickets_tariff_step.h" +#include "calculate_parking_tickets_tariff.h" +#include "calculate_parking_tickets_utils.h" + +#include +#include +#include +#include +#include + +struct DayInternal { +}; + +struct parking_tariff_t; +template +struct Day { + static bool price(parking_tariff_t const * /*tariff*/, + QTime const & /*time*/, + uint32_t * /*price_units*/) { + // minute_t const minute = time.hour()*60 + time.minute(); + // for (int i = 0; i < MIN_PER_DAY; ++i) { + //if (m_tariffSteps[i].isValid()) { + + //} + //} + return true; + } + +protected: + //std::array m_tariffSteps; + +#if 0 + static bool price(parking_tariff_t const *tariff, + QTime const &time, uint32_t *price_units, int dayIndex) { + minute_t const minute = time.hour()*60 + time.minute(); + for (int i = 0; i < tariff->m_tariffSteps[dayIndex].size(); ++i) { + //if (minute >= tariff->m_tariff[dayIndex][i].first) { + // *price_units += tariff->m_tariff[dayIndex][i].second; + // return true; + //} + } + return true; + // return false; + } +#endif +}; + +struct Holiday : Day { + enum { dayIndex = 0 }; +}; + +struct Monday : Day { + enum { dayIndex = Qt::Monday }; +}; + +struct Tuesday : Day { + enum { dayIndex = Qt::Tuesday }; +}; + +struct Wednesday : Day { + enum { dayIndex = Qt::Wednesday }; +}; + +struct Thursday : Day { + enum { dayIndex = Qt::Thursday }; +}; + +struct Friday : Day { + enum { dayIndex = Qt::Friday }; +}; + +struct Saturday : Day { + enum { dayIndex = Qt::Saturday }; +}; + +struct Sunday : Day { + enum { dayIndex = Qt::Sunday }; +}; + + +#endif // CALCULATE_PARKING_TICKETS_DAY_H_INCLUDED diff --git a/calculate_parking_tickets/calculate_parking_tickets_global.h b/calculate_parking_tickets/calculate_parking_tickets_global.h new file mode 100644 index 0000000..1b2e52c --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_global.h @@ -0,0 +1,59 @@ +#ifndef CALCULATE_PARKING_TICKETS_GLOBAL_H +#define CALCULATE_PARKING_TICKETS_GLOBAL_H + +#include + +#if defined(CALCULATE_PARKING_TICKETS_LIBRARY) +# define CALCULATE_PARKING_TICKETS_EXPORT Q_DECL_EXPORT +#else +# define CALCULATE_PARKING_TICKETS_EXPORT Q_DECL_IMPORT +#endif + +#include +#include + +typedef time_t minute_t; + +typedef struct price_t { + uint32_t units; + double netto; + double brutto; + double vat_percentage; + double vat; +} price_t; + +static constexpr uint16_t const MIN_PER_DAY = 1440; +static constexpr uint16_t const MINUTES_PER_DAY = 1440; +static constexpr uint32_t const SECS_PER_DAY = 1440*60; + +//struct TariffLine { +// uint32_t line; + // obere 11 bit: 2 bit week, 3 bit day, 11 bit minute +//}; + +struct TariffMinute { + uint32_t price_units; + uint32_t next_minute; +}; + +static constexpr uint16_t const WEEKS = 3; +static constexpr uint16_t const DAYS = 7; + +static constexpr uint32_t const MAX_OFFSET = (uint32_t)sizeof(TariffMinute[3][7][1440]); +static constexpr uint32_t const UNDEFINED_NEXT_MINUTE = MAX_OFFSET; + +struct TariffDay { + TariffMinute m[1]; + //TariffMinute m[MINUTES_PER_DAY]; +}; + +struct TariffWeek { + TariffDay mon = {{}}; +}; + +struct TariffSteps { +}; + + + +#endif // CALCULATE_PARKING_TICKETS_GLOBAL_H diff --git a/calculate_parking_tickets/calculate_parking_tickets_parse_tariff.cpp b/calculate_parking_tickets/calculate_parking_tickets_parse_tariff.cpp new file mode 100644 index 0000000..108116f --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_parse_tariff.cpp @@ -0,0 +1,184 @@ +#include "calculate_parking_tickets_parse_tariff.h" +#include "calculate_parking_tickets_tariff.h" + +#include +#include + +#include +#include + +#include +#include +#include +#include +#include "rapidjson/stringbuffer.h" +#include +#include + +using namespace rapidjson; + +#define MAX_READ_BUFFER_SIZE 10000000 + +static const char *weekStr[] { + "week1", "week2", "week3" +}; +static const char *weekDayStr[] { + "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" +}; +static const int constexpr STEP_PRICE = 1; +static const int constexpr STEP_NEXT = 2; + +parking_tariff_t *parking_tariff_t::parseTariff(const char *confFile) { + parking_tariff_t *tariff = 0; + + FILE* fp = fopen(confFile, "r"); + if (fp) { + fseek(fp, 0 , SEEK_END); + long const bufSize = ftell(fp) + 1024; + fseek(fp, 0 , SEEK_SET); + char *readBuffer = (char *)malloc(bufSize); + if (readBuffer) { + memset(readBuffer, 0x00, bufSize); + + FileReadStream is(fp, readBuffer, bufSize); + Document d; + + if (d.ParseStream(is).HasParseError()) { + fprintf(stderr, "\nError(offset %u): %s\n", + (unsigned)d.GetErrorOffset(), + GetParseError_En(d.GetParseError())); + free(readBuffer); + fclose(fp); + return 0; + } + + tariff = new parking_tariff_t(); + + if (d.HasMember(FREE_OF_CHARGE)) { + Value::MemberIterator o = d.FindMember(FREE_OF_CHARGE); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string foc = o->value.GetString(); + tariff->free_of_charge = std::stoi(foc); + } + if (d.HasMember(UNIT_SCALE_FACTOR)) { + Value::MemberIterator o = d.FindMember(UNIT_SCALE_FACTOR); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string usf = o->value.GetString(); + tariff->unit_scale_factor = std::stof(usf); + } + if (d.HasMember(UNIT_DEFINITION)) { + Value::MemberIterator o = d.FindMember(UNIT_DEFINITION); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string udef = o->value.GetString(); + tariff->unit_definition = std::stoi(udef); + } + if (d.HasMember(VAT)) { + Value::MemberIterator o = d.FindMember(VAT); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string vat = o->value.GetString(); + tariff->vat = std::stof(vat); + } + if (d.HasMember(MAX_PARKING_PRICE)) { + Value::MemberIterator o = d.FindMember(MAX_PARKING_PRICE); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string mp = o->value.GetString(); + if (mp == "unlimited") { + tariff->max_parking_price_units = ~0; + } else { + tariff->max_parking_price_units = (uint32_t)std::stoul(mp); + } + } + if (d.HasMember(MAX_PRICE_FOR_24_HOURS)) { + Value::MemberIterator o = d.FindMember(MAX_PRICE_FOR_24_HOURS); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string mp = o->value.GetString(); + if (mp == "unlimited") { + tariff->max_price_for_24_hours = ~0; + } else { + tariff->max_price_for_24_hours = (uint32_t)std::stoul(mp); + } + } + + QDate today = QDate::currentDate(); + int todayWeekDay = today.dayOfWeek(); + if (todayWeekDay > Qt::Monday) { + int day = today.day() - todayWeekDay; + if (!today.setDate(today.year(), today.month(), day)) { + qFatal("Setting today failed"); + } + } + + QDate monday = today; + + // "week1" : { + for (int w = 0; w < 3; ++w) { + assert(d.HasMember(weekStr[w])); + + // "Monday": { + for (int j = Qt::Monday - 1; j < Qt::Sunday; ++j) { + QDateTime startMinute(monday.addDays(w*7+j), QTime( 0, 0)); + + Value::MemberIterator wObj = d.FindMember(weekStr[w]); + assert(wObj != d.MemberEnd()); + assert(wObj->value.IsObject()); + + Value::MemberIterator stepsForDay = wObj->value.FindMember(weekDayStr[j]); + assert(stepsForDay != wObj->value.MemberEnd()); + assert(stepsForDay->value.IsObject()); + + // name : time, price, next-tariff-step + // "000000" : [ "00:00", "800000", "000001" ], + // "000001" : [ "07:00", "350000", "000002" ], + // ... + // "000014" : [ "20:00", "800000", "000011" ] + // }, + int k = 0; + for (Value::ConstMemberIterator step = stepsForDay->value.MemberBegin(); + step != stepsForDay->value.MemberEnd(); ++step) { + + assert(step->name.IsString()); + assert(step->value.IsArray()); + + QString name(step->name.GetString()); + + int const week = name.midRef(0, 1).toInt(); + int const weekDay = name.midRef(1, 1).toInt(); + int const stepIndex = name.midRef(2).toInt(); + + assert(w == week); + assert(j == weekDay); + assert(k == stepIndex); + + uint32_t price_units = QString(step->value[STEP_PRICE].GetString()).toUInt(); + QString next = QString(step->value[STEP_NEXT].GetString()); + + int const nextWeek = next.midRef(0, 1).toInt(); + int const nextWeekDay = next.midRef(1, 1).toInt(); + int const nextStepIndex = next.midRef(2).toInt(); + + //qDebug() << startMinute.addSecs(stepIndex*60) + // << "(" << week << weekDay << stepIndex << ")" + // << "(" << nextWeek << nextWeekDay << nextStepIndex << ")"; + + tariff->m_tariffSteps[week][weekDay][stepIndex] = + TariffStep(startMinute.addSecs(stepIndex*60), + price_units, + &tariff->m_tariffSteps[nextWeek][nextWeekDay][nextStepIndex]); + + ++k; + } + } + } + free(readBuffer); + } + fclose(fp); + } + + return tariff; +} diff --git a/calculate_parking_tickets/calculate_parking_tickets_parse_tariff.h b/calculate_parking_tickets/calculate_parking_tickets_parse_tariff.h new file mode 100644 index 0000000..ef22507 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_parse_tariff.h @@ -0,0 +1,16 @@ +#ifndef CALCULATE_PARKING_TICKETS_PARSE_TARIFF_H_INCLUDED +#define CALCULATE_PARKING_TICKETS_PARSE_TARIFF_H_INCLUDED + +#include "calculate_parking_tickets_tariff.h" + +#define FREE_OF_CHARGE "free_of_charge" +#define UNIT_SCALE_FACTOR "unit_scale_factor" +#define UNIT_DEFINITION "unit_definition" +#define VAT "vat" +#define MAX_PARKING_PRICE "max_parking_price" +#define MAX_PRICE_FOR_24_HOURS "max_price_for_24_hours" + + +parking_tariff_t *parking_tariff_t::parseTariff(const char *confFile); + +#endif // CALCULATE_PARKING_TICKETS_PARSE_TARIFF_H_INCLUDED diff --git a/calculate_parking_tickets/calculate_parking_tickets_tariff.cpp b/calculate_parking_tickets/calculate_parking_tickets_tariff.cpp new file mode 100644 index 0000000..e5bbfa1 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_tariff.cpp @@ -0,0 +1,217 @@ +#include "calculate_parking_tickets_tariff.h" + +#include +#include + +#include +#include + +#include +#include +#include +#include +#include "rapidjson/stringbuffer.h" +#include +#include + +using namespace rapidjson; + +#define FREE_OF_CHARGE "free_of_charge" +#define UNIT_SCALE_FACTOR "unit_scale_factor" +#define UNIT_DEFINITION "unit_definition" +#define VAT "vat" +#define MAX_PARKING_PRICE "max_parking_price" +#define MAX_PRICE_FOR_24_HOURS "max_price_for_24_hours" +#define MAX_PARKING_TIME "max_parking_time" + +static const char *weekStr[] { + "week1", "week2", "week3" +}; +static const char *weekDayStr[] { + "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday" +}; +static const int constexpr STEP_PRICE = 1; +static const int constexpr STEP_NEXT = 2; + +parking_tariff_t *parking_tariff_t::parseTariff(const char *confFile) { + parking_tariff_t *tariff = 0; + + FILE* fp = fopen(confFile, "r"); + if (fp) { + fseek(fp, 0 , SEEK_END); + long const bufSize = ftell(fp) + 1024; + fseek(fp, 0 , SEEK_SET); + char *readBuffer = (char *)malloc(bufSize); + if (readBuffer) { + memset(readBuffer, 0x00, bufSize); + + FileReadStream is(fp, readBuffer, bufSize); + Document d; + + if (d.ParseStream(is).HasParseError()) { + fprintf(stderr, "\nError(offset %u): %s\n", + (unsigned)d.GetErrorOffset(), + GetParseError_En(d.GetParseError())); + free(readBuffer); + fclose(fp); + return 0; + } + + tariff = new parking_tariff_t(); + + if (d.HasMember(FREE_OF_CHARGE)) { + Value::MemberIterator o = d.FindMember(FREE_OF_CHARGE); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string foc = o->value.GetString(); + tariff->free_of_charge = std::stoi(foc); + } + if (d.HasMember(UNIT_SCALE_FACTOR)) { + Value::MemberIterator o = d.FindMember(UNIT_SCALE_FACTOR); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string usf = o->value.GetString(); + tariff->unit_scale_factor = std::stof(usf); + } + if (d.HasMember(UNIT_DEFINITION)) { + Value::MemberIterator o = d.FindMember(UNIT_DEFINITION); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string udef = o->value.GetString(); + tariff->unit_definition = std::stoi(udef); + } + if (d.HasMember(VAT)) { + Value::MemberIterator o = d.FindMember(VAT); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string vat = o->value.GetString(); + tariff->vat = std::stof(vat); + } + if (d.HasMember(MAX_PARKING_PRICE)) { + Value::MemberIterator o = d.FindMember(MAX_PARKING_PRICE); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string mp = o->value.GetString(); + if (mp == "unlimited") { + tariff->max_parking_price_units = ~0; + } else { + tariff->max_parking_price_units = (uint32_t)std::stoul(mp); + } + } + if (d.HasMember(MAX_PRICE_FOR_24_HOURS)) { + Value::MemberIterator o = d.FindMember(MAX_PRICE_FOR_24_HOURS); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string mp = o->value.GetString(); + if (mp == "unlimited") { + tariff->max_price_for_24_hours = ~0; + } else { + tariff->max_price_for_24_hours = (uint32_t)std::stoul(mp); + } + } + if (d.HasMember(MAX_PARKING_TIME)) { + Value::MemberIterator o = d.FindMember(MAX_PARKING_TIME); + assert(o != d.MemberEnd()); + assert(o->value.IsString()); + std::string mp = o->value.GetString(); + if (mp == "unlimited") { + tariff->max_parking_time = ~0; + } else { + tariff->max_parking_time = (uint32_t)std::stoul(mp); + } + } + + QDate today = QDate::currentDate(); + + int const todayWeekDay = today.dayOfWeek(); // qt: 1 (mon) - 7 (sun) + if (todayWeekDay > Qt::Monday) { + int day = today.day(); + day -= (todayWeekDay - Qt::Monday); + if (!today.setDate(today.year(), today.month(), day)) { + qFatal("Setting today failed"); + } + } + + assert(today.dayOfWeek() == Qt::Monday); + QDate monday = today; + + // "week1" : { + for (int w = 0; w < 3; ++w) { + assert(d.HasMember(weekStr[w])); + + // "Monday": { + for (int j = Qt::Monday - 1; j < Qt::Sunday; ++j) { + QDateTime startMinute(monday.addDays(w*7+j), QTime( 0, 0)); + + Value::MemberIterator wObj = d.FindMember(weekStr[w]); + assert(wObj != d.MemberEnd()); + assert(wObj->value.IsObject()); + + Value::MemberIterator stepsForDay = wObj->value.FindMember(weekDayStr[j]); + assert(stepsForDay != wObj->value.MemberEnd()); + assert(stepsForDay->value.IsObject()); + + // name : time, price, next-tariff-step + // "000000" : [ "00:00", "800000", "000001" ], + // "000001" : [ "07:00", "350000", "000002" ], + // ... + // "000014" : [ "20:00", "800000", "000011" ] + // }, + int k = 0; + for (Value::ConstMemberIterator step = stepsForDay->value.MemberBegin(); + step != stepsForDay->value.MemberEnd(); ++step) { + + assert(step->name.IsString()); + assert(step->value.IsArray()); + + QString name(step->name.GetString()); + + int const week = name.midRef(0, 1).toInt(); + int const weekDay = name.midRef(1, 1).toInt(); + int const stepIndex = name.midRef(2).toInt(); + + assert(w == week); + assert(j == weekDay); + assert(k == stepIndex); + + uint32_t price_units = QString(step->value[STEP_PRICE].GetString()).toUInt(); + QString next = QString(step->value[STEP_NEXT].GetString()); + + int const nextWeek = next.midRef(0, 1).toInt(); + int const nextWeekDay = next.midRef(1, 1).toInt(); + int const nextStepIndex = next.midRef(2).toInt(); + + //qDebug() << startMinute.addSecs(stepIndex*60) + // << "(" << week << weekDay << stepIndex << ")" + // << "(" << nextWeek << nextWeekDay << nextStepIndex << ")"; + + tariff->m_tariffSteps[week][weekDay][stepIndex] = + TariffStep(startMinute.addSecs(stepIndex*60), + price_units, + &tariff->m_tariffSteps[nextWeek][nextWeekDay][nextStepIndex]); + + ++k; + } + } + } + free(readBuffer); + +#if 0 + for (int w = 0; w < 3; ++w) { + for (int j = Qt::Monday - 1; j < Qt::Sunday; ++j) { + for (int k = 0; k < MIN_PER_DAY; ++k) { + //if (tariff->m_tariffSteps[w][j][k].next()) { + TariffStep const *s = &tariff->m_tariffSteps[w][j][k]; + qDebug() << s->dateTime() << s->price() << "next:" << s->next()->dateTime(); + //} + } + } + } +#endif + } + fclose(fp); + } + + return tariff; +} + diff --git a/calculate_parking_tickets/calculate_parking_tickets_tariff.h b/calculate_parking_tickets/calculate_parking_tickets_tariff.h new file mode 100644 index 0000000..003a87d --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_tariff.h @@ -0,0 +1,218 @@ +#ifndef CALCULATE_PARKING_TICKETS_TARIFF_H_INCLUDED +#define CALCULATE_PARKING_TICKETS_TARIFF_H_INCLUDED + +#include "calculate_parking_tickets_global.h" +#include "calculate_parking_tickets_tariff_step.h" +#include +#include +#include +#include +#include + +struct parking_tariff_t { + // parking_tariff_t(); + static parking_tariff_t *parseTariff(const char *confFile); + + /// \brief Express computational units in cent. + /// + /// The internal computations do not use the unit "cent" \n + /// directly. Rather virtual integer value unit_definition is used, expressing \n + /// how many cents correspond to unit_definition units. + uint32_t unit_definition; + + /// \brief Scale units to cent. + /// + double unit_scale_factor; + + /// \brief VAT (Mehrwertsteuer) in percent. + /// + double vat; + + QSet holidays; + + /// + /// \brief m_tariffSteps + /// + TariffStep m_tariffSteps[3][7][MIN_PER_DAY]; + + /// + /// \brief waiting_period + /// @note Also called "Karenzzeit". Allowed values: [0, 3] + // minute_t waiting_period; + + /// + /// \brief free_of_charge + /// + minute_t free_of_charge; + + /// + /// \brief max_parking_time + /// + minute_t max_parking_time = -1; + + /// + /// \brief max_parking_price_units + /// + uint32_t max_parking_price_units; + + /// + /// \brief max_price_for_24_hours + /// + uint32_t max_price_for_24_hours; // 24h limit (default -1) + +#if 0 + /// Minimal amount of money for buying a ticket. + /// + /// The minimal amount of money a user has to provide \n + /// to get a valid (parking) ticket. + uint32_t money_min; + + /// + /// \brief Minimal parking time. + /// + /// Minimal parking time. The full parking time must be \n + /// a multiple of @see parking_time_min. + minute_t parking_time_min; + + /// + /// \brief Maximal parking time. Must be a multiple of @see parking_time_min. + /// + minute_t parking_time_max; + + /// + /// \brief integration_time_max + /// Maximal possible integration time, i.e. the time after which all tickets + /// will be closed. + /// \note parking_time_max <= integration_time_max. + minute_t integration_time_max; + + /// + /// \brief tages_ticket_uebertrag + /// + bool tages_ticket_uebertrag; + + /// + /// \brief free_of_charge_uebertrag + /// Carry FOC (usually at midnight) or not. + /// The default setting is true. + bool free_of_charge_uebertrag; + + /// \brief Time for optionally changing tariff-table. + /// + /// Depending on the configuration, a table in the tariff can be swapped + /// in, typically at midnight. But it is also possible that this event happens + /// during the day. + /// @note 0 ≤ tariff_deadline $lt; 1440 + minute_t tages_ticket_offset; + + /// + /// \brief vorkauf + /// + /// Maximal time in minutes before business hours where a presales + /// ("vorkauf") operation is possible. + minute_t vorkauf; + + /// \brief Memory consumption of calculate price algorithm + uint32_t memory_consumption; + + /// + /// Time-range which is free of charge. + /// + struct free_of_charge_range_t free_of_charge; + + /// + /// \brief business_hours + /// + struct business_hours_range_t business_hours; + + + /// Array of possible days: DEFAULT, SUN - SAT plus HOLIDAY. + /// + day_t *day[DAYS]; + + /// Pointer to current day in tariff-table. + /// + day_t *current_day; + + /// Array of holiday dates. Format: YYYY:MM:DD + /// + holiday_date_t *holiday_date; + + /// + /// \brief algorithm_features + /// + uint16_t algorithm_features; + + /// + /// \brief tariff_features + /// + /// @todo: add comment + uint64_t tariff_features; + + /// + /// \brief _tariff_features + /// + /// @todo: add comment + uint64_t _tariff_features[64]; + + /// + /// @brief closed_tickets_local_end_times + /// + /// @note The end times of all closed tickets: the possible values are + /// 0 <= end_time <= 168h. + /// + bool closed_tickets_sorted; + + /// + /// \brief closed_tickets_count + /// + /// @note Used internally for optimizations. + int closed_tickets_count; + + /// + /// \brief closed_tickets + /// @todo: add comment + ticket_t *closed_tickets[NUMBER_OF_TICKETS]; + + /// + /// \brief tariff_step_min + /// + /// @todo: add comment + time_t tariff_step_min; + + /// + /// \brief tariff_step_max + /// + /// @todo: add comment + time_t tariff_step_max; + + /// + /// \brief tariff_version + /// Version for a given config-file, associated to a given tariff. + char tariff_version[64]; + + /// + /// \brief free_of_charge_at_start; + /// + /// Free-of-charge minutes at beginning of tariff computation + /// + uint16_t free_of_charge_at_start; + + /// + /// \brief repeated_default_without_carryover + /// + /// Setting describing a special tariff: + /// - All days are equal + /// - 24:00 is a "tariff-schnitt" (=without_carryover) + /// (i.e. computation is carried out + /// on a per day basis. Total price is the sum of all days.) + bool repeated_default_without_carryover; + + /// + /// \brief waiting_period + /// @note Also called "Karenzzeit". Allowed values: [0, 3] + minute_t waiting_period; +#endif +}; + +#endif // CALCULATE_PARKING_TICKETS_TARIFF_H_INCLUDED diff --git a/calculate_parking_tickets/calculate_parking_tickets_tariff_step.cpp b/calculate_parking_tickets/calculate_parking_tickets_tariff_step.cpp new file mode 100644 index 0000000..5fbb820 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_tariff_step.cpp @@ -0,0 +1,3 @@ +#include "calculate_parking_tickets_tariff_step.h" + +int TariffStep::m_offsetInDays = 0; diff --git a/calculate_parking_tickets/calculate_parking_tickets_tariff_step.h b/calculate_parking_tickets/calculate_parking_tickets_tariff_step.h new file mode 100644 index 0000000..ae86ce4 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_tariff_step.h @@ -0,0 +1,78 @@ +#ifndef CALCULATE_PARKING_TICKET_TARIFF_STEP_H_INCLUDED +#define CALCULATE_PARKING_TICKET_TARIFF_STEP_H_INCLUDED + +#include +#include +#include +#include + +/// +/// \brief The TariffStep class +/// +/// Ein Berechnungsschritt kann alles sein zwischen einer Minute und einem Tag. +/// Jeder Tag wird zerlegt in 1440 Berechnungsschritte. + +class TariffStep { + QDateTime m_datetime; // minute since start of tariff calculation + int m_dayOfWeek; + uint32_t m_price; + TariffStep const *m_next; + + static int m_offsetInDays; + +public: + // static setOffsetinDays(int offsetInDays) { m_offsetInDays = offsetInDays; } + + TariffStep() + : m_datetime(QDateTime()) + , m_dayOfWeek(-1) + , m_price(0) + , m_next(nullptr) { + } + + TariffStep(QDateTime const &datetime, + uint32_t price, + TariffStep const *next) + : m_datetime(datetime) + , m_dayOfWeek(m_datetime.isValid() ? m_datetime.date().dayOfWeek() : -1) + , m_price(price) + , m_next(next) { + + } + + TariffStep const *next() const { return m_next; } + //TariffStep *next() { return m_next; } + + int dayOfWeek() const { return m_dayOfWeek; } + + bool contains(QTime const &minute) const { + if (dateTime().isValid() + && minute.isValid() + && m_next && m_next->dateTime().isValid()) { + if (dayOfWeek() == m_next->dayOfWeek()) { + return + (dateTime().time() <= minute + && minute < m_next->dateTime().time()); + } + return (dateTime().time() <= minute); + } + return false; + } + + uint16_t startHour() { + return m_datetime.time().hour(); + } + + uint32_t price() const { return m_price; } + bool isValid() { return m_datetime.isValid(); } + TariffStep const *address() { return this; } + + void setPrice(uint32_t price) { m_price = price; } + void setDateTime(QDateTime const &datetime) { m_datetime = datetime; } + void setNextTariffStep(TariffStep *const next) { m_next = next; } + + QDateTime &dateTime() { return m_datetime; } + QDateTime const &dateTime() const { return m_datetime; } +}; + +#endif // CALCULATE_PARKING_TICKET_TARIFF_STEP_H_INCLUDED diff --git a/calculate_parking_tickets/calculate_parking_tickets_utils.cpp b/calculate_parking_tickets/calculate_parking_tickets_utils.cpp new file mode 100644 index 0000000..fbd3621 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_utils.cpp @@ -0,0 +1,158 @@ +#include "calculate_parking_tickets_utils.h" +#include "calculate_parking_tickets_tariff.h" + +#include +#include + +namespace TUtils { + bool isHoliday(parking_tariff_t const *tariff, QDate const &qd) { + for (int s = 0; s < tariff->holidays.size(); ++s) { + if (tariff->holidays.contains(qd)) { + qDebug() << "Holiday"; + return true; + } + } + qDebug() << "No Holiday"; + return false; + } + + QDateTime const fromSecs(quint64 secs) { + QDateTime dateTime; + dateTime.setSecsSinceEpoch(0); + return dateTime.addSecs(secs); + } + + QDateTime const fromMinutes(quint64 minutes) { + return fromSecs(minutes*60); + } + + quint64 toSecs(QDateTime const &dt) { + return dt.toSecsSinceEpoch(); + } + + quint64 toMinutes(QDateTime const &dt) { + return dt.toSecsSinceEpoch()/60; + } + + // Monday + bool isMon(quint64 secs) { + return (fromSecs(secs).date().dayOfWeek() == Qt::Monday); + } + bool isMon(QDate const &date) { + return (date.dayOfWeek() == Qt::Monday); + } + bool isMonUTC(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::UTC).date().dayOfWeek() == Qt::Monday); + } + bool isMonCET(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::LocalTime).date().dayOfWeek() == Qt::Monday); + } + bool isMonUTC(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Monday); + } + bool isMonCET(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Monday); + } + + // Tuesday + bool isTue(QDate const &date) { + return (date.dayOfWeek() == Qt::Tuesday); + } + bool isTueUTC(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::UTC).date().dayOfWeek() == Qt::Tuesday); + } + bool isTueCET(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::LocalTime).date().dayOfWeek() == Qt::Tuesday); + } + bool isTueUTC(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Tuesday); + } + bool isTueCET(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Tuesday); + } + + // Wednesday + bool isWed(QDate const &date) { + return (date.dayOfWeek() == Qt::Wednesday); + } + bool isWedUTC(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::UTC).date().dayOfWeek() == Qt::Wednesday); + } + bool isWedCET(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::LocalTime).date().dayOfWeek() == Qt::Wednesday); + } + bool isWedUTC(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Wednesday); + } + bool isWedCET(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Wednesday); + } + + // Thursday + bool isThu(QDate const &date) { + return (date.dayOfWeek() == Qt::Thursday); + } + bool isThuUTC(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::UTC).date().dayOfWeek() == Qt::Thursday); + } + bool isThuCET(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::LocalTime).date().dayOfWeek() == Qt::Thursday); + } + bool isThuUTC(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Thursday); + } + bool isThuCET(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Thursday); + } + + // Friday + bool isFri(QDate const &date) { + return (date.dayOfWeek() == Qt::Friday); + } + bool isFriUTC(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::UTC).date().dayOfWeek() == Qt::Friday); + } + bool isFriCET(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::LocalTime).date().dayOfWeek() == Qt::Friday); + } + bool isFriUTC(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Friday); + } + bool isFriCET(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Friday); + } + + // Saturday + bool isSat(QDate const &date) { + return (date.dayOfWeek() == Qt::Saturday); + } + bool isSatUTC(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::UTC).date().dayOfWeek() == Qt::Saturday); + } + bool isSatCET(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::LocalTime).date().dayOfWeek() == Qt::Saturday); + } + bool isSatUTC(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Saturday); + } + bool isSatCET(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Saturday); + } + + // Sunday + bool isSun(QDate const &date) { + return (date.dayOfWeek() == Qt::Sunday); + } + bool isSunUTC(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::UTC).date().dayOfWeek() == Qt::Sunday); + } + bool isSunCET(quint64 secsSinceEpoch) { + return (QDateTime::fromSecsSinceEpoch(secsSinceEpoch, Qt::LocalTime).date().dayOfWeek() == Qt::Sunday); + } + bool isSunUTC(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Sunday); + } + bool isSunCET(QDate const &dateSinceEpoch) { + return (dateSinceEpoch.dayOfWeek() == Qt::Sunday); + } +} diff --git a/calculate_parking_tickets/calculate_parking_tickets_utils.h b/calculate_parking_tickets/calculate_parking_tickets_utils.h new file mode 100644 index 0000000..21a1c41 --- /dev/null +++ b/calculate_parking_tickets/calculate_parking_tickets_utils.h @@ -0,0 +1,64 @@ +#ifndef CALCULATE_PARKING_TICKETS_UTILS_H_INCLUDED +#define CALCULATE_PARKING_TICKETS_UTILS_H_INCLUDED + +#include +#include +#include +#include + +struct parking_tariff_t; + +namespace TUtils { + QDateTime const fromSecs(quint64 secs); + QDateTime const fromMinutes(quint64 minutes); + + quint64 toSecs(QDateTime const &dt); + quint64 toMinutes(QDateTime const &dt); + + bool isHoliday(parking_tariff_t const *tariff, QDate const &qdt); + + bool isMon(quint64 secs); + bool isMon(QDate const &date); + bool isMonUTC(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isMonUTC(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch(), Qt::UTC).date()); + bool isMonCET(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isMonCET(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch()).date()); + + bool isTue(QDate const &date); + bool isTueUTC(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isTueUTC(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch(), Qt::UTC).date()); + bool isTueCET(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isTueCET(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch()).date()); + + bool isWed(QDate const &date); + bool isWedUTC(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isWedUTC(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch(), Qt::UTC).date()); + bool isWedCET(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isWedCET(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch()).date()); + + bool isThu(QDate const &date); + bool isThuUTC(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isThuUTC(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch(), Qt::UTC).date()); + bool isThuCET(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isThuCET(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch()).date()); + + bool isFri(QDate const &date); + bool isFriUTC(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isFriUTC(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch(), Qt::UTC).date()); + bool isFriCET(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isFriCET(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch()).date()); + + bool isSat(QDate const &date); + bool isSatUTC(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isSatUTC(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch(), Qt::UTC).date()); + bool isSatCET(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isSatCET(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch()).date()); + + bool isSun(QDate const &date); + bool isSunUTC(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isSunUTC(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch(), Qt::UTC).date()); + bool isSunCET(quint64 secsSinceEpoch = QDateTime::currentSecsSinceEpoch()); + bool isSunCET(QDate const &dateSinceEpoch = QDateTime::fromSecsSinceEpoch(QDateTime::currentSecsSinceEpoch()).date()); +} + +#endif // CALCULATE_PARKING_TICKETS_UTILS_H_INCLUDED diff --git a/calculate_parking_tickets/erlangen.conf b/calculate_parking_tickets/erlangen.conf new file mode 100644 index 0000000..7e71d19 --- /dev/null +++ b/calculate_parking_tickets/erlangen.conf @@ -0,0 +1,562 @@ +{ + "name" : "Tarif Erlangen", + "description" : [ + "erste 90 Min = 0 Euro", + "jede weitere 60 Min = 1,20 Euro", + "tagesmax: 7,20 Euro" + ], + "properties": [ + ], + "week1" : { + "Monday": { + "TariffStep000" : [ "00:00", "120000", "TariffStep001" ], + "TariffStep001" : [ "01:00", "120000", "TariffStep002" ], + "TariffStep002" : [ "02:00", "120000", "TariffStep003" ], + "TariffStep003" : [ "03:00", "120000", "TariffStep004" ], + "TariffStep004" : [ "04:00", "120000", "TariffStep005" ], + "TariffStep005" : [ "05:00", "120000", "TariffStep006" ], + "TariffStep006" : [ "06:00", "120000", "TariffStep007" ], + "TariffStep007" : [ "07:00", "120000", "TariffStep008" ], + "TariffStep008" : [ "08:00", "120000", "TariffStep009" ], + "TariffStep009" : [ "09:00", "120000", "TariffStep0010"], + "TariffStep0010" : [ "10:00", "120000", "TariffStep0011"], + "TariffStep0011" : [ "11:00", "120000", "TariffStep0012"], + "TariffStep0012" : [ "12:00", "120000", "TariffStep0013"], + "TariffStep0013" : [ "13:00", "120000", "TariffStep0014"], + "TariffStep0014" : [ "14:00", "120000", "TariffStep0015"], + "TariffStep0015" : [ "15:00", "120000", "TariffStep0016"], + "TariffStep0016" : [ "16:00", "120000", "TariffStep0017"], + "TariffStep0017" : [ "17:00", "120000", "TariffStep0018"], + "TariffStep0018" : [ "18:00", "120000", "TariffStep0019"], + "TariffStep0019" : [ "19:00", "120000", "TariffStep0020"], + "TariffStep0020" : [ "20:00", "120000", "TariffStep0021"], + "TariffStep0021" : [ "21:00", "120000", "TariffStep0022"], + "TariffStep0022" : [ "22:00", "120000", "TariffStep0023"], + "TariffStep0023" : [ "23:00", "120000", "TariffStep010" ] + }, + "Tuesday": { + "TariffStep010" : [ "00:00", "120000", "TariffStep011" ], + "TariffStep011" : [ "01:00", "120000", "TariffStep012" ], + "TariffStep012" : [ "02:00", "120000", "TariffStep013" ], + "TariffStep013" : [ "03:00", "120000", "TariffStep014" ], + "TariffStep014" : [ "04:00", "120000", "TariffStep015" ], + "TariffStep015" : [ "05:00", "120000", "TariffStep016" ], + "TariffStep016" : [ "06:00", "120000", "TariffStep017" ], + "TariffStep017" : [ "07:00", "120000", "TariffStep018" ], + "TariffStep018" : [ "08:00", "120000", "TariffStep019" ], + "TariffStep019" : [ "09:00", "120000", "TariffStep0110"], + "TariffStep0110" : [ "10:00", "120000", "TariffStep0111"], + "TariffStep0111" : [ "11:00", "120000", "TariffStep0112"], + "TariffStep0112" : [ "12:00", "120000", "TariffStep0113"], + "TariffStep0113" : [ "13:00", "120000", "TariffStep0114"], + "TariffStep0114" : [ "14:00", "120000", "TariffStep0115"], + "TariffStep0115" : [ "15:00", "120000", "TariffStep0116"], + "TariffStep0116" : [ "16:00", "120000", "TariffStep0117"], + "TariffStep0117" : [ "17:00", "120000", "TariffStep0118"], + "TariffStep0118" : [ "18:00", "120000", "TariffStep0119"], + "TariffStep0119" : [ "19:00", "120000", "TariffStep0120"], + "TariffStep0120" : [ "20:00", "120000", "TariffStep0121"], + "TariffStep0121" : [ "21:00", "120000", "TariffStep0122"], + "TariffStep0122" : [ "22:00", "120000", "TariffStep0123"], + "TariffStep0123" : [ "23:00", "120000", "TariffStep020" ] + }, + "Wednesday": { + "TariffStep020" : [ "00:00", "120000", "TariffStep021" ], + "TariffStep021" : [ "01:00", "120000", "TariffStep022" ], + "TariffStep022" : [ "02:00", "120000", "TariffStep023" ], + "TariffStep023" : [ "03:00", "120000", "TariffStep024" ], + "TariffStep024" : [ "04:00", "120000", "TariffStep025" ], + "TariffStep025" : [ "05:00", "120000", "TariffStep026" ], + "TariffStep026" : [ "06:00", "120000", "TariffStep027" ], + "TariffStep027" : [ "07:00", "120000", "TariffStep028" ], + "TariffStep028" : [ "08:00", "120000", "TariffStep029" ], + "TariffStep029" : [ "09:00", "120000", "TariffStep0210"], + "TariffStep0210" : [ "10:00", "120000", "TariffStep0211"], + "TariffStep0211" : [ "11:00", "120000", "TariffStep0212"], + "TariffStep0212" : [ "12:00", "120000", "TariffStep0213"], + "TariffStep0213" : [ "13:00", "120000", "TariffStep0214"], + "TariffStep0214" : [ "14:00", "120000", "TariffStep0215"], + "TariffStep0215" : [ "15:00", "120000", "TariffStep0216"], + "TariffStep0216" : [ "16:00", "120000", "TariffStep0217"], + "TariffStep0217" : [ "17:00", "120000", "TariffStep0218"], + "TariffStep0218" : [ "18:00", "120000", "TariffStep0219"], + "TariffStep0219" : [ "19:00", "120000", "TariffStep0220"], + "TariffStep0220" : [ "20:00", "120000", "TariffStep0221"], + "TariffStep0221" : [ "21:00", "120000", "TariffStep0222"], + "TariffStep0222" : [ "22:00", "120000", "TariffStep0223"], + "TariffStep0223" : [ "23:00", "120000", "TariffStep030" ] + }, + "Thursday": { + "TariffStep030" : [ "00:00", "120000", "TariffStep031" ], + "TariffStep031" : [ "01:00", "120000", "TariffStep032" ], + "TariffStep032" : [ "02:00", "120000", "TariffStep033" ], + "TariffStep033" : [ "03:00", "120000", "TariffStep034" ], + "TariffStep034" : [ "04:00", "120000", "TariffStep035" ], + "TariffStep035" : [ "05:00", "120000", "TariffStep036" ], + "TariffStep036" : [ "06:00", "120000", "TariffStep037" ], + "TariffStep037" : [ "07:00", "120000", "TariffStep038" ], + "TariffStep038" : [ "08:00", "120000", "TariffStep039" ], + "TariffStep039" : [ "09:00", "120000", "TariffStep0310"], + "TariffStep0310" : [ "10:00", "120000", "TariffStep0311"], + "TariffStep0311" : [ "11:00", "120000", "TariffStep0312"], + "TariffStep0312" : [ "12:00", "120000", "TariffStep0313"], + "TariffStep0313" : [ "13:00", "120000", "TariffStep0314"], + "TariffStep0314" : [ "14:00", "120000", "TariffStep0315"], + "TariffStep0315" : [ "15:00", "120000", "TariffStep0316"], + "TariffStep0316" : [ "16:00", "120000", "TariffStep0317"], + "TariffStep0317" : [ "17:00", "120000", "TariffStep0318"], + "TariffStep0318" : [ "18:00", "120000", "TariffStep0319"], + "TariffStep0319" : [ "19:00", "120000", "TariffStep0320"], + "TariffStep0320" : [ "20:00", "120000", "TariffStep0321"], + "TariffStep0321" : [ "21:00", "120000", "TariffStep0322"], + "TariffStep0322" : [ "22:00", "120000", "TariffStep0323"], + "TariffStep0323" : [ "23:00", "120000", "TariffStep040" ] + }, + "Friday": { + "TariffStep040" : [ "00:00", "120000", "TariffStep041" ], + "TariffStep041" : [ "01:00", "120000", "TariffStep042" ], + "TariffStep042" : [ "02:00", "120000", "TariffStep043" ], + "TariffStep043" : [ "03:00", "120000", "TariffStep044" ], + "TariffStep044" : [ "04:00", "120000", "TariffStep045" ], + "TariffStep045" : [ "05:00", "120000", "TariffStep046" ], + "TariffStep046" : [ "06:00", "120000", "TariffStep047" ], + "TariffStep047" : [ "07:00", "120000", "TariffStep048" ], + "TariffStep048" : [ "08:00", "120000", "TariffStep049" ], + "TariffStep049" : [ "09:00", "120000", "TariffStep0410"], + "TariffStep0410" : [ "10:00", "120000", "TariffStep0411"], + "TariffStep0411" : [ "11:00", "120000", "TariffStep0412"], + "TariffStep0412" : [ "12:00", "120000", "TariffStep0413"], + "TariffStep0413" : [ "13:00", "120000", "TariffStep0414"], + "TariffStep0414" : [ "14:00", "120000", "TariffStep0415"], + "TariffStep0415" : [ "15:00", "120000", "TariffStep0416"], + "TariffStep0416" : [ "16:00", "120000", "TariffStep0417"], + "TariffStep0417" : [ "17:00", "120000", "TariffStep0418"], + "TariffStep0418" : [ "18:00", "120000", "TariffStep0419"], + "TariffStep0419" : [ "19:00", "120000", "TariffStep0420"], + "TariffStep0420" : [ "20:00", "120000", "TariffStep0421"], + "TariffStep0421" : [ "21:00", "120000", "TariffStep0422"], + "TariffStep0422" : [ "22:00", "120000", "TariffStep0423"], + "TariffStep0423" : [ "23:00", "120000", "TariffStep050" ] + }, + "Saturday": { + "TariffStep050" : [ "00:00", "120000", "TariffStep051" ], + "TariffStep051" : [ "01:00", "120000", "TariffStep052" ], + "TariffStep052" : [ "02:00", "120000", "TariffStep053" ], + "TariffStep053" : [ "03:00", "120000", "TariffStep054" ], + "TariffStep054" : [ "04:00", "120000", "TariffStep055" ], + "TariffStep055" : [ "05:00", "120000", "TariffStep056" ], + "TariffStep056" : [ "06:00", "120000", "TariffStep057" ], + "TariffStep057" : [ "07:00", "120000", "TariffStep058" ], + "TariffStep058" : [ "08:00", "120000", "TariffStep059" ], + "TariffStep059" : [ "09:00", "120000", "TariffStep0510"], + "TariffStep0510" : [ "10:00", "120000", "TariffStep0511"], + "TariffStep0511" : [ "11:00", "120000", "TariffStep0512"], + "TariffStep0512" : [ "12:00", "120000", "TariffStep0513"], + "TariffStep0513" : [ "13:00", "120000", "TariffStep0514"], + "TariffStep0514" : [ "14:00", "120000", "TariffStep0515"], + "TariffStep0515" : [ "15:00", "120000", "TariffStep0516"], + "TariffStep0516" : [ "16:00", "120000", "TariffStep0517"], + "TariffStep0517" : [ "17:00", "120000", "TariffStep0518"], + "TariffStep0518" : [ "18:00", "120000", "TariffStep0519"], + "TariffStep0519" : [ "19:00", "120000", "TariffStep0520"], + "TariffStep0520" : [ "20:00", "120000", "TariffStep0521"], + "TariffStep0521" : [ "21:00", "120000", "TariffStep0522"], + "TariffStep0522" : [ "22:00", "120000", "TariffStep0523"], + "TariffStep0523" : [ "23:00", "120000", "TariffStep060" ] + }, + "Sunday": { + "TariffStep060" : [ "00:00", "120000", "TariffStep061" ], + "TariffStep061" : [ "01:00", "120000", "TariffStep062" ], + "TariffStep062" : [ "02:00", "120000", "TariffStep063" ], + "TariffStep063" : [ "03:00", "120000", "TariffStep064" ], + "TariffStep064" : [ "04:00", "120000", "TariffStep065" ], + "TariffStep065" : [ "05:00", "120000", "TariffStep066" ], + "TariffStep066" : [ "06:00", "120000", "TariffStep067" ], + "TariffStep067" : [ "07:00", "120000", "TariffStep068" ], + "TariffStep068" : [ "08:00", "120000", "TariffStep069" ], + "TariffStep069" : [ "09:00", "120000", "TariffStep0610"], + "TariffStep0610" : [ "10:00", "120000", "TariffStep0611"], + "TariffStep0611" : [ "11:00", "120000", "TariffStep0612"], + "TariffStep0612" : [ "12:00", "120000", "TariffStep0613"], + "TariffStep0613" : [ "13:00", "120000", "TariffStep0614"], + "TariffStep0614" : [ "14:00", "120000", "TariffStep0615"], + "TariffStep0615" : [ "15:00", "120000", "TariffStep0616"], + "TariffStep0616" : [ "16:00", "120000", "TariffStep0617"], + "TariffStep0617" : [ "17:00", "120000", "TariffStep0618"], + "TariffStep0618" : [ "18:00", "120000", "TariffStep0619"], + "TariffStep0619" : [ "19:00", "120000", "TariffStep0620"], + "TariffStep0620" : [ "20:00", "120000", "TariffStep0621"], + "TariffStep0621" : [ "21:00", "120000", "TariffStep0622"], + "TariffStep0622" : [ "22:00", "120000", "TariffStep0623"], + "TariffStep0623" : [ "23:00", "120000", "TariffStep100" ] + } + }, + "week2" : { + "Monday": { + "TariffStep100" : [ "00:00", "120000", "TariffStep101" ], + "TariffStep101" : [ "01:00", "120000", "TariffStep102" ], + "TariffStep102" : [ "02:00", "120000", "TariffStep103" ], + "TariffStep103" : [ "03:00", "120000", "TariffStep104" ], + "TariffStep104" : [ "04:00", "120000", "TariffStep105" ], + "TariffStep105" : [ "05:00", "120000", "TariffStep106" ], + "TariffStep106" : [ "06:00", "120000", "TariffStep107" ], + "TariffStep107" : [ "07:00", "120000", "TariffStep108" ], + "TariffStep108" : [ "08:00", "120000", "TariffStep109" ], + "TariffStep109" : [ "09:00", "120000", "TariffStep1010"], + "TariffStep1010" : [ "10:00", "120000", "TariffStep1011"], + "TariffStep1011" : [ "11:00", "120000", "TariffStep1012"], + "TariffStep1012" : [ "12:00", "120000", "TariffStep1013"], + "TariffStep1013" : [ "13:00", "120000", "TariffStep1014"], + "TariffStep1014" : [ "14:00", "120000", "TariffStep1015"], + "TariffStep1015" : [ "15:00", "120000", "TariffStep1016"], + "TariffStep1016" : [ "16:00", "120000", "TariffStep1017"], + "TariffStep1017" : [ "17:00", "120000", "TariffStep1018"], + "TariffStep1018" : [ "18:00", "120000", "TariffStep1019"], + "TariffStep1019" : [ "19:00", "120000", "TariffStep1020"], + "TariffStep1020" : [ "20:00", "120000", "TariffStep1021"], + "TariffStep1021" : [ "21:00", "120000", "TariffStep1022"], + "TariffStep1022" : [ "22:00", "120000", "TariffStep1023"], + "TariffStep1023" : [ "23:00", "120000", "TariffStep110" ] + }, + "Tuesday": { + "TariffStep110" : [ "00:00", "120000", "TariffStep111" ], + "TariffStep111" : [ "01:00", "120000", "TariffStep112" ], + "TariffStep112" : [ "02:00", "120000", "TariffStep113" ], + "TariffStep113" : [ "03:00", "120000", "TariffStep114" ], + "TariffStep114" : [ "04:00", "120000", "TariffStep115" ], + "TariffStep115" : [ "05:00", "120000", "TariffStep116" ], + "TariffStep116" : [ "06:00", "120000", "TariffStep117" ], + "TariffStep117" : [ "07:00", "120000", "TariffStep118" ], + "TariffStep118" : [ "08:00", "120000", "TariffStep119" ], + "TariffStep119" : [ "09:00", "120000", "TariffStep1110"], + "TariffStep1110" : [ "10:00", "120000", "TariffStep1111"], + "TariffStep1111" : [ "11:00", "120000", "TariffStep1112"], + "TariffStep1112" : [ "12:00", "120000", "TariffStep1113"], + "TariffStep1113" : [ "13:00", "120000", "TariffStep1114"], + "TariffStep1114" : [ "14:00", "120000", "TariffStep1115"], + "TariffStep1115" : [ "15:00", "120000", "TariffStep1116"], + "TariffStep1116" : [ "16:00", "120000", "TariffStep1117"], + "TariffStep1117" : [ "17:00", "120000", "TariffStep1118"], + "TariffStep1118" : [ "18:00", "120000", "TariffStep1119"], + "TariffStep1119" : [ "19:00", "120000", "TariffStep1120"], + "TariffStep1120" : [ "20:00", "120000", "TariffStep1121"], + "TariffStep1121" : [ "21:00", "120000", "TariffStep1122"], + "TariffStep1122" : [ "22:00", "120000", "TariffStep1123"], + "TariffStep1123" : [ "23:00", "120000", "TariffStep120" ] + }, + "Wednesday": { + "TariffStep120" : [ "00:00", "120000", "TariffStep121" ], + "TariffStep121" : [ "01:00", "120000", "TariffStep122" ], + "TariffStep122" : [ "02:00", "120000", "TariffStep123" ], + "TariffStep123" : [ "03:00", "120000", "TariffStep124" ], + "TariffStep124" : [ "04:00", "120000", "TariffStep125" ], + "TariffStep125" : [ "05:00", "120000", "TariffStep126" ], + "TariffStep126" : [ "06:00", "120000", "TariffStep127" ], + "TariffStep127" : [ "07:00", "120000", "TariffStep128" ], + "TariffStep128" : [ "08:00", "120000", "TariffStep129" ], + "TariffStep129" : [ "09:00", "120000", "TariffStep1210"], + "TariffStep1210" : [ "10:00", "120000", "TariffStep1211"], + "TariffStep1211" : [ "11:00", "120000", "TariffStep1212"], + "TariffStep1212" : [ "12:00", "120000", "TariffStep1213"], + "TariffStep1213" : [ "13:00", "120000", "TariffStep1214"], + "TariffStep1214" : [ "14:00", "120000", "TariffStep1215"], + "TariffStep1215" : [ "15:00", "120000", "TariffStep1216"], + "TariffStep1216" : [ "16:00", "120000", "TariffStep1217"], + "TariffStep1217" : [ "17:00", "120000", "TariffStep1218"], + "TariffStep1218" : [ "18:00", "120000", "TariffStep1219"], + "TariffStep1219" : [ "19:00", "120000", "TariffStep1220"], + "TariffStep1220" : [ "20:00", "120000", "TariffStep1221"], + "TariffStep1221" : [ "21:00", "120000", "TariffStep1222"], + "TariffStep1222" : [ "22:00", "120000", "TariffStep1223"], + "TariffStep1223" : [ "23:00", "120000", "TariffStep130" ] + }, + "Thursday": { + "TariffStep130" : [ "00:00", "120000", "TariffStep131" ], + "TariffStep131" : [ "01:00", "120000", "TariffStep132" ], + "TariffStep132" : [ "02:00", "120000", "TariffStep133" ], + "TariffStep133" : [ "03:00", "120000", "TariffStep134" ], + "TariffStep134" : [ "04:00", "120000", "TariffStep135" ], + "TariffStep135" : [ "05:00", "120000", "TariffStep136" ], + "TariffStep136" : [ "06:00", "120000", "TariffStep137" ], + "TariffStep137" : [ "07:00", "120000", "TariffStep138" ], + "TariffStep138" : [ "08:00", "120000", "TariffStep139" ], + "TariffStep139" : [ "09:00", "120000", "TariffStep1310"], + "TariffStep1310" : [ "10:00", "120000", "TariffStep1311"], + "TariffStep1311" : [ "11:00", "120000", "TariffStep1312"], + "TariffStep1312" : [ "12:00", "120000", "TariffStep1313"], + "TariffStep1313" : [ "13:00", "120000", "TariffStep1314"], + "TariffStep1314" : [ "14:00", "120000", "TariffStep1315"], + "TariffStep1315" : [ "15:00", "120000", "TariffStep1316"], + "TariffStep1316" : [ "16:00", "120000", "TariffStep1317"], + "TariffStep1317" : [ "17:00", "120000", "TariffStep1318"], + "TariffStep1318" : [ "18:00", "120000", "TariffStep1319"], + "TariffStep1319" : [ "19:00", "120000", "TariffStep1320"], + "TariffStep1320" : [ "20:00", "120000", "TariffStep1321"], + "TariffStep1321" : [ "21:00", "120000", "TariffStep1322"], + "TariffStep1322" : [ "22:00", "120000", "TariffStep1323"], + "TariffStep1323" : [ "23:00", "120000", "TariffStep140" ] + }, + "Friday": { + "TariffStep140" : [ "00:00", "120000", "TariffStep141" ], + "TariffStep141" : [ "01:00", "120000", "TariffStep142" ], + "TariffStep142" : [ "02:00", "120000", "TariffStep143" ], + "TariffStep143" : [ "03:00", "120000", "TariffStep144" ], + "TariffStep144" : [ "04:00", "120000", "TariffStep145" ], + "TariffStep145" : [ "05:00", "120000", "TariffStep146" ], + "TariffStep146" : [ "06:00", "120000", "TariffStep147" ], + "TariffStep147" : [ "07:00", "120000", "TariffStep148" ], + "TariffStep148" : [ "08:00", "120000", "TariffStep149" ], + "TariffStep149" : [ "09:00", "120000", "TariffStep1410" ], + "TariffStep1410" : [ "10:00", "120000", "TariffStep1411" ], + "TariffStep1411" : [ "11:00", "120000", "TariffStep1412" ], + "TariffStep1412" : [ "12:00", "120000", "TariffStep1413" ], + "TariffStep1413" : [ "13:00", "120000", "TariffStep1414" ], + "TariffStep1414" : [ "14:00", "120000", "TariffStep1415" ], + "TariffStep1415" : [ "15:00", "120000", "TariffStep1416"], + "TariffStep1416" : [ "16:00", "120000", "TariffStep1417"], + "TariffStep1417" : [ "17:00", "120000", "TariffStep1418"], + "TariffStep1418" : [ "18:00", "120000", "TariffStep1419"], + "TariffStep1419" : [ "19:00", "120000", "TariffStep1420"], + "TariffStep1420" : [ "20:00", "120000", "TariffStep1421" ], + "TariffStep1421" : [ "21:00", "120000", "TariffStep1422" ], + "TariffStep1422" : [ "22:00", "120000", "TariffStep1423" ], + "TariffStep1423" : [ "23:00", "120000", "TariffStep150" ] + }, + "Saturday": { + "TariffStep150" : [ "00:00", "120000", "TariffStep151" ], + "TariffStep151" : [ "01:00", "120000", "TariffStep152" ], + "TariffStep152" : [ "02:00", "120000", "TariffStep153" ], + "TariffStep153" : [ "03:00", "120000", "TariffStep154" ], + "TariffStep154" : [ "04:00", "120000", "TariffStep155" ], + "TariffStep155" : [ "05:00", "120000", "TariffStep156" ], + "TariffStep156" : [ "06:00", "120000", "TariffStep157" ], + "TariffStep157" : [ "07:00", "120000", "TariffStep158" ], + "TariffStep158" : [ "08:00", "120000", "TariffStep159" ], + "TariffStep159" : [ "09:00", "120000", "TariffStep1510"], + "TariffStep1510" : [ "10:00", "120000", "TariffStep1511"], + "TariffStep1511" : [ "11:00", "120000", "TariffStep1512"], + "TariffStep1512" : [ "12:00", "120000", "TariffStep1513"], + "TariffStep1513" : [ "13:00", "120000", "TariffStep1514"], + "TariffStep1514" : [ "14:00", "120000", "TariffStep1515"], + "TariffStep1515" : [ "15:00", "120000", "TariffStep1516"], + "TariffStep1516" : [ "16:00", "120000", "TariffStep1517"], + "TariffStep1517" : [ "17:00", "120000", "TariffStep1518"], + "TariffStep1518" : [ "18:00", "120000", "TariffStep1519"], + "TariffStep1519" : [ "19:00", "120000", "TariffStep1520"], + "TariffStep1520" : [ "20:00", "120000", "TariffStep1521"], + "TariffStep1521" : [ "21:00", "120000", "TariffStep1522"], + "TariffStep1522" : [ "22:00", "120000", "TariffStep1523"], + "TariffStep1523" : [ "23:00", "120000", "TariffStep160" ] + }, + "Sunday": { + "TariffStep160" : [ "00:00", "120000", "TariffStep161" ], + "TariffStep161" : [ "01:00", "120000", "TariffStep162" ], + "TariffStep162" : [ "02:00", "120000", "TariffStep163" ], + "TariffStep163" : [ "03:00", "120000", "TariffStep164" ], + "TariffStep164" : [ "04:00", "120000", "TariffStep165" ], + "TariffStep165" : [ "05:00", "120000", "TariffStep166" ], + "TariffStep166" : [ "06:00", "120000", "TariffStep167" ], + "TariffStep167" : [ "07:00", "120000", "TariffStep168" ], + "TariffStep168" : [ "08:00", "120000", "TariffStep169" ], + "TariffStep169" : [ "09:00", "120000", "TariffStep1610"], + "TariffStep1610" : [ "10:00", "120000", "TariffStep1611"], + "TariffStep1611" : [ "11:00", "120000", "TariffStep1612"], + "TariffStep1612" : [ "12:00", "120000", "TariffStep1613"], + "TariffStep1613" : [ "13:00", "120000", "TariffStep1614"], + "TariffStep1614" : [ "14:00", "120000", "TariffStep1615"], + "TariffStep1615" : [ "15:00", "120000", "TariffStep1616"], + "TariffStep1616" : [ "16:00", "120000", "TariffStep1617"], + "TariffStep1617" : [ "17:00", "120000", "TariffStep1618"], + "TariffStep1618" : [ "18:00", "120000", "TariffStep1619"], + "TariffStep1619" : [ "19:00", "120000", "TariffStep1620"], + "TariffStep1620" : [ "20:00", "120000", "TariffStep1621"], + "TariffStep1621" : [ "21:00", "120000", "TariffStep1622"], + "TariffStep1622" : [ "22:00", "120000", "TariffStep1623"], + "TariffStep1623" : [ "23:00", "120000", "TariffStep200" ] + } + }, + "week3" : { + "Monday": { + "TariffStep200" : [ "00:00", "120000", "TariffStep201" ], + "TariffStep201" : [ "01:00", "120000", "TariffStep202" ], + "TariffStep202" : [ "02:00", "120000", "TariffStep203" ], + "TariffStep203" : [ "03:00", "120000", "TariffStep204" ], + "TariffStep204" : [ "04:00", "120000", "TariffStep205" ], + "TariffStep205" : [ "05:00", "120000", "TariffStep206" ], + "TariffStep206" : [ "06:00", "120000", "TariffStep207" ], + "TariffStep207" : [ "07:00", "120000", "TariffStep208" ], + "TariffStep208" : [ "08:00", "120000", "TariffStep209" ], + "TariffStep209" : [ "09:00", "120000", "TariffStep2010"], + "TariffStep2010" : [ "10:00", "120000", "TariffStep2011"], + "TariffStep2011" : [ "11:00", "120000", "TariffStep2012"], + "TariffStep2012" : [ "12:00", "120000", "TariffStep2013"], + "TariffStep2013" : [ "13:00", "120000", "TariffStep2014"], + "TariffStep2014" : [ "14:00", "120000", "TariffStep2015"], + "TariffStep2015" : [ "15:00", "120000", "TariffStep2016"], + "TariffStep2016" : [ "16:00", "120000", "TariffStep2017"], + "TariffStep2017" : [ "17:00", "120000", "TariffStep2018"], + "TariffStep2018" : [ "18:00", "120000", "TariffStep2019"], + "TariffStep2019" : [ "19:00", "120000", "TariffStep2020"], + "TariffStep2020" : [ "20:00", "120000", "TariffStep2021"], + "TariffStep2021" : [ "21:00", "120000", "TariffStep2022"], + "TariffStep2022" : [ "22:00", "120000", "TariffStep2023"], + "TariffStep2023" : [ "23:00", "120000", "TariffStep210" ] + }, + "Tuesday": { + "TariffStep210" : [ "00:00", "120000", "TariffStep211" ], + "TariffStep211" : [ "01:00", "120000", "TariffStep212" ], + "TariffStep212" : [ "02:00", "120000", "TariffStep213" ], + "TariffStep213" : [ "03:00", "120000", "TariffStep214" ], + "TariffStep214" : [ "04:00", "120000", "TariffStep215" ], + "TariffStep215" : [ "05:00", "120000", "TariffStep216" ], + "TariffStep216" : [ "06:00", "120000", "TariffStep217" ], + "TariffStep217" : [ "07:00", "120000", "TariffStep218" ], + "TariffStep218" : [ "08:00", "120000", "TariffStep219" ], + "TariffStep219" : [ "09:00", "120000", "TariffStep2110"], + "TariffStep2110" : [ "10:00", "120000", "TariffStep2111"], + "TariffStep2111" : [ "11:00", "120000", "TariffStep2112"], + "TariffStep2112" : [ "12:00", "120000", "TariffStep2113"], + "TariffStep2113" : [ "13:00", "120000", "TariffStep2114"], + "TariffStep2114" : [ "14:00", "120000", "TariffStep2115"], + "TariffStep2115" : [ "15:00", "120000", "TariffStep2116"], + "TariffStep2116" : [ "16:00", "120000", "TariffStep2117"], + "TariffStep2117" : [ "17:00", "120000", "TariffStep2118"], + "TariffStep2118" : [ "18:00", "120000", "TariffStep2119"], + "TariffStep2119" : [ "19:00", "120000", "TariffStep2120"], + "TariffStep2120" : [ "20:00", "120000", "TariffStep2121"], + "TariffStep2121" : [ "21:00", "120000", "TariffStep2122"], + "TariffStep2122" : [ "22:00", "120000", "TariffStep2123"], + "TariffStep2123" : [ "23:00", "120000", "TariffStep220" ] + }, + "Wednesday": { + "TariffStep220" : [ "00:00", "120000", "TariffStep221" ], + "TariffStep221" : [ "01:00", "120000", "TariffStep222" ], + "TariffStep222" : [ "02:00", "120000", "TariffStep223" ], + "TariffStep223" : [ "03:00", "120000", "TariffStep224" ], + "TariffStep224" : [ "04:00", "120000", "TariffStep225" ], + "TariffStep225" : [ "05:00", "120000", "TariffStep226" ], + "TariffStep226" : [ "06:00", "120000", "TariffStep227" ], + "TariffStep227" : [ "07:00", "120000", "TariffStep228" ], + "TariffStep228" : [ "08:00", "120000", "TariffStep229" ], + "TariffStep229" : [ "09:00", "120000", "TariffStep2210"], + "TariffStep2210" : [ "10:00", "120000", "TariffStep2211"], + "TariffStep2211" : [ "11:00", "120000", "TariffStep2212"], + "TariffStep2212" : [ "12:00", "120000", "TariffStep2213"], + "TariffStep2213" : [ "13:00", "120000", "TariffStep2214"], + "TariffStep2214" : [ "14:00", "120000", "TariffStep2215"], + "TariffStep2215" : [ "15:00", "120000", "TariffStep2216"], + "TariffStep2216" : [ "16:00", "120000", "TariffStep2217"], + "TariffStep2217" : [ "17:00", "120000", "TariffStep2218"], + "TariffStep2218" : [ "18:00", "120000", "TariffStep2219"], + "TariffStep2219" : [ "19:00", "120000", "TariffStep2220"], + "TariffStep2220" : [ "20:00", "120000", "TariffStep2221"], + "TariffStep2221" : [ "21:00", "120000", "TariffStep2222"], + "TariffStep2222" : [ "22:00", "120000", "TariffStep2223"], + "TariffStep2223" : [ "23:00", "120000", "TariffStep230" ] + }, + "Thursday": { + "TariffStep230" : [ "00:00", "120000", "TariffStep231" ], + "TariffStep231" : [ "01:00", "120000", "TariffStep232" ], + "TariffStep232" : [ "02:00", "120000", "TariffStep233" ], + "TariffStep233" : [ "03:00", "120000", "TariffStep234" ], + "TariffStep234" : [ "04:00", "120000", "TariffStep235" ], + "TariffStep235" : [ "05:00", "120000", "TariffStep236" ], + "TariffStep236" : [ "06:00", "120000", "TariffStep237" ], + "TariffStep237" : [ "07:00", "120000", "TariffStep238" ], + "TariffStep238" : [ "08:00", "120000", "TariffStep239" ], + "TariffStep239" : [ "09:00", "120000", "TariffStep2310"], + "TariffStep2310" : [ "10:00", "120000", "TariffStep2311"], + "TariffStep2311" : [ "11:00", "120000", "TariffStep2312"], + "TariffStep2312" : [ "12:00", "120000", "TariffStep2313"], + "TariffStep2313" : [ "13:00", "120000", "TariffStep2314"], + "TariffStep2314" : [ "14:00", "120000", "TariffStep2315"], + "TariffStep2315" : [ "15:00", "120000", "TariffStep2316"], + "TariffStep2316" : [ "16:00", "120000", "TariffStep2317"], + "TariffStep2317" : [ "17:00", "120000", "TariffStep2318"], + "TariffStep2318" : [ "18:00", "120000", "TariffStep2319"], + "TariffStep2319" : [ "19:00", "120000", "TariffStep2320"], + "TariffStep2320" : [ "20:00", "120000", "TariffStep2321"], + "TariffStep2321" : [ "21:00", "120000", "TariffStep2322"], + "TariffStep2322" : [ "22:00", "120000", "TariffStep2323"], + "TariffStep2323" : [ "23:00", "120000", "TariffStep240" ] + }, + "Friday": { + "TariffStep240" : [ "00:00", "120000", "TariffStep241" ], + "TariffStep241" : [ "01:00", "120000", "TariffStep242" ], + "TariffStep242" : [ "02:00", "120000", "TariffStep243" ], + "TariffStep243" : [ "03:00", "120000", "TariffStep244" ], + "TariffStep244" : [ "04:00", "120000", "TariffStep245" ], + "TariffStep245" : [ "05:00", "120000", "TariffStep246" ], + "TariffStep246" : [ "06:00", "120000", "TariffStep247" ], + "TariffStep247" : [ "07:00", "120000", "TariffStep248" ], + "TariffStep248" : [ "08:00", "120000", "TariffStep249" ], + "TariffStep249" : [ "09:00", "120000", "TariffStep2410"], + "TariffStep2410" : [ "10:00", "120000", "TariffStep2411"], + "TariffStep2411" : [ "11:00", "120000", "TariffStep2412"], + "TariffStep2412" : [ "12:00", "120000", "TariffStep2413"], + "TariffStep2413" : [ "13:00", "120000", "TariffStep2414"], + "TariffStep2414" : [ "14:00", "120000", "TariffStep2415"], + "TariffStep2415" : [ "15:00", "120000", "TariffStep2416"], + "TariffStep2416" : [ "16:00", "120000", "TariffStep2417"], + "TariffStep2417" : [ "17:00", "120000", "TariffStep2418"], + "TariffStep2418" : [ "18:00", "120000", "TariffStep2419"], + "TariffStep2419" : [ "19:00", "120000", "TariffStep2420"], + "TariffStep2420" : [ "20:00", "120000", "TariffStep2421"], + "TariffStep2421" : [ "21:00", "120000", "TariffStep2422"], + "TariffStep2422" : [ "22:00", "120000", "TariffStep2423"], + "TariffStep2423" : [ "23:00", "120000", "TariffStep250" ] + }, + "Saturday": { + "TariffStep250" : [ "00:00", "120000", "TariffStep251" ], + "TariffStep251" : [ "01:00", "120000", "TariffStep252" ], + "TariffStep252" : [ "02:00", "120000", "TariffStep253" ], + "TariffStep253" : [ "03:00", "120000", "TariffStep254" ], + "TariffStep254" : [ "04:00", "120000", "TariffStep255" ], + "TariffStep255" : [ "05:00", "120000", "TariffStep256" ], + "TariffStep256" : [ "06:00", "120000", "TariffStep257" ], + "TariffStep257" : [ "07:00", "120000", "TariffStep258" ], + "TariffStep258" : [ "08:00", "120000", "TariffStep259" ], + "TariffStep259" : [ "09:00", "120000", "TariffStep2510"], + "TariffStep2510" : [ "10:00", "120000", "TariffStep2511"], + "TariffStep2511" : [ "11:00", "120000", "TariffStep2512"], + "TariffStep2512" : [ "12:00", "120000", "TariffStep2513"], + "TariffStep2513" : [ "13:00", "120000", "TariffStep2514"], + "TariffStep2514" : [ "14:00", "120000", "TariffStep2515"], + "TariffStep2515" : [ "15:00", "120000", "TariffStep2516"], + "TariffStep2516" : [ "16:00", "120000", "TariffStep2517"], + "TariffStep2517" : [ "17:00", "120000", "TariffStep2518"], + "TariffStep2518" : [ "18:00", "120000", "TariffStep2519"], + "TariffStep2519" : [ "19:00", "120000", "TariffStep2520"], + "TariffStep2520" : [ "20:00", "120000", "TariffStep2521"], + "TariffStep2521" : [ "21:00", "120000", "TariffStep2522"], + "TariffStep2522" : [ "22:00", "120000", "TariffStep2523"], + "TariffStep2523" : [ "23:00", "120000", "TariffStep260" ] + }, + "Sunday": { + "TariffStep260" : [ "00:00", "120000", "TariffStep261" ], + "TariffStep261" : [ "01:00", "120000", "TariffStep262" ], + "TariffStep262" : [ "02:00", "120000", "TariffStep263" ], + "TariffStep263" : [ "03:00", "120000", "TariffStep264" ], + "TariffStep264" : [ "04:00", "120000", "TariffStep265" ], + "TariffStep265" : [ "05:00", "120000", "TariffStep266" ], + "TariffStep266" : [ "06:00", "120000", "TariffStep267" ], + "TariffStep267" : [ "07:00", "120000", "TariffStep268" ], + "TariffStep268" : [ "08:00", "120000", "TariffStep269" ], + "TariffStep269" : [ "09:00", "120000", "TariffStep2610"], + "TariffStep2610" : [ "10:00", "120000", "TariffStep2611"], + "TariffStep2611" : [ "11:00", "120000", "TariffStep2612"], + "TariffStep2612" : [ "12:00", "120000", "TariffStep2613"], + "TariffStep2613" : [ "13:00", "120000", "TariffStep2614"], + "TariffStep2614" : [ "14:00", "120000", "TariffStep2615"], + "TariffStep2615" : [ "15:00", "120000", "TariffStep2616"], + "TariffStep2616" : [ "16:00", "120000", "TariffStep2617"], + "TariffStep2617" : [ "17:00", "120000", "TariffStep2618"], + "TariffStep2618" : [ "18:00", "120000", "TariffStep2619"], + "TariffStep2619" : [ "19:00", "120000", "TariffStep2620"], + "TariffStep2620" : [ "20:00", "120000", "TariffStep2621"], + "TariffStep2621" : [ "21:00", "120000", "TariffStep2622"], + "TariffStep2622" : [ "22:00", "120000", "TariffStep2623"], + "TariffStep2623" : [ "23:00", "120000", "TariffStep000" ] + } + } +} diff --git a/calculate_parking_tickets/erlangen.conf.bck b/calculate_parking_tickets/erlangen.conf.bck new file mode 100644 index 0000000..c7975f3 --- /dev/null +++ b/calculate_parking_tickets/erlangen.conf.bck @@ -0,0 +1,557 @@ +{ + "name":"test", + "properties": [ + ], + "week1" : { + "Monday": { + "TariffStep000" : [ "00:00", "120000", "TariffStep001" ], + "TariffStep001" : [ "01:00", "120000", "TariffStep002" ], + "TariffStep002" : [ "02:00", "120000", "TariffStep003" ], + "TariffStep003" : [ "03:00", "120000", "TariffStep004" ], + "TariffStep004" : [ "04:00", "120000", "TariffStep005" ], + "TariffStep005" : [ "05:00", "120000", "TariffStep006" ], + "TariffStep006" : [ "06:00", "120000", "TariffStep007" ], + "TariffStep007" : [ "07:00", "120000", "TariffStep008" ], + "TariffStep008" : [ "08:00", "120000", "TariffStep009" ], + "TariffStep009" : [ "09:00", "120000", "TariffStep0010" ], + "TariffStep0010" : [ "10:00", "120000", "TariffStep0011" ], + "TariffStep0011" : [ "11:00", "120000", "TariffStep0012" ], + "TariffStep0012" : [ "12:00", "120000", "TariffStep0013" ], + "TariffStep0013" : [ "13:00", "120000", "TariffStep0014" ], + "TariffStep0014" : [ "14:00", "120000", "TariffStep0015" ], + "TariffStep0015" : [ "15:00", "120000", "TariffStep0016"], + "TariffStep0016" : [ "16:00", "120000", "TariffStep0017"], + "TariffStep0017" : [ "17:00", "120000", "TariffStep0018"], + "TariffStep0018" : [ "18:00", "120000", "TariffStep0019"], + "TariffStep0019" : [ "19:00", "120000", "TariffStep0020"], + "TariffStep0020" : [ "20:00", "120000", "TariffStep0021" ] + "TariffStep0021" : [ "21:00", "120000", "TariffStep0022" ] + "TariffStep0022" : [ "22:00", "120000", "TariffStep0023" ] + "TariffStep0023" : [ "23:00", "120000", "TariffStep010" ] + }, + "Tuesday": { + "TariffStep010" : [ "00:00", "120000", "TariffStep011" ], + "TariffStep011" : [ "01:00", "120000", "TariffStep012" ], + "TariffStep012" : [ "02:00", "120000", "TariffStep013" ], + "TariffStep013" : [ "03:00", "120000", "TariffStep014" ], + "TariffStep014" : [ "04:00", "120000", "TariffStep015" ], + "TariffStep015" : [ "05:00", "120000", "TariffStep016" ], + "TariffStep016" : [ "06:00", "120000", "TariffStep017" ], + "TariffStep017" : [ "07:00", "120000", "TariffStep018" ], + "TariffStep018" : [ "08:00", "120000", "TariffStep019" ], + "TariffStep019" : [ "09:00", "120000", "TariffStep0110" ], + "TariffStep0110" : [ "10:00", "120000", "TariffStep0111" ], + "TariffStep0111" : [ "11:00", "120000", "TariffStep0112" ], + "TariffStep0112" : [ "12:00", "120000", "TariffStep0113" ], + "TariffStep0113" : [ "13:00", "120000", "TariffStep0114" ], + "TariffStep0114" : [ "14:00", "120000", "TariffStep0115" ], + "TariffStep0115" : [ "15:00", "120000", "TariffStep0116"], + "TariffStep0116" : [ "16:00", "120000", "TariffStep0117"], + "TariffStep0117" : [ "17:00", "120000", "TariffStep0118"], + "TariffStep0118" : [ "18:00", "120000", "TariffStep0119"], + "TariffStep0119" : [ "19:00", "120000", "TariffStep0120"], + "TariffStep0120" : [ "20:00", "120000", "TariffStep0121" ] + "TariffStep0121" : [ "21:00", "120000", "TariffStep0122" ] + "TariffStep0122" : [ "22:00", "120000", "TariffStep0123" ] + "TariffStep0123" : [ "23:00", "120000", "TariffStep020" ] + }, + "Wednesday": { + "TariffStep020" : [ "00:00", "120000", "TariffStep021" ], + "TariffStep021" : [ "01:00", "120000", "TariffStep022" ], + "TariffStep022" : [ "02:00", "120000", "TariffStep023" ], + "TariffStep023" : [ "03:00", "120000", "TariffStep024" ], + "TariffStep024" : [ "04:00", "120000", "TariffStep025" ], + "TariffStep025" : [ "05:00", "120000", "TariffStep026" ], + "TariffStep026" : [ "06:00", "120000", "TariffStep027" ], + "TariffStep027" : [ "07:00", "120000", "TariffStep028" ], + "TariffStep028" : [ "08:00", "120000", "TariffStep029" ], + "TariffStep029" : [ "09:00", "120000", "TariffStep0210"], + "TariffStep0210" : [ "10:00", "120000", "TariffStep0211"], + "TariffStep0211" : [ "11:00", "120000", "TariffStep0212"], + "TariffStep0212" : [ "12:00", "120000", "TariffStep0213"], + "TariffStep0213" : [ "13:00", "120000", "TariffStep0214"], + "TariffStep0214" : [ "14:00", "120000", "TariffStep0215"], + "TariffStep0215" : [ "15:00", "120000", "TariffStep0216"], + "TariffStep0216" : [ "16:00", "120000", "TariffStep0217"], + "TariffStep0217" : [ "17:00", "120000", "TariffStep0218"], + "TariffStep0218" : [ "18:00", "120000", "TariffStep0219"], + "TariffStep0219" : [ "19:00", "120000", "TariffStep0220"], + "TariffStep0220" : [ "20:00", "120000", "TariffStep0221"] + "TariffStep0221" : [ "21:00", "120000", "TariffStep0222"] + "TariffStep0222" : [ "22:00", "120000", "TariffStep0223"] + "TariffStep0223" : [ "23:00", "120000", "TariffStep030" ] + }, + "Thursday": { + "TariffStep030" : [ "00:00", "120000", "TariffStep031" ], + "TariffStep031" : [ "01:00", "120000", "TariffStep032" ], + "TariffStep032" : [ "02:00", "120000", "TariffStep033" ], + "TariffStep033" : [ "03:00", "120000", "TariffStep034" ], + "TariffStep034" : [ "04:00", "120000", "TariffStep035" ], + "TariffStep035" : [ "05:00", "120000", "TariffStep036" ], + "TariffStep036" : [ "06:00", "120000", "TariffStep037" ], + "TariffStep037" : [ "07:00", "120000", "TariffStep038" ], + "TariffStep038" : [ "08:00", "120000", "TariffStep039" ], + "TariffStep039" : [ "09:00", "120000", "TariffStep0310"], + "TariffStep0310" : [ "10:00", "120000", "TariffStep0311"], + "TariffStep0311" : [ "11:00", "120000", "TariffStep0312"], + "TariffStep0312" : [ "12:00", "120000", "TariffStep0313"], + "TariffStep0313" : [ "13:00", "120000", "TariffStep0314"], + "TariffStep0314" : [ "14:00", "120000", "TariffStep0315"], + "TariffStep0315" : [ "15:00", "120000", "TariffStep0316"], + "TariffStep0316" : [ "16:00", "120000", "TariffStep0317"], + "TariffStep0317" : [ "17:00", "120000", "TariffStep0318"], + "TariffStep0318" : [ "18:00", "120000", "TariffStep0319"], + "TariffStep0319" : [ "19:00", "120000", "TariffStep0320"], + "TariffStep0320" : [ "20:00", "120000", "TariffStep0321"] + "TariffStep0321" : [ "21:00", "120000", "TariffStep0322"] + "TariffStep0322" : [ "22:00", "120000", "TariffStep0323"] + "TariffStep0323" : [ "23:00", "120000", "TariffStep040" ] + }, + "Friday": { + "TariffStep040" : [ "00:00", "120000", "TariffStep041" ], + "TariffStep041" : [ "01:00", "120000", "TariffStep042" ], + "TariffStep042" : [ "02:00", "120000", "TariffStep043" ], + "TariffStep043" : [ "03:00", "120000", "TariffStep044" ], + "TariffStep044" : [ "04:00", "120000", "TariffStep045" ], + "TariffStep045" : [ "05:00", "120000", "TariffStep046" ], + "TariffStep046" : [ "06:00", "120000", "TariffStep047" ], + "TariffStep047" : [ "07:00", "120000", "TariffStep048" ], + "TariffStep048" : [ "08:00", "120000", "TariffStep049" ], + "TariffStep049" : [ "09:00", "120000", "TariffStep0410" ], + "TariffStep0410" : [ "10:00", "120000", "TariffStep0411" ], + "TariffStep0411" : [ "11:00", "120000", "TariffStep0412" ], + "TariffStep0412" : [ "12:00", "120000", "TariffStep0413" ], + "TariffStep0413" : [ "13:00", "120000", "TariffStep0414" ], + "TariffStep0414" : [ "14:00", "120000", "TariffStep0415" ], + "TariffStep0415" : [ "15:00", "120000", "TariffStep0416"], + "TariffStep0416" : [ "16:00", "120000", "TariffStep0417"], + "TariffStep0417" : [ "17:00", "120000", "TariffStep0418"], + "TariffStep0418" : [ "18:00", "120000", "TariffStep0419"], + "TariffStep0419" : [ "19:00", "120000", "TariffStep0420"], + "TariffStep0420" : [ "20:00", "120000", "TariffStep0421" ] + "TariffStep0421" : [ "21:00", "120000", "TariffStep0422" ] + "TariffStep0422" : [ "22:00", "120000", "TariffStep0423" ] + "TariffStep0423" : [ "23:00", "120000", "TariffStep050" ] + }, + "Saturday": { + "TariffStep050" : [ "00:00", "120000", "TariffStep051" ], + "TariffStep051" : [ "01:00", "120000", "TariffStep052" ], + "TariffStep052" : [ "02:00", "120000", "TariffStep053" ], + "TariffStep053" : [ "03:00", "120000", "TariffStep054" ], + "TariffStep054" : [ "04:00", "120000", "TariffStep055" ], + "TariffStep055" : [ "05:00", "120000", "TariffStep056" ], + "TariffStep056" : [ "06:00", "120000", "TariffStep057" ], + "TariffStep057" : [ "07:00", "120000", "TariffStep058" ], + "TariffStep058" : [ "08:00", "120000", "TariffStep059" ], + "TariffStep059" : [ "09:00", "120000", "TariffStep0510"], + "TariffStep0510" : [ "10:00", "120000", "TariffStep0511"], + "TariffStep0511" : [ "11:00", "120000", "TariffStep0512"], + "TariffStep0512" : [ "12:00", "120000", "TariffStep0513"], + "TariffStep0513" : [ "13:00", "120000", "TariffStep0514"], + "TariffStep0514" : [ "14:00", "120000", "TariffStep0515"], + "TariffStep0515" : [ "15:00", "120000", "TariffStep0516"], + "TariffStep0516" : [ "16:00", "120000", "TariffStep0517"], + "TariffStep0517" : [ "17:00", "120000", "TariffStep0518"], + "TariffStep0518" : [ "18:00", "120000", "TariffStep0519"], + "TariffStep0519" : [ "19:00", "120000", "TariffStep0520"], + "TariffStep0520" : [ "20:00", "120000", "TariffStep0521"] + "TariffStep0521" : [ "21:00", "120000", "TariffStep0522"] + "TariffStep0522" : [ "22:00", "120000", "TariffStep0523"] + "TariffStep0523" : [ "23:00", "120000", "TariffStep060" ] + }, + "Sunday": { + "TariffStep060" : [ "00:00", "120000", "TariffStep061" ], + "TariffStep061" : [ "01:00", "120000", "TariffStep062" ], + "TariffStep062" : [ "02:00", "120000", "TariffStep063" ], + "TariffStep063" : [ "03:00", "120000", "TariffStep064" ], + "TariffStep064" : [ "04:00", "120000", "TariffStep065" ], + "TariffStep065" : [ "05:00", "120000", "TariffStep066" ], + "TariffStep066" : [ "06:00", "120000", "TariffStep067" ], + "TariffStep067" : [ "07:00", "120000", "TariffStep068" ], + "TariffStep068" : [ "08:00", "120000", "TariffStep069" ], + "TariffStep069" : [ "09:00", "120000", "TariffStep0610"], + "TariffStep0610" : [ "10:00", "120000", "TariffStep0611"], + "TariffStep0611" : [ "11:00", "120000", "TariffStep0612"], + "TariffStep0612" : [ "12:00", "120000", "TariffStep0613"], + "TariffStep0613" : [ "13:00", "120000", "TariffStep0614"], + "TariffStep0614" : [ "14:00", "120000", "TariffStep0615"], + "TariffStep0615" : [ "15:00", "120000", "TariffStep0616"], + "TariffStep0616" : [ "16:00", "120000", "TariffStep0617"], + "TariffStep0617" : [ "17:00", "120000", "TariffStep0618"], + "TariffStep0618" : [ "18:00", "120000", "TariffStep0619"], + "TariffStep0619" : [ "19:00", "120000", "TariffStep0620"], + "TariffStep0620" : [ "20:00", "120000", "TariffStep0621"] + "TariffStep0621" : [ "21:00", "120000", "TariffStep0622"] + "TariffStep0622" : [ "22:00", "120000", "TariffStep0623"] + "TariffStep0623" : [ "23:00", "120000", "TariffStep100" ] + } + }, + "week2" : { + "Monday": { + "TariffStep100" : [ "00:00", "120000", "TariffStep101" ], + "TariffStep101" : [ "01:00", "120000", "TariffStep102" ], + "TariffStep102" : [ "02:00", "120000", "TariffStep103" ], + "TariffStep103" : [ "03:00", "120000", "TariffStep104" ], + "TariffStep104" : [ "04:00", "120000", "TariffStep105" ], + "TariffStep105" : [ "05:00", "120000", "TariffStep106" ], + "TariffStep106" : [ "06:00", "120000", "TariffStep107" ], + "TariffStep107" : [ "07:00", "120000", "TariffStep108" ], + "TariffStep108" : [ "08:00", "120000", "TariffStep109" ], + "TariffStep109" : [ "09:00", "120000", "TariffStep1010" ], + "TariffStep1010" : [ "10:00", "120000", "TariffStep1011" ], + "TariffStep1011" : [ "11:00", "120000", "TariffStep1012" ], + "TariffStep1012" : [ "12:00", "120000", "TariffStep1013" ], + "TariffStep1013" : [ "13:00", "120000", "TariffStep1014" ], + "TariffStep1014" : [ "14:00", "120000", "TariffStep1015" ], + "TariffStep1015" : [ "15:00", "120000", "TariffStep1016"], + "TariffStep1016" : [ "16:00", "120000", "TariffStep1017"], + "TariffStep1017" : [ "17:00", "120000", "TariffStep1018"], + "TariffStep1018" : [ "18:00", "120000", "TariffStep1019"], + "TariffStep1019" : [ "19:00", "120000", "TariffStep1020"], + "TariffStep1020" : [ "20:00", "120000", "TariffStep1021" ] + "TariffStep1021" : [ "21:00", "120000", "TariffStep1022" ] + "TariffStep1022" : [ "22:00", "120000", "TariffStep1023" ] + "TariffStep1023" : [ "23:00", "120000", "TariffStep110" ] + }, + "Tuesday": { + "TariffStep110" : [ "00:00", "120000", "TariffStep111" ], + "TariffStep111" : [ "01:00", "120000", "TariffStep112" ], + "TariffStep112" : [ "02:00", "120000", "TariffStep113" ], + "TariffStep113" : [ "03:00", "120000", "TariffStep114" ], + "TariffStep114" : [ "04:00", "120000", "TariffStep115" ], + "TariffStep115" : [ "05:00", "120000", "TariffStep116" ], + "TariffStep116" : [ "06:00", "120000", "TariffStep117" ], + "TariffStep117" : [ "07:00", "120000", "TariffStep118" ], + "TariffStep118" : [ "08:00", "120000", "TariffStep119" ], + "TariffStep119" : [ "09:00", "120000", "TariffStep1110" ], + "TariffStep1110" : [ "10:00", "120000", "TariffStep1111" ], + "TariffStep1111" : [ "11:00", "120000", "TariffStep1112" ], + "TariffStep1112" : [ "12:00", "120000", "TariffStep1113" ], + "TariffStep1113" : [ "13:00", "120000", "TariffStep1114" ], + "TariffStep1114" : [ "14:00", "120000", "TariffStep1115" ], + "TariffStep1115" : [ "15:00", "120000", "TariffStep1116"], + "TariffStep1116" : [ "16:00", "120000", "TariffStep1117"], + "TariffStep1117" : [ "17:00", "120000", "TariffStep1118"], + "TariffStep1118" : [ "18:00", "120000", "TariffStep1119"], + "TariffStep1119" : [ "19:00", "120000", "TariffStep1120"], + "TariffStep1120" : [ "20:00", "120000", "TariffStep1121" ] + "TariffStep1121" : [ "21:00", "120000", "TariffStep1122" ] + "TariffStep1122" : [ "22:00", "120000", "TariffStep1123" ] + "TariffStep1123" : [ "23:00", "120000", "TariffStep120" ] + }, + "Wednesday": { + "TariffStep120" : [ "00:00", "120000", "TariffStep121" ], + "TariffStep121" : [ "01:00", "120000", "TariffStep122" ], + "TariffStep122" : [ "02:00", "120000", "TariffStep123" ], + "TariffStep123" : [ "03:00", "120000", "TariffStep124" ], + "TariffStep124" : [ "04:00", "120000", "TariffStep125" ], + "TariffStep125" : [ "05:00", "120000", "TariffStep126" ], + "TariffStep126" : [ "06:00", "120000", "TariffStep127" ], + "TariffStep127" : [ "07:00", "120000", "TariffStep128" ], + "TariffStep128" : [ "08:00", "120000", "TariffStep129" ], + "TariffStep129" : [ "09:00", "120000", "TariffStep1210"], + "TariffStep1210" : [ "10:00", "120000", "TariffStep1211"], + "TariffStep1211" : [ "11:00", "120000", "TariffStep1212"], + "TariffStep1212" : [ "12:00", "120000", "TariffStep1213"], + "TariffStep1213" : [ "13:00", "120000", "TariffStep1214"], + "TariffStep1214" : [ "14:00", "120000", "TariffStep1215"], + "TariffStep1215" : [ "15:00", "120000", "TariffStep1216"], + "TariffStep1216" : [ "16:00", "120000", "TariffStep1217"], + "TariffStep1217" : [ "17:00", "120000", "TariffStep1218"], + "TariffStep1218" : [ "18:00", "120000", "TariffStep1219"], + "TariffStep1219" : [ "19:00", "120000", "TariffStep1220"], + "TariffStep1220" : [ "20:00", "120000", "TariffStep1221"] + "TariffStep1221" : [ "21:00", "120000", "TariffStep1222"] + "TariffStep1222" : [ "22:00", "120000", "TariffStep1223"] + "TariffStep1223" : [ "23:00", "120000", "TariffStep130" ] + }, + "Thursday": { + "TariffStep130" : [ "00:00", "120000", "TariffStep131" ], + "TariffStep131" : [ "01:00", "120000", "TariffStep132" ], + "TariffStep132" : [ "02:00", "120000", "TariffStep133" ], + "TariffStep133" : [ "03:00", "120000", "TariffStep134" ], + "TariffStep134" : [ "04:00", "120000", "TariffStep135" ], + "TariffStep135" : [ "05:00", "120000", "TariffStep136" ], + "TariffStep136" : [ "06:00", "120000", "TariffStep137" ], + "TariffStep137" : [ "07:00", "120000", "TariffStep138" ], + "TariffStep138" : [ "08:00", "120000", "TariffStep139" ], + "TariffStep139" : [ "09:00", "120000", "TariffStep1310"], + "TariffStep1310" : [ "10:00", "120000", "TariffStep1311"], + "TariffStep1311" : [ "11:00", "120000", "TariffStep1312"], + "TariffStep1312" : [ "12:00", "120000", "TariffStep1313"], + "TariffStep1313" : [ "13:00", "120000", "TariffStep1314"], + "TariffStep1314" : [ "14:00", "120000", "TariffStep1315"], + "TariffStep1315" : [ "15:00", "120000", "TariffStep1316"], + "TariffStep1316" : [ "16:00", "120000", "TariffStep1317"], + "TariffStep1317" : [ "17:00", "120000", "TariffStep1318"], + "TariffStep1318" : [ "18:00", "120000", "TariffStep1319"], + "TariffStep1319" : [ "19:00", "120000", "TariffStep1320"], + "TariffStep1320" : [ "20:00", "120000", "TariffStep1321"] + "TariffStep1321" : [ "21:00", "120000", "TariffStep1322"] + "TariffStep1322" : [ "22:00", "120000", "TariffStep1323"] + "TariffStep1323" : [ "23:00", "120000", "TariffStep140" ] + }, + "Friday": { + "TariffStep140" : [ "00:00", "120000", "TariffStep141" ], + "TariffStep141" : [ "01:00", "120000", "TariffStep142" ], + "TariffStep142" : [ "02:00", "120000", "TariffStep143" ], + "TariffStep143" : [ "03:00", "120000", "TariffStep144" ], + "TariffStep144" : [ "04:00", "120000", "TariffStep145" ], + "TariffStep145" : [ "05:00", "120000", "TariffStep146" ], + "TariffStep146" : [ "06:00", "120000", "TariffStep147" ], + "TariffStep147" : [ "07:00", "120000", "TariffStep148" ], + "TariffStep148" : [ "08:00", "120000", "TariffStep149" ], + "TariffStep149" : [ "09:00", "120000", "TariffStep1410" ], + "TariffStep1410" : [ "10:00", "120000", "TariffStep1411" ], + "TariffStep1411" : [ "11:00", "120000", "TariffStep1412" ], + "TariffStep1412" : [ "12:00", "120000", "TariffStep1413" ], + "TariffStep1413" : [ "13:00", "120000", "TariffStep1414" ], + "TariffStep1414" : [ "14:00", "120000", "TariffStep1415" ], + "TariffStep1415" : [ "15:00", "120000", "TariffStep1416"], + "TariffStep1416" : [ "16:00", "120000", "TariffStep1417"], + "TariffStep1417" : [ "17:00", "120000", "TariffStep1418"], + "TariffStep1418" : [ "18:00", "120000", "TariffStep1419"], + "TariffStep1419" : [ "19:00", "120000", "TariffStep1420"], + "TariffStep1420" : [ "20:00", "120000", "TariffStep1421" ] + "TariffStep1421" : [ "21:00", "120000", "TariffStep1422" ] + "TariffStep1422" : [ "22:00", "120000", "TariffStep1423" ] + "TariffStep1423" : [ "23:00", "120000", "TariffStep150" ] + }, + "Saturday": { + "TariffStep150" : [ "00:00", "120000", "TariffStep151" ], + "TariffStep151" : [ "01:00", "120000", "TariffStep152" ], + "TariffStep152" : [ "02:00", "120000", "TariffStep153" ], + "TariffStep153" : [ "03:00", "120000", "TariffStep154" ], + "TariffStep154" : [ "04:00", "120000", "TariffStep155" ], + "TariffStep155" : [ "05:00", "120000", "TariffStep156" ], + "TariffStep156" : [ "06:00", "120000", "TariffStep157" ], + "TariffStep157" : [ "07:00", "120000", "TariffStep158" ], + "TariffStep158" : [ "08:00", "120000", "TariffStep159" ], + "TariffStep159" : [ "09:00", "120000", "TariffStep1510"], + "TariffStep1510" : [ "10:00", "120000", "TariffStep1511"], + "TariffStep1511" : [ "11:00", "120000", "TariffStep1512"], + "TariffStep1512" : [ "12:00", "120000", "TariffStep1513"], + "TariffStep1513" : [ "13:00", "120000", "TariffStep1514"], + "TariffStep1514" : [ "14:00", "120000", "TariffStep1515"], + "TariffStep1515" : [ "15:00", "120000", "TariffStep1516"], + "TariffStep1516" : [ "16:00", "120000", "TariffStep1517"], + "TariffStep1517" : [ "17:00", "120000", "TariffStep1518"], + "TariffStep1518" : [ "18:00", "120000", "TariffStep1519"], + "TariffStep1519" : [ "19:00", "120000", "TariffStep1520"], + "TariffStep1520" : [ "20:00", "120000", "TariffStep1521"] + "TariffStep1521" : [ "21:00", "120000", "TariffStep1522"] + "TariffStep1522" : [ "22:00", "120000", "TariffStep1523"] + "TariffStep1523" : [ "23:00", "120000", "TariffStep160" ] + }, + "Sunday": { + "TariffStep160" : [ "00:00", "120000", "TariffStep161" ], + "TariffStep161" : [ "01:00", "120000", "TariffStep162" ], + "TariffStep162" : [ "02:00", "120000", "TariffStep163" ], + "TariffStep163" : [ "03:00", "120000", "TariffStep164" ], + "TariffStep164" : [ "04:00", "120000", "TariffStep165" ], + "TariffStep165" : [ "05:00", "120000", "TariffStep166" ], + "TariffStep166" : [ "06:00", "120000", "TariffStep167" ], + "TariffStep167" : [ "07:00", "120000", "TariffStep168" ], + "TariffStep168" : [ "08:00", "120000", "TariffStep169" ], + "TariffStep169" : [ "09:00", "120000", "TariffStep1610"], + "TariffStep1610" : [ "10:00", "120000", "TariffStep1611"], + "TariffStep1611" : [ "11:00", "120000", "TariffStep1612"], + "TariffStep1612" : [ "12:00", "120000", "TariffStep1613"], + "TariffStep1613" : [ "13:00", "120000", "TariffStep1614"], + "TariffStep1614" : [ "14:00", "120000", "TariffStep1615"], + "TariffStep1615" : [ "15:00", "120000", "TariffStep1616"], + "TariffStep1616" : [ "16:00", "120000", "TariffStep1617"], + "TariffStep1617" : [ "17:00", "120000", "TariffStep1618"], + "TariffStep1618" : [ "18:00", "120000", "TariffStep1619"], + "TariffStep1619" : [ "19:00", "120000", "TariffStep1620"], + "TariffStep1620" : [ "20:00", "120000", "TariffStep1621"] + "TariffStep1621" : [ "21:00", "120000", "TariffStep1622"] + "TariffStep1622" : [ "22:00", "120000", "TariffStep1623"] + "TariffStep1623" : [ "23:00", "120000", "TariffStep200" ] + } + }, + "week3" : { + "Monday": { + "TariffStep200" : [ "00:00", "120000", "TariffStep201" ], + "TariffStep201" : [ "01:00", "120000", "TariffStep202" ], + "TariffStep202" : [ "02:00", "120000", "TariffStep203" ], + "TariffStep203" : [ "03:00", "120000", "TariffStep204" ], + "TariffStep204" : [ "04:00", "120000", "TariffStep205" ], + "TariffStep205" : [ "05:00", "120000", "TariffStep206" ], + "TariffStep206" : [ "06:00", "120000", "TariffStep207" ], + "TariffStep207" : [ "07:00", "120000", "TariffStep208" ], + "TariffStep208" : [ "08:00", "120000", "TariffStep209" ], + "TariffStep209" : [ "09:00", "120000", "TariffStep2010" ], + "TariffStep2010" : [ "10:00", "120000", "TariffStep2011" ], + "TariffStep2011" : [ "11:00", "120000", "TariffStep2012" ], + "TariffStep2012" : [ "12:00", "120000", "TariffStep2013" ], + "TariffStep2013" : [ "13:00", "120000", "TariffStep2014" ], + "TariffStep2014" : [ "14:00", "120000", "TariffStep2015" ], + "TariffStep2015" : [ "15:00", "120000", "TariffStep2016"], + "TariffStep2016" : [ "16:00", "120000", "TariffStep2017"], + "TariffStep2017" : [ "17:00", "120000", "TariffStep2018"], + "TariffStep2018" : [ "18:00", "120000", "TariffStep2019"], + "TariffStep2019" : [ "19:00", "120000", "TariffStep2020"], + "TariffStep2020" : [ "20:00", "120000", "TariffStep2021" ] + "TariffStep2021" : [ "21:00", "120000", "TariffStep2022" ] + "TariffStep2022" : [ "22:00", "120000", "TariffStep2023" ] + "TariffStep2023" : [ "23:00", "120000", "TariffStep210" ] + }, + "Tuesday": { + "TariffStep210" : [ "00:00", "120000", "TariffStep211" ], + "TariffStep211" : [ "01:00", "120000", "TariffStep212" ], + "TariffStep212" : [ "02:00", "120000", "TariffStep213" ], + "TariffStep213" : [ "03:00", "120000", "TariffStep214" ], + "TariffStep214" : [ "04:00", "120000", "TariffStep215" ], + "TariffStep215" : [ "05:00", "120000", "TariffStep216" ], + "TariffStep216" : [ "06:00", "120000", "TariffStep217" ], + "TariffStep217" : [ "07:00", "120000", "TariffStep218" ], + "TariffStep218" : [ "08:00", "120000", "TariffStep219" ], + "TariffStep219" : [ "09:00", "120000", "TariffStep2110" ], + "TariffStep2110" : [ "10:00", "120000", "TariffStep2111" ], + "TariffStep2111" : [ "11:00", "120000", "TariffStep2112" ], + "TariffStep2112" : [ "12:00", "120000", "TariffStep2113" ], + "TariffStep2113" : [ "13:00", "120000", "TariffStep2114" ], + "TariffStep2114" : [ "14:00", "120000", "TariffStep2115" ], + "TariffStep2115" : [ "15:00", "120000", "TariffStep2116"], + "TariffStep2116" : [ "16:00", "120000", "TariffStep2117"], + "TariffStep2117" : [ "17:00", "120000", "TariffStep2118"], + "TariffStep2118" : [ "18:00", "120000", "TariffStep2119"], + "TariffStep2119" : [ "19:00", "120000", "TariffStep2120"], + "TariffStep2120" : [ "20:00", "120000", "TariffStep2121" ] + "TariffStep2121" : [ "21:00", "120000", "TariffStep2122" ] + "TariffStep2122" : [ "22:00", "120000", "TariffStep2123" ] + "TariffStep2123" : [ "23:00", "120000", "TariffStep220" ] + }, + "Wednesday": { + "TariffStep220" : [ "00:00", "120000", "TariffStep221" ], + "TariffStep221" : [ "01:00", "120000", "TariffStep222" ], + "TariffStep222" : [ "02:00", "120000", "TariffStep223" ], + "TariffStep223" : [ "03:00", "120000", "TariffStep224" ], + "TariffStep224" : [ "04:00", "120000", "TariffStep225" ], + "TariffStep225" : [ "05:00", "120000", "TariffStep226" ], + "TariffStep226" : [ "06:00", "120000", "TariffStep227" ], + "TariffStep227" : [ "07:00", "120000", "TariffStep228" ], + "TariffStep228" : [ "08:00", "120000", "TariffStep229" ], + "TariffStep229" : [ "09:00", "120000", "TariffStep2210"], + "TariffStep2210" : [ "10:00", "120000", "TariffStep2211"], + "TariffStep2211" : [ "11:00", "120000", "TariffStep2212"], + "TariffStep2212" : [ "12:00", "120000", "TariffStep2213"], + "TariffStep2213" : [ "13:00", "120000", "TariffStep2214"], + "TariffStep2214" : [ "14:00", "120000", "TariffStep2215"], + "TariffStep2215" : [ "15:00", "120000", "TariffStep2216"], + "TariffStep2216" : [ "16:00", "120000", "TariffStep2217"], + "TariffStep2217" : [ "17:00", "120000", "TariffStep2218"], + "TariffStep2218" : [ "18:00", "120000", "TariffStep2219"], + "TariffStep2219" : [ "19:00", "120000", "TariffStep2220"], + "TariffStep2220" : [ "20:00", "120000", "TariffStep2221"] + "TariffStep2221" : [ "21:00", "120000", "TariffStep2222"] + "TariffStep2222" : [ "22:00", "120000", "TariffStep2223"] + "TariffStep2223" : [ "23:00", "120000", "TariffStep230" ] + }, + "Thursday": { + "TariffStep230" : [ "00:00", "120000", "TariffStep231" ], + "TariffStep231" : [ "01:00", "120000", "TariffStep232" ], + "TariffStep232" : [ "02:00", "120000", "TariffStep233" ], + "TariffStep233" : [ "03:00", "120000", "TariffStep234" ], + "TariffStep234" : [ "04:00", "120000", "TariffStep235" ], + "TariffStep235" : [ "05:00", "120000", "TariffStep236" ], + "TariffStep236" : [ "06:00", "120000", "TariffStep237" ], + "TariffStep237" : [ "07:00", "120000", "TariffStep238" ], + "TariffStep238" : [ "08:00", "120000", "TariffStep239" ], + "TariffStep239" : [ "09:00", "120000", "TariffStep2310"], + "TariffStep2310" : [ "10:00", "120000", "TariffStep2311"], + "TariffStep2311" : [ "11:00", "120000", "TariffStep2312"], + "TariffStep2312" : [ "12:00", "120000", "TariffStep2313"], + "TariffStep2313" : [ "13:00", "120000", "TariffStep2314"], + "TariffStep2314" : [ "14:00", "120000", "TariffStep2315"], + "TariffStep2315" : [ "15:00", "120000", "TariffStep2316"], + "TariffStep2316" : [ "16:00", "120000", "TariffStep2317"], + "TariffStep2317" : [ "17:00", "120000", "TariffStep2318"], + "TariffStep2318" : [ "18:00", "120000", "TariffStep2319"], + "TariffStep2319" : [ "19:00", "120000", "TariffStep2320"], + "TariffStep2320" : [ "20:00", "120000", "TariffStep2321"] + "TariffStep2321" : [ "21:00", "120000", "TariffStep2322"] + "TariffStep2322" : [ "22:00", "120000", "TariffStep2323"] + "TariffStep2323" : [ "23:00", "120000", "TariffStep240" ] + }, + "Friday": { + "TariffStep240" : [ "00:00", "120000", "TariffStep241" ], + "TariffStep241" : [ "01:00", "120000", "TariffStep242" ], + "TariffStep242" : [ "02:00", "120000", "TariffStep243" ], + "TariffStep243" : [ "03:00", "120000", "TariffStep244" ], + "TariffStep244" : [ "04:00", "120000", "TariffStep245" ], + "TariffStep245" : [ "05:00", "120000", "TariffStep246" ], + "TariffStep246" : [ "06:00", "120000", "TariffStep247" ], + "TariffStep247" : [ "07:00", "120000", "TariffStep248" ], + "TariffStep248" : [ "08:00", "120000", "TariffStep249" ], + "TariffStep249" : [ "09:00", "120000", "TariffStep2410" ], + "TariffStep2410" : [ "10:00", "120000", "TariffStep2411" ], + "TariffStep2411" : [ "11:00", "120000", "TariffStep2412" ], + "TariffStep2412" : [ "12:00", "120000", "TariffStep2413" ], + "TariffStep2413" : [ "13:00", "120000", "TariffStep2414" ], + "TariffStep2414" : [ "14:00", "120000", "TariffStep2415" ], + "TariffStep2415" : [ "15:00", "120000", "TariffStep2416"], + "TariffStep2416" : [ "16:00", "120000", "TariffStep2417"], + "TariffStep2417" : [ "17:00", "120000", "TariffStep2418"], + "TariffStep2418" : [ "18:00", "120000", "TariffStep2419"], + "TariffStep2419" : [ "19:00", "120000", "TariffStep2420"], + "TariffStep2420" : [ "20:00", "120000", "TariffStep2421" ] + "TariffStep2421" : [ "21:00", "120000", "TariffStep2422" ] + "TariffStep2422" : [ "22:00", "120000", "TariffStep2423" ] + "TariffStep2423" : [ "23:00", "120000", "TariffStep250" ] + }, + "Saturday": { + "TariffStep250" : [ "00:00", "120000", "TariffStep251" ], + "TariffStep251" : [ "01:00", "120000", "TariffStep252" ], + "TariffStep252" : [ "02:00", "120000", "TariffStep253" ], + "TariffStep253" : [ "03:00", "120000", "TariffStep254" ], + "TariffStep254" : [ "04:00", "120000", "TariffStep255" ], + "TariffStep255" : [ "05:00", "120000", "TariffStep256" ], + "TariffStep256" : [ "06:00", "120000", "TariffStep257" ], + "TariffStep257" : [ "07:00", "120000", "TariffStep258" ], + "TariffStep258" : [ "08:00", "120000", "TariffStep259" ], + "TariffStep259" : [ "09:00", "120000", "TariffStep2510"], + "TariffStep2510" : [ "10:00", "120000", "TariffStep2511"], + "TariffStep2511" : [ "11:00", "120000", "TariffStep2512"], + "TariffStep2512" : [ "12:00", "120000", "TariffStep2513"], + "TariffStep2513" : [ "13:00", "120000", "TariffStep2514"], + "TariffStep2514" : [ "14:00", "120000", "TariffStep2515"], + "TariffStep2515" : [ "15:00", "120000", "TariffStep2516"], + "TariffStep2516" : [ "16:00", "120000", "TariffStep2517"], + "TariffStep2517" : [ "17:00", "120000", "TariffStep2518"], + "TariffStep2518" : [ "18:00", "120000", "TariffStep2519"], + "TariffStep2519" : [ "19:00", "120000", "TariffStep2520"], + "TariffStep2520" : [ "20:00", "120000", "TariffStep2521"] + "TariffStep2521" : [ "21:00", "120000", "TariffStep2522"] + "TariffStep2522" : [ "22:00", "120000", "TariffStep2523"] + "TariffStep2523" : [ "23:00", "120000", "TariffStep260" ] + }, + "Sunday": { + "TariffStep260" : [ "00:00", "120000", "TariffStep261" ], + "TariffStep261" : [ "01:00", "120000", "TariffStep262" ], + "TariffStep262" : [ "02:00", "120000", "TariffStep263" ], + "TariffStep263" : [ "03:00", "120000", "TariffStep264" ], + "TariffStep264" : [ "04:00", "120000", "TariffStep265" ], + "TariffStep265" : [ "05:00", "120000", "TariffStep266" ], + "TariffStep266" : [ "06:00", "120000", "TariffStep267" ], + "TariffStep267" : [ "07:00", "120000", "TariffStep268" ], + "TariffStep268" : [ "08:00", "120000", "TariffStep269" ], + "TariffStep269" : [ "09:00", "120000", "TariffStep2610"], + "TariffStep2610" : [ "10:00", "120000", "TariffStep2611"], + "TariffStep2611" : [ "11:00", "120000", "TariffStep2612"], + "TariffStep2612" : [ "12:00", "120000", "TariffStep2613"], + "TariffStep2613" : [ "13:00", "120000", "TariffStep2614"], + "TariffStep2614" : [ "14:00", "120000", "TariffStep2615"], + "TariffStep2615" : [ "15:00", "120000", "TariffStep2616"], + "TariffStep2616" : [ "16:00", "120000", "TariffStep2617"], + "TariffStep2617" : [ "17:00", "120000", "TariffStep2618"], + "TariffStep2618" : [ "18:00", "120000", "TariffStep2619"], + "TariffStep2619" : [ "19:00", "120000", "TariffStep2620"], + "TariffStep2620" : [ "20:00", "120000", "TariffStep2621"] + "TariffStep2621" : [ "21:00", "120000", "TariffStep2622"] + "TariffStep2622" : [ "22:00", "120000", "TariffStep2623"] + "TariffStep2623" : [ "23:00", "120000", "TariffStep000" ] + } + }, +} diff --git a/calculate_parking_tickets/germersheim.conf b/calculate_parking_tickets/germersheim.conf new file mode 100644 index 0000000..0f9b9cc --- /dev/null +++ b/calculate_parking_tickets/germersheim.conf @@ -0,0 +1,30319 @@ +{ + "name" : "Germersheim (23.01.2023)", + + "spec1" : "Freiparkzeit: 90min kostenlos", + "spec2" : "Stundentariff (7.00 - 20:00): 3.50 Euro/h", + "spec3" : "Tagesmaximum 18 Euro, gueltig 24Std. ab Einfahrt", + "spec3.1" : "(d.h gueltig bis 24h nach Einfahrt)", + "spec4" : "Nachttarif (20.00 - 7.00): 8 Euro", + + "comment_free_of_charge" : "Freiparkzeit: 90min kostenlos", + "free_of_charge" : "90", + + "comment_unit_scale_factor" : "internal", + "unit_scale_factor" : "1.0", + + "comment_unit_definition" : "internal", + "unit_definition" : "1000", + + "comment_vat" : "mehrwertsteuersatz: internal", + "vat" : "0.19", + + "comment_parking_max_price" : "unlimited", + "max_parking_price" : "unlimited", + + "comment_max_price_for_24_hours" : "preis fuer 24h ticket (18 Euro)", + "max_price_for_24_hours" : "1800000", + + "comment_max_parking_time" : "maximale parkzeit (in minuten)", + "max_parking_time" : "20160", + + "week1" : { + "Monday": { + "000000" : [ "00:00", "800000", "000420" ], + "000001" : [ "00:01", "800000", "000420" ], + "000002" : [ "00:02", "800000", "000420" ], + "000003" : [ "00:03", "800000", "000420" ], + "000004" : [ "00:04", "800000", "000420" ], + "000005" : [ "00:05", "800000", "000420" ], + "000006" : [ "00:06", "800000", "000420" ], + "000007" : [ "00:07", "800000", "000420" ], + "000008" : [ "00:08", "800000", "000420" ], + "000009" : [ "00:09", "800000", "000420" ], + "000010" : [ "00:10", "800000", "000420" ], + "000011" : [ "00:11", "800000", "000420" ], + "000012" : [ "00:12", "800000", "000420" ], + "000013" : [ "00:13", "800000", "000420" ], + "000014" : [ "00:14", "800000", "000420" ], + "000015" : [ "00:15", "800000", "000420" ], + "000016" : [ "00:16", "800000", "000420" ], + "000017" : [ "00:17", "800000", "000420" ], + "000018" : [ "00:18", "800000", "000420" ], + "000019" : [ "00:19", "800000", "000420" ], + "000020" : [ "00:20", "800000", "000420" ], + "000021" : [ "00:21", "800000", "000420" ], + "000022" : [ "00:22", "800000", "000420" ], + "000023" : [ "00:23", "800000", "000420" ], + "000024" : [ "00:24", "800000", "000420" ], + "000025" : [ "00:25", "800000", "000420" ], + "000026" : [ "00:26", "800000", "000420" ], + "000027" : [ "00:27", "800000", "000420" ], + "000028" : [ "00:28", "800000", "000420" ], + "000029" : [ "00:29", "800000", "000420" ], + "000030" : [ "00:30", "800000", "000420" ], + "000031" : [ "00:31", "800000", "000420" ], + "000032" : [ "00:32", "800000", "000420" ], + "000033" : [ "00:33", "800000", "000420" ], + "000034" : [ "00:34", "800000", "000420" ], + "000035" : [ "00:35", "800000", "000420" ], + "000036" : [ "00:36", "800000", "000420" ], + "000037" : [ "00:37", "800000", "000420" ], + "000038" : [ "00:38", "800000", "000420" ], + "000039" : [ "00:39", "800000", "000420" ], + "000040" : [ "00:40", "800000", "000420" ], + "000041" : [ "00:41", "800000", "000420" ], + "000042" : [ "00:42", "800000", "000420" ], + "000043" : [ "00:43", "800000", "000420" ], + "000044" : [ "00:44", "800000", "000420" ], + "000045" : [ "00:45", "800000", "000420" ], + "000046" : [ "00:46", "800000", "000420" ], + "000047" : [ "00:47", "800000", "000420" ], + "000048" : [ "00:48", "800000", "000420" ], + "000049" : [ "00:49", "800000", "000420" ], + "000050" : [ "00:50", "800000", "000420" ], + "000051" : [ "00:51", "800000", "000420" ], + "000052" : [ "00:52", "800000", "000420" ], + "000053" : [ "00:53", "800000", "000420" ], + "000054" : [ "00:54", "800000", "000420" ], + "000055" : [ "00:55", "800000", "000420" ], + "000056" : [ "00:56", "800000", "000420" ], + "000057" : [ "00:57", "800000", "000420" ], + "000058" : [ "00:58", "800000", "000420" ], + "000059" : [ "00:59", "800000", "000420" ], + "000060" : [ "01:00", "800000", "000420" ], + "000061" : [ "01:01", "800000", "000420" ], + "000062" : [ "01:02", "800000", "000420" ], + "000063" : [ "01:03", "800000", "000420" ], + "000064" : [ "01:04", "800000", "000420" ], + "000065" : [ "01:05", "800000", "000420" ], + "000066" : [ "01:06", "800000", "000420" ], + "000067" : [ "01:07", "800000", "000420" ], + "000068" : [ "01:08", "800000", "000420" ], + "000069" : [ "01:09", "800000", "000420" ], + "000070" : [ "01:10", "800000", "000420" ], + "000071" : [ "01:11", "800000", "000420" ], + "000072" : [ "01:12", "800000", "000420" ], + "000073" : [ "01:13", "800000", "000420" ], + "000074" : [ "01:14", "800000", "000420" ], + "000075" : [ "01:15", "800000", "000420" ], + "000076" : [ "01:16", "800000", "000420" ], + "000077" : [ "01:17", "800000", "000420" ], + "000078" : [ "01:18", "800000", "000420" ], + "000079" : [ "01:19", "800000", "000420" ], + "000080" : [ "01:20", "800000", "000420" ], + "000081" : [ "01:21", "800000", "000420" ], + "000082" : [ "01:22", "800000", "000420" ], + "000083" : [ "01:23", "800000", "000420" ], + "000084" : [ "01:24", "800000", "000420" ], + "000085" : [ "01:25", "800000", "000420" ], + "000086" : [ "01:26", "800000", "000420" ], + "000087" : [ "01:27", "800000", "000420" ], + "000088" : [ "01:28", "800000", "000420" ], + "000089" : [ "01:29", "800000", "000420" ], + "000090" : [ "01:30", "800000", "000420" ], + "000091" : [ "01:31", "800000", "000420" ], + "000092" : [ "01:32", "800000", "000420" ], + "000093" : [ "01:33", "800000", "000420" ], + "000094" : [ "01:34", "800000", "000420" ], + "000095" : [ "01:35", "800000", "000420" ], + "000096" : [ "01:36", "800000", "000420" ], + "000097" : [ "01:37", "800000", "000420" ], + "000098" : [ "01:38", "800000", "000420" ], + "000099" : [ "01:39", "800000", "000420" ], + "000100" : [ "01:40", "800000", "000420" ], + "000101" : [ "01:41", "800000", "000420" ], + "000102" : [ "01:42", "800000", "000420" ], + "000103" : [ "01:43", "800000", "000420" ], + "000104" : [ "01:44", "800000", "000420" ], + "000105" : [ "01:45", "800000", "000420" ], + "000106" : [ "01:46", "800000", "000420" ], + "000107" : [ "01:47", "800000", "000420" ], + "000108" : [ "01:48", "800000", "000420" ], + "000109" : [ "01:49", "800000", "000420" ], + "000110" : [ "01:50", "800000", "000420" ], + "000111" : [ "01:51", "800000", "000420" ], + "000112" : [ "01:52", "800000", "000420" ], + "000113" : [ "01:53", "800000", "000420" ], + "000114" : [ "01:54", "800000", "000420" ], + "000115" : [ "01:55", "800000", "000420" ], + "000116" : [ "01:56", "800000", "000420" ], + "000117" : [ "01:57", "800000", "000420" ], + "000118" : [ "01:58", "800000", "000420" ], + "000119" : [ "01:59", "800000", "000420" ], + "000120" : [ "02:00", "800000", "000420" ], + "000121" : [ "02:01", "800000", "000420" ], + "000122" : [ "02:02", "800000", "000420" ], + "000123" : [ "02:03", "800000", "000420" ], + "000124" : [ "02:04", "800000", "000420" ], + "000125" : [ "02:05", "800000", "000420" ], + "000126" : [ "02:06", "800000", "000420" ], + "000127" : [ "02:07", "800000", "000420" ], + "000128" : [ "02:08", "800000", "000420" ], + "000129" : [ "02:09", "800000", "000420" ], + "000130" : [ "02:10", "800000", "000420" ], + "000131" : [ "02:11", "800000", "000420" ], + "000132" : [ "02:12", "800000", "000420" ], + "000133" : [ "02:13", "800000", "000420" ], + "000134" : [ "02:14", "800000", "000420" ], + "000135" : [ "02:15", "800000", "000420" ], + "000136" : [ "02:16", "800000", "000420" ], + "000137" : [ "02:17", "800000", "000420" ], + "000138" : [ "02:18", "800000", "000420" ], + "000139" : [ "02:19", "800000", "000420" ], + "000140" : [ "02:20", "800000", "000420" ], + "000141" : [ "02:21", "800000", "000420" ], + "000142" : [ "02:22", "800000", "000420" ], + "000143" : [ "02:23", "800000", "000420" ], + "000144" : [ "02:24", "800000", "000420" ], + "000145" : [ "02:25", "800000", "000420" ], + "000146" : [ "02:26", "800000", "000420" ], + "000147" : [ "02:27", "800000", "000420" ], + "000148" : [ "02:28", "800000", "000420" ], + "000149" : [ "02:29", "800000", "000420" ], + "000150" : [ "02:30", "800000", "000420" ], + "000151" : [ "02:31", "800000", "000420" ], + "000152" : [ "02:32", "800000", "000420" ], + "000153" : [ "02:33", "800000", "000420" ], + "000154" : [ "02:34", "800000", "000420" ], + "000155" : [ "02:35", "800000", "000420" ], + "000156" : [ "02:36", "800000", "000420" ], + "000157" : [ "02:37", "800000", "000420" ], + "000158" : [ "02:38", "800000", "000420" ], + "000159" : [ "02:39", "800000", "000420" ], + "000160" : [ "02:40", "800000", "000420" ], + "000161" : [ "02:41", "800000", "000420" ], + "000162" : [ "02:42", "800000", "000420" ], + "000163" : [ "02:43", "800000", "000420" ], + "000164" : [ "02:44", "800000", "000420" ], + "000165" : [ "02:45", "800000", "000420" ], + "000166" : [ "02:46", "800000", "000420" ], + "000167" : [ "02:47", "800000", "000420" ], + "000168" : [ "02:48", "800000", "000420" ], + "000169" : [ "02:49", "800000", "000420" ], + "000170" : [ "02:50", "800000", "000420" ], + "000171" : [ "02:51", "800000", "000420" ], + "000172" : [ "02:52", "800000", "000420" ], + "000173" : [ "02:53", "800000", "000420" ], + "000174" : [ "02:54", "800000", "000420" ], + "000175" : [ "02:55", "800000", "000420" ], + "000176" : [ "02:56", "800000", "000420" ], + "000177" : [ "02:57", "800000", "000420" ], + "000178" : [ "02:58", "800000", "000420" ], + "000179" : [ "02:59", "800000", "000420" ], + "000180" : [ "03:00", "800000", "000420" ], + "000181" : [ "03:01", "800000", "000420" ], + "000182" : [ "03:02", "800000", "000420" ], + "000183" : [ "03:03", "800000", "000420" ], + "000184" : [ "03:04", "800000", "000420" ], + "000185" : [ "03:05", "800000", "000420" ], + "000186" : [ "03:06", "800000", "000420" ], + "000187" : [ "03:07", "800000", "000420" ], + "000188" : [ "03:08", "800000", "000420" ], + "000189" : [ "03:09", "800000", "000420" ], + "000190" : [ "03:10", "800000", "000420" ], + "000191" : [ "03:11", "800000", "000420" ], + "000192" : [ "03:12", "800000", "000420" ], + "000193" : [ "03:13", "800000", "000420" ], + "000194" : [ "03:14", "800000", "000420" ], + "000195" : [ "03:15", "800000", "000420" ], + "000196" : [ "03:16", "800000", "000420" ], + "000197" : [ "03:17", "800000", "000420" ], + "000198" : [ "03:18", "800000", "000420" ], + "000199" : [ "03:19", "800000", "000420" ], + "000200" : [ "03:20", "800000", "000420" ], + "000201" : [ "03:21", "800000", "000420" ], + "000202" : [ "03:22", "800000", "000420" ], + "000203" : [ "03:23", "800000", "000420" ], + "000204" : [ "03:24", "800000", "000420" ], + "000205" : [ "03:25", "800000", "000420" ], + "000206" : [ "03:26", "800000", "000420" ], + "000207" : [ "03:27", "800000", "000420" ], + "000208" : [ "03:28", "800000", "000420" ], + "000209" : [ "03:29", "800000", "000420" ], + "000210" : [ "03:30", "800000", "000420" ], + "000211" : [ "03:31", "800000", "000420" ], + "000212" : [ "03:32", "800000", "000420" ], + "000213" : [ "03:33", "800000", "000420" ], + "000214" : [ "03:34", "800000", "000420" ], + "000215" : [ "03:35", "800000", "000420" ], + "000216" : [ "03:36", "800000", "000420" ], + "000217" : [ "03:37", "800000", "000420" ], + "000218" : [ "03:38", "800000", "000420" ], + "000219" : [ "03:39", "800000", "000420" ], + "000220" : [ "03:40", "800000", "000420" ], + "000221" : [ "03:41", "800000", "000420" ], + "000222" : [ "03:42", "800000", "000420" ], + "000223" : [ "03:43", "800000", "000420" ], + "000224" : [ "03:44", "800000", "000420" ], + "000225" : [ "03:45", "800000", "000420" ], + "000226" : [ "03:46", "800000", "000420" ], + "000227" : [ "03:47", "800000", "000420" ], + "000228" : [ "03:48", "800000", "000420" ], + "000229" : [ "03:49", "800000", "000420" ], + "000230" : [ "03:50", "800000", "000420" ], + "000231" : [ "03:51", "800000", "000420" ], + "000232" : [ "03:52", "800000", "000420" ], + "000233" : [ "03:53", "800000", "000420" ], + "000234" : [ "03:54", "800000", "000420" ], + "000235" : [ "03:55", "800000", "000420" ], + "000236" : [ "03:56", "800000", "000420" ], + "000237" : [ "03:57", "800000", "000420" ], + "000238" : [ "03:58", "800000", "000420" ], + "000239" : [ "03:59", "800000", "000420" ], + "000240" : [ "04:00", "800000", "000420" ], + "000241" : [ "04:01", "800000", "000420" ], + "000242" : [ "04:02", "800000", "000420" ], + "000243" : [ "04:03", "800000", "000420" ], + "000244" : [ "04:04", "800000", "000420" ], + "000245" : [ "04:05", "800000", "000420" ], + "000246" : [ "04:06", "800000", "000420" ], + "000247" : [ "04:07", "800000", "000420" ], + "000248" : [ "04:08", "800000", "000420" ], + "000249" : [ "04:09", "800000", "000420" ], + "000250" : [ "04:10", "800000", "000420" ], + "000251" : [ "04:11", "800000", "000420" ], + "000252" : [ "04:12", "800000", "000420" ], + "000253" : [ "04:13", "800000", "000420" ], + "000254" : [ "04:14", "800000", "000420" ], + "000255" : [ "04:15", "800000", "000420" ], + "000256" : [ "04:16", "800000", "000420" ], + "000257" : [ "04:17", "800000", "000420" ], + "000258" : [ "04:18", "800000", "000420" ], + "000259" : [ "04:19", "800000", "000420" ], + "000260" : [ "04:20", "800000", "000420" ], + "000261" : [ "04:21", "800000", "000420" ], + "000262" : [ "04:22", "800000", "000420" ], + "000263" : [ "04:23", "800000", "000420" ], + "000264" : [ "04:24", "800000", "000420" ], + "000265" : [ "04:25", "800000", "000420" ], + "000266" : [ "04:26", "800000", "000420" ], + "000267" : [ "04:27", "800000", "000420" ], + "000268" : [ "04:28", "800000", "000420" ], + "000269" : [ "04:29", "800000", "000420" ], + "000270" : [ "04:30", "800000", "000420" ], + "000271" : [ "04:31", "800000", "000420" ], + "000272" : [ "04:32", "800000", "000420" ], + "000273" : [ "04:33", "800000", "000420" ], + "000274" : [ "04:34", "800000", "000420" ], + "000275" : [ "04:35", "800000", "000420" ], + "000276" : [ "04:36", "800000", "000420" ], + "000277" : [ "04:37", "800000", "000420" ], + "000278" : [ "04:38", "800000", "000420" ], + "000279" : [ "04:39", "800000", "000420" ], + "000280" : [ "04:40", "800000", "000420" ], + "000281" : [ "04:41", "800000", "000420" ], + "000282" : [ "04:42", "800000", "000420" ], + "000283" : [ "04:43", "800000", "000420" ], + "000284" : [ "04:44", "800000", "000420" ], + "000285" : [ "04:45", "800000", "000420" ], + "000286" : [ "04:46", "800000", "000420" ], + "000287" : [ "04:47", "800000", "000420" ], + "000288" : [ "04:48", "800000", "000420" ], + "000289" : [ "04:49", "800000", "000420" ], + "000290" : [ "04:50", "800000", "000420" ], + "000291" : [ "04:51", "800000", "000420" ], + "000292" : [ "04:52", "800000", "000420" ], + "000293" : [ "04:53", "800000", "000420" ], + "000294" : [ "04:54", "800000", "000420" ], + "000295" : [ "04:55", "800000", "000420" ], + "000296" : [ "04:56", "800000", "000420" ], + "000297" : [ "04:57", "800000", "000420" ], + "000298" : [ "04:58", "800000", "000420" ], + "000299" : [ "04:59", "800000", "000420" ], + "000300" : [ "05:00", "800000", "000420" ], + "000301" : [ "05:01", "800000", "000420" ], + "000302" : [ "05:02", "800000", "000420" ], + "000303" : [ "05:03", "800000", "000420" ], + "000304" : [ "05:04", "800000", "000420" ], + "000305" : [ "05:05", "800000", "000420" ], + "000306" : [ "05:06", "800000", "000420" ], + "000307" : [ "05:07", "800000", "000420" ], + "000308" : [ "05:08", "800000", "000420" ], + "000309" : [ "05:09", "800000", "000420" ], + "000310" : [ "05:10", "800000", "000420" ], + "000311" : [ "05:11", "800000", "000420" ], + "000312" : [ "05:12", "800000", "000420" ], + "000313" : [ "05:13", "800000", "000420" ], + "000314" : [ "05:14", "800000", "000420" ], + "000315" : [ "05:15", "800000", "000420" ], + "000316" : [ "05:16", "800000", "000420" ], + "000317" : [ "05:17", "800000", "000420" ], + "000318" : [ "05:18", "800000", "000420" ], + "000319" : [ "05:19", "800000", "000420" ], + "000320" : [ "05:20", "800000", "000420" ], + "000321" : [ "05:21", "800000", "000420" ], + "000322" : [ "05:22", "800000", "000420" ], + "000323" : [ "05:23", "800000", "000420" ], + "000324" : [ "05:24", "800000", "000420" ], + "000325" : [ "05:25", "800000", "000420" ], + "000326" : [ "05:26", "800000", "000420" ], + "000327" : [ "05:27", "800000", "000420" ], + "000328" : [ "05:28", "800000", "000420" ], + "000329" : [ "05:29", "800000", "000420" ], + "000330" : [ "05:30", "800000", "000420" ], + "000331" : [ "05:31", "800000", "000420" ], + "000332" : [ "05:32", "800000", "000420" ], + "000333" : [ "05:33", "800000", "000420" ], + "000334" : [ "05:34", "800000", "000420" ], + "000335" : [ "05:35", "800000", "000420" ], + "000336" : [ "05:36", "800000", "000420" ], + "000337" : [ "05:37", "800000", "000420" ], + "000338" : [ "05:38", "800000", "000420" ], + "000339" : [ "05:39", "800000", "000420" ], + "000340" : [ "05:40", "800000", "000420" ], + "000341" : [ "05:41", "800000", "000420" ], + "000342" : [ "05:42", "800000", "000420" ], + "000343" : [ "05:43", "800000", "000420" ], + "000344" : [ "05:44", "800000", "000420" ], + "000345" : [ "05:45", "800000", "000420" ], + "000346" : [ "05:46", "800000", "000420" ], + "000347" : [ "05:47", "800000", "000420" ], + "000348" : [ "05:48", "800000", "000420" ], + "000349" : [ "05:49", "800000", "000420" ], + "000350" : [ "05:50", "800000", "000420" ], + "000351" : [ "05:51", "800000", "000420" ], + "000352" : [ "05:52", "800000", "000420" ], + "000353" : [ "05:53", "800000", "000420" ], + "000354" : [ "05:54", "800000", "000420" ], + "000355" : [ "05:55", "800000", "000420" ], + "000356" : [ "05:56", "800000", "000420" ], + "000357" : [ "05:57", "800000", "000420" ], + "000358" : [ "05:58", "800000", "000420" ], + "000359" : [ "05:59", "800000", "000420" ], + "000360" : [ "06:00", "800000", "000420" ], + "000361" : [ "06:01", "800000", "000420" ], + "000362" : [ "06:02", "800000", "000420" ], + "000363" : [ "06:03", "800000", "000420" ], + "000364" : [ "06:04", "800000", "000420" ], + "000365" : [ "06:05", "800000", "000420" ], + "000366" : [ "06:06", "800000", "000420" ], + "000367" : [ "06:07", "800000", "000420" ], + "000368" : [ "06:08", "800000", "000420" ], + "000369" : [ "06:09", "800000", "000420" ], + "000370" : [ "06:10", "800000", "000420" ], + "000371" : [ "06:11", "800000", "000420" ], + "000372" : [ "06:12", "800000", "000420" ], + "000373" : [ "06:13", "800000", "000420" ], + "000374" : [ "06:14", "800000", "000420" ], + "000375" : [ "06:15", "800000", "000420" ], + "000376" : [ "06:16", "800000", "000420" ], + "000377" : [ "06:17", "800000", "000420" ], + "000378" : [ "06:18", "800000", "000420" ], + "000379" : [ "06:19", "800000", "000420" ], + "000380" : [ "06:20", "800000", "000420" ], + "000381" : [ "06:21", "800000", "000420" ], + "000382" : [ "06:22", "800000", "000420" ], + "000383" : [ "06:23", "800000", "000420" ], + "000384" : [ "06:24", "800000", "000420" ], + "000385" : [ "06:25", "800000", "000420" ], + "000386" : [ "06:26", "800000", "000420" ], + "000387" : [ "06:27", "800000", "000420" ], + "000388" : [ "06:28", "800000", "000420" ], + "000389" : [ "06:29", "800000", "000420" ], + "000390" : [ "06:30", "800000", "000420" ], + "000391" : [ "06:31", "800000", "000420" ], + "000392" : [ "06:32", "800000", "000420" ], + "000393" : [ "06:33", "800000", "000420" ], + "000394" : [ "06:34", "800000", "000420" ], + "000395" : [ "06:35", "800000", "000420" ], + "000396" : [ "06:36", "800000", "000420" ], + "000397" : [ "06:37", "800000", "000420" ], + "000398" : [ "06:38", "800000", "000420" ], + "000399" : [ "06:39", "800000", "000420" ], + "000400" : [ "06:40", "800000", "000420" ], + "000401" : [ "06:41", "800000", "000420" ], + "000402" : [ "06:42", "800000", "000420" ], + "000403" : [ "06:43", "800000", "000420" ], + "000404" : [ "06:44", "800000", "000420" ], + "000405" : [ "06:45", "800000", "000420" ], + "000406" : [ "06:46", "800000", "000420" ], + "000407" : [ "06:47", "800000", "000420" ], + "000408" : [ "06:48", "800000", "000420" ], + "000409" : [ "06:49", "800000", "000420" ], + "000410" : [ "06:50", "800000", "000420" ], + "000411" : [ "06:51", "800000", "000420" ], + "000412" : [ "06:52", "800000", "000420" ], + "000413" : [ "06:53", "800000", "000420" ], + "000414" : [ "06:54", "800000", "000420" ], + "000415" : [ "06:55", "800000", "000420" ], + "000416" : [ "06:56", "800000", "000420" ], + "000417" : [ "06:57", "800000", "000420" ], + "000418" : [ "06:58", "800000", "000420" ], + "000419" : [ "06:59", "800000", "000420" ], + "000420" : [ "07:00", "350000", "000480" ], + "000421" : [ "07:01", "350000", "000481" ], + "000422" : [ "07:02", "350000", "000482" ], + "000423" : [ "07:03", "350000", "000483" ], + "000424" : [ "07:04", "350000", "000484" ], + "000425" : [ "07:05", "350000", "000485" ], + "000426" : [ "07:06", "350000", "000486" ], + "000427" : [ "07:07", "350000", "000487" ], + "000428" : [ "07:08", "350000", "000488" ], + "000429" : [ "07:09", "350000", "000489" ], + "000430" : [ "07:10", "350000", "000490" ], + "000431" : [ "07:11", "350000", "000491" ], + "000432" : [ "07:12", "350000", "000492" ], + "000433" : [ "07:13", "350000", "000493" ], + "000434" : [ "07:14", "350000", "000494" ], + "000435" : [ "07:15", "350000", "000495" ], + "000436" : [ "07:16", "350000", "000496" ], + "000437" : [ "07:17", "350000", "000497" ], + "000438" : [ "07:18", "350000", "000498" ], + "000439" : [ "07:19", "350000", "000499" ], + "000440" : [ "07:20", "350000", "000500" ], + "000441" : [ "07:21", "350000", "000501" ], + "000442" : [ "07:22", "350000", "000502" ], + "000443" : [ "07:23", "350000", "000503" ], + "000444" : [ "07:24", "350000", "000504" ], + "000445" : [ "07:25", "350000", "000505" ], + "000446" : [ "07:26", "350000", "000506" ], + "000447" : [ "07:27", "350000", "000507" ], + "000448" : [ "07:28", "350000", "000508" ], + "000449" : [ "07:29", "350000", "000509" ], + "000450" : [ "07:30", "350000", "000510" ], + "000451" : [ "07:31", "350000", "000511" ], + "000452" : [ "07:32", "350000", "000512" ], + "000453" : [ "07:33", "350000", "000513" ], + "000454" : [ "07:34", "350000", "000514" ], + "000455" : [ "07:35", "350000", "000515" ], + "000456" : [ "07:36", "350000", "000516" ], + "000457" : [ "07:37", "350000", "000517" ], + "000458" : [ "07:38", "350000", "000518" ], + "000459" : [ "07:39", "350000", "000519" ], + "000460" : [ "07:40", "350000", "000520" ], + "000461" : [ "07:41", "350000", "000521" ], + "000462" : [ "07:42", "350000", "000522" ], + "000463" : [ "07:43", "350000", "000523" ], + "000464" : [ "07:44", "350000", "000524" ], + "000465" : [ "07:45", "350000", "000525" ], + "000466" : [ "07:46", "350000", "000526" ], + "000467" : [ "07:47", "350000", "000527" ], + "000468" : [ "07:48", "350000", "000528" ], + "000469" : [ "07:49", "350000", "000529" ], + "000470" : [ "07:50", "350000", "000530" ], + "000471" : [ "07:51", "350000", "000531" ], + "000472" : [ "07:52", "350000", "000532" ], + "000473" : [ "07:53", "350000", "000533" ], + "000474" : [ "07:54", "350000", "000534" ], + "000475" : [ "07:55", "350000", "000535" ], + "000476" : [ "07:56", "350000", "000536" ], + "000477" : [ "07:57", "350000", "000537" ], + "000478" : [ "07:58", "350000", "000538" ], + "000479" : [ "07:59", "350000", "000539" ], + "000480" : [ "08:00", "350000", "000540" ], + "000481" : [ "08:01", "350000", "000541" ], + "000482" : [ "08:02", "350000", "000542" ], + "000483" : [ "08:03", "350000", "000543" ], + "000484" : [ "08:04", "350000", "000544" ], + "000485" : [ "08:05", "350000", "000545" ], + "000486" : [ "08:06", "350000", "000546" ], + "000487" : [ "08:07", "350000", "000547" ], + "000488" : [ "08:08", "350000", "000548" ], + "000489" : [ "08:09", "350000", "000549" ], + "000490" : [ "08:10", "350000", "000550" ], + "000491" : [ "08:11", "350000", "000551" ], + "000492" : [ "08:12", "350000", "000552" ], + "000493" : [ "08:13", "350000", "000553" ], + "000494" : [ "08:14", "350000", "000554" ], + "000495" : [ "08:15", "350000", "000555" ], + "000496" : [ "08:16", "350000", "000556" ], + "000497" : [ "08:17", "350000", "000557" ], + "000498" : [ "08:18", "350000", "000558" ], + "000499" : [ "08:19", "350000", "000559" ], + "000500" : [ "08:20", "350000", "000560" ], + "000501" : [ "08:21", "350000", "000561" ], + "000502" : [ "08:22", "350000", "000562" ], + "000503" : [ "08:23", "350000", "000563" ], + "000504" : [ "08:24", "350000", "000564" ], + "000505" : [ "08:25", "350000", "000565" ], + "000506" : [ "08:26", "350000", "000566" ], + "000507" : [ "08:27", "350000", "000567" ], + "000508" : [ "08:28", "350000", "000568" ], + "000509" : [ "08:29", "350000", "000569" ], + "000510" : [ "08:30", "350000", "000570" ], + "000511" : [ "08:31", "350000", "000571" ], + "000512" : [ "08:32", "350000", "000572" ], + "000513" : [ "08:33", "350000", "000573" ], + "000514" : [ "08:34", "350000", "000574" ], + "000515" : [ "08:35", "350000", "000575" ], + "000516" : [ "08:36", "350000", "000576" ], + "000517" : [ "08:37", "350000", "000577" ], + "000518" : [ "08:38", "350000", "000578" ], + "000519" : [ "08:39", "350000", "000579" ], + "000520" : [ "08:40", "350000", "000580" ], + "000521" : [ "08:41", "350000", "000581" ], + "000522" : [ "08:42", "350000", "000582" ], + "000523" : [ "08:43", "350000", "000583" ], + "000524" : [ "08:44", "350000", "000584" ], + "000525" : [ "08:45", "350000", "000585" ], + "000526" : [ "08:46", "350000", "000586" ], + "000527" : [ "08:47", "350000", "000587" ], + "000528" : [ "08:48", "350000", "000588" ], + "000529" : [ "08:49", "350000", "000589" ], + "000530" : [ "08:50", "350000", "000590" ], + "000531" : [ "08:51", "350000", "000591" ], + "000532" : [ "08:52", "350000", "000592" ], + "000533" : [ "08:53", "350000", "000593" ], + "000534" : [ "08:54", "350000", "000594" ], + "000535" : [ "08:55", "350000", "000595" ], + "000536" : [ "08:56", "350000", "000596" ], + "000537" : [ "08:57", "350000", "000597" ], + "000538" : [ "08:58", "350000", "000598" ], + "000539" : [ "08:59", "350000", "000599" ], + "000540" : [ "09:00", "350000", "000600" ], + "000541" : [ "09:01", "350000", "000601" ], + "000542" : [ "09:02", "350000", "000602" ], + "000543" : [ "09:03", "350000", "000603" ], + "000544" : [ "09:04", "350000", "000604" ], + "000545" : [ "09:05", "350000", "000605" ], + "000546" : [ "09:06", "350000", "000606" ], + "000547" : [ "09:07", "350000", "000607" ], + "000548" : [ "09:08", "350000", "000608" ], + "000549" : [ "09:09", "350000", "000609" ], + "000550" : [ "09:10", "350000", "000610" ], + "000551" : [ "09:11", "350000", "000611" ], + "000552" : [ "09:12", "350000", "000612" ], + "000553" : [ "09:13", "350000", "000613" ], + "000554" : [ "09:14", "350000", "000614" ], + "000555" : [ "09:15", "350000", "000615" ], + "000556" : [ "09:16", "350000", "000616" ], + "000557" : [ "09:17", "350000", "000617" ], + "000558" : [ "09:18", "350000", "000618" ], + "000559" : [ "09:19", "350000", "000619" ], + "000560" : [ "09:20", "350000", "000620" ], + "000561" : [ "09:21", "350000", "000621" ], + "000562" : [ "09:22", "350000", "000622" ], + "000563" : [ "09:23", "350000", "000623" ], + "000564" : [ "09:24", "350000", "000624" ], + "000565" : [ "09:25", "350000", "000625" ], + "000566" : [ "09:26", "350000", "000626" ], + "000567" : [ "09:27", "350000", "000627" ], + "000568" : [ "09:28", "350000", "000628" ], + "000569" : [ "09:29", "350000", "000629" ], + "000570" : [ "09:30", "350000", "000630" ], + "000571" : [ "09:31", "350000", "000631" ], + "000572" : [ "09:32", "350000", "000632" ], + "000573" : [ "09:33", "350000", "000633" ], + "000574" : [ "09:34", "350000", "000634" ], + "000575" : [ "09:35", "350000", "000635" ], + "000576" : [ "09:36", "350000", "000636" ], + "000577" : [ "09:37", "350000", "000637" ], + "000578" : [ "09:38", "350000", "000638" ], + "000579" : [ "09:39", "350000", "000639" ], + "000580" : [ "09:40", "350000", "000640" ], + "000581" : [ "09:41", "350000", "000641" ], + "000582" : [ "09:42", "350000", "000642" ], + "000583" : [ "09:43", "350000", "000643" ], + "000584" : [ "09:44", "350000", "000644" ], + "000585" : [ "09:45", "350000", "000645" ], + "000586" : [ "09:46", "350000", "000646" ], + "000587" : [ "09:47", "350000", "000647" ], + "000588" : [ "09:48", "350000", "000648" ], + "000589" : [ "09:49", "350000", "000649" ], + "000590" : [ "09:50", "350000", "000650" ], + "000591" : [ "09:51", "350000", "000651" ], + "000592" : [ "09:52", "350000", "000652" ], + "000593" : [ "09:53", "350000", "000653" ], + "000594" : [ "09:54", "350000", "000654" ], + "000595" : [ "09:55", "350000", "000655" ], + "000596" : [ "09:56", "350000", "000656" ], + "000597" : [ "09:57", "350000", "000657" ], + "000598" : [ "09:58", "350000", "000658" ], + "000599" : [ "09:59", "350000", "000659" ], + "000600" : [ "10:00", "350000", "000660" ], + "000601" : [ "10:01", "350000", "000661" ], + "000602" : [ "10:02", "350000", "000662" ], + "000603" : [ "10:03", "350000", "000663" ], + "000604" : [ "10:04", "350000", "000664" ], + "000605" : [ "10:05", "350000", "000665" ], + "000606" : [ "10:06", "350000", "000666" ], + "000607" : [ "10:07", "350000", "000667" ], + "000608" : [ "10:08", "350000", "000668" ], + "000609" : [ "10:09", "350000", "000669" ], + "000610" : [ "10:10", "350000", "000670" ], + "000611" : [ "10:11", "350000", "000671" ], + "000612" : [ "10:12", "350000", "000672" ], + "000613" : [ "10:13", "350000", "000673" ], + "000614" : [ "10:14", "350000", "000674" ], + "000615" : [ "10:15", "350000", "000675" ], + "000616" : [ "10:16", "350000", "000676" ], + "000617" : [ "10:17", "350000", "000677" ], + "000618" : [ "10:18", "350000", "000678" ], + "000619" : [ "10:19", "350000", "000679" ], + "000620" : [ "10:20", "350000", "000680" ], + "000621" : [ "10:21", "350000", "000681" ], + "000622" : [ "10:22", "350000", "000682" ], + "000623" : [ "10:23", "350000", "000683" ], + "000624" : [ "10:24", "350000", "000684" ], + "000625" : [ "10:25", "350000", "000685" ], + "000626" : [ "10:26", "350000", "000686" ], + "000627" : [ "10:27", "350000", "000687" ], + "000628" : [ "10:28", "350000", "000688" ], + "000629" : [ "10:29", "350000", "000689" ], + "000630" : [ "10:30", "350000", "000690" ], + "000631" : [ "10:31", "350000", "000691" ], + "000632" : [ "10:32", "350000", "000692" ], + "000633" : [ "10:33", "350000", "000693" ], + "000634" : [ "10:34", "350000", "000694" ], + "000635" : [ "10:35", "350000", "000695" ], + "000636" : [ "10:36", "350000", "000696" ], + "000637" : [ "10:37", "350000", "000697" ], + "000638" : [ "10:38", "350000", "000698" ], + "000639" : [ "10:39", "350000", "000699" ], + "000640" : [ "10:40", "350000", "000700" ], + "000641" : [ "10:41", "350000", "000701" ], + "000642" : [ "10:42", "350000", "000702" ], + "000643" : [ "10:43", "350000", "000703" ], + "000644" : [ "10:44", "350000", "000704" ], + "000645" : [ "10:45", "350000", "000705" ], + "000646" : [ "10:46", "350000", "000706" ], + "000647" : [ "10:47", "350000", "000707" ], + "000648" : [ "10:48", "350000", "000708" ], + "000649" : [ "10:49", "350000", "000709" ], + "000650" : [ "10:50", "350000", "000710" ], + "000651" : [ "10:51", "350000", "000711" ], + "000652" : [ "10:52", "350000", "000712" ], + "000653" : [ "10:53", "350000", "000713" ], + "000654" : [ "10:54", "350000", "000714" ], + "000655" : [ "10:55", "350000", "000715" ], + "000656" : [ "10:56", "350000", "000716" ], + "000657" : [ "10:57", "350000", "000717" ], + "000658" : [ "10:58", "350000", "000718" ], + "000659" : [ "10:59", "350000", "000719" ], + "000660" : [ "11:00", "350000", "000720" ], + "000661" : [ "11:01", "350000", "000721" ], + "000662" : [ "11:02", "350000", "000722" ], + "000663" : [ "11:03", "350000", "000723" ], + "000664" : [ "11:04", "350000", "000724" ], + "000665" : [ "11:05", "350000", "000725" ], + "000666" : [ "11:06", "350000", "000726" ], + "000667" : [ "11:07", "350000", "000727" ], + "000668" : [ "11:08", "350000", "000728" ], + "000669" : [ "11:09", "350000", "000729" ], + "000670" : [ "11:10", "350000", "000730" ], + "000671" : [ "11:11", "350000", "000731" ], + "000672" : [ "11:12", "350000", "000732" ], + "000673" : [ "11:13", "350000", "000733" ], + "000674" : [ "11:14", "350000", "000734" ], + "000675" : [ "11:15", "350000", "000735" ], + "000676" : [ "11:16", "350000", "000736" ], + "000677" : [ "11:17", "350000", "000737" ], + "000678" : [ "11:18", "350000", "000738" ], + "000679" : [ "11:19", "350000", "000739" ], + "000680" : [ "11:20", "350000", "000740" ], + "000681" : [ "11:21", "350000", "000741" ], + "000682" : [ "11:22", "350000", "000742" ], + "000683" : [ "11:23", "350000", "000743" ], + "000684" : [ "11:24", "350000", "000744" ], + "000685" : [ "11:25", "350000", "000745" ], + "000686" : [ "11:26", "350000", "000746" ], + "000687" : [ "11:27", "350000", "000747" ], + "000688" : [ "11:28", "350000", "000748" ], + "000689" : [ "11:29", "350000", "000749" ], + "000690" : [ "11:30", "350000", "000750" ], + "000691" : [ "11:31", "350000", "000751" ], + "000692" : [ "11:32", "350000", "000752" ], + "000693" : [ "11:33", "350000", "000753" ], + "000694" : [ "11:34", "350000", "000754" ], + "000695" : [ "11:35", "350000", "000755" ], + "000696" : [ "11:36", "350000", "000756" ], + "000697" : [ "11:37", "350000", "000757" ], + "000698" : [ "11:38", "350000", "000758" ], + "000699" : [ "11:39", "350000", "000759" ], + "000700" : [ "11:40", "350000", "000760" ], + "000701" : [ "11:41", "350000", "000761" ], + "000702" : [ "11:42", "350000", "000762" ], + "000703" : [ "11:43", "350000", "000763" ], + "000704" : [ "11:44", "350000", "000764" ], + "000705" : [ "11:45", "350000", "000765" ], + "000706" : [ "11:46", "350000", "000766" ], + "000707" : [ "11:47", "350000", "000767" ], + "000708" : [ "11:48", "350000", "000768" ], + "000709" : [ "11:49", "350000", "000769" ], + "000710" : [ "11:50", "350000", "000770" ], + "000711" : [ "11:51", "350000", "000771" ], + "000712" : [ "11:52", "350000", "000772" ], + "000713" : [ "11:53", "350000", "000773" ], + "000714" : [ "11:54", "350000", "000774" ], + "000715" : [ "11:55", "350000", "000775" ], + "000716" : [ "11:56", "350000", "000776" ], + "000717" : [ "11:57", "350000", "000777" ], + "000718" : [ "11:58", "350000", "000778" ], + "000719" : [ "11:59", "350000", "000779" ], + "000720" : [ "12:00", "350000", "000780" ], + "000721" : [ "12:01", "350000", "000781" ], + "000722" : [ "12:02", "350000", "000782" ], + "000723" : [ "12:03", "350000", "000783" ], + "000724" : [ "12:04", "350000", "000784" ], + "000725" : [ "12:05", "350000", "000785" ], + "000726" : [ "12:06", "350000", "000786" ], + "000727" : [ "12:07", "350000", "000787" ], + "000728" : [ "12:08", "350000", "000788" ], + "000729" : [ "12:09", "350000", "000789" ], + "000730" : [ "12:10", "350000", "000790" ], + "000731" : [ "12:11", "350000", "000791" ], + "000732" : [ "12:12", "350000", "000792" ], + "000733" : [ "12:13", "350000", "000793" ], + "000734" : [ "12:14", "350000", "000794" ], + "000735" : [ "12:15", "350000", "000795" ], + "000736" : [ "12:16", "350000", "000796" ], + "000737" : [ "12:17", "350000", "000797" ], + "000738" : [ "12:18", "350000", "000798" ], + "000739" : [ "12:19", "350000", "000799" ], + "000740" : [ "12:20", "350000", "000800" ], + "000741" : [ "12:21", "350000", "000801" ], + "000742" : [ "12:22", "350000", "000802" ], + "000743" : [ "12:23", "350000", "000803" ], + "000744" : [ "12:24", "350000", "000804" ], + "000745" : [ "12:25", "350000", "000805" ], + "000746" : [ "12:26", "350000", "000806" ], + "000747" : [ "12:27", "350000", "000807" ], + "000748" : [ "12:28", "350000", "000808" ], + "000749" : [ "12:29", "350000", "000809" ], + "000750" : [ "12:30", "350000", "000810" ], + "000751" : [ "12:31", "350000", "000811" ], + "000752" : [ "12:32", "350000", "000812" ], + "000753" : [ "12:33", "350000", "000813" ], + "000754" : [ "12:34", "350000", "000814" ], + "000755" : [ "12:35", "350000", "000815" ], + "000756" : [ "12:36", "350000", "000816" ], + "000757" : [ "12:37", "350000", "000817" ], + "000758" : [ "12:38", "350000", "000818" ], + "000759" : [ "12:39", "350000", "000819" ], + "000760" : [ "12:40", "350000", "000820" ], + "000761" : [ "12:41", "350000", "000821" ], + "000762" : [ "12:42", "350000", "000822" ], + "000763" : [ "12:43", "350000", "000823" ], + "000764" : [ "12:44", "350000", "000824" ], + "000765" : [ "12:45", "350000", "000825" ], + "000766" : [ "12:46", "350000", "000826" ], + "000767" : [ "12:47", "350000", "000827" ], + "000768" : [ "12:48", "350000", "000828" ], + "000769" : [ "12:49", "350000", "000829" ], + "000770" : [ "12:50", "350000", "000830" ], + "000771" : [ "12:51", "350000", "000831" ], + "000772" : [ "12:52", "350000", "000832" ], + "000773" : [ "12:53", "350000", "000833" ], + "000774" : [ "12:54", "350000", "000834" ], + "000775" : [ "12:55", "350000", "000835" ], + "000776" : [ "12:56", "350000", "000836" ], + "000777" : [ "12:57", "350000", "000837" ], + "000778" : [ "12:58", "350000", "000838" ], + "000779" : [ "12:59", "350000", "000839" ], + "000780" : [ "13:00", "350000", "000840" ], + "000781" : [ "13:01", "350000", "000841" ], + "000782" : [ "13:02", "350000", "000842" ], + "000783" : [ "13:03", "350000", "000843" ], + "000784" : [ "13:04", "350000", "000844" ], + "000785" : [ "13:05", "350000", "000845" ], + "000786" : [ "13:06", "350000", "000846" ], + "000787" : [ "13:07", "350000", "000847" ], + "000788" : [ "13:08", "350000", "000848" ], + "000789" : [ "13:09", "350000", "000849" ], + "000790" : [ "13:10", "350000", "000850" ], + "000791" : [ "13:11", "350000", "000851" ], + "000792" : [ "13:12", "350000", "000852" ], + "000793" : [ "13:13", "350000", "000853" ], + "000794" : [ "13:14", "350000", "000854" ], + "000795" : [ "13:15", "350000", "000855" ], + "000796" : [ "13:16", "350000", "000856" ], + "000797" : [ "13:17", "350000", "000857" ], + "000798" : [ "13:18", "350000", "000858" ], + "000799" : [ "13:19", "350000", "000859" ], + "000800" : [ "13:20", "350000", "000860" ], + "000801" : [ "13:21", "350000", "000861" ], + "000802" : [ "13:22", "350000", "000862" ], + "000803" : [ "13:23", "350000", "000863" ], + "000804" : [ "13:24", "350000", "000864" ], + "000805" : [ "13:25", "350000", "000865" ], + "000806" : [ "13:26", "350000", "000866" ], + "000807" : [ "13:27", "350000", "000867" ], + "000808" : [ "13:28", "350000", "000868" ], + "000809" : [ "13:29", "350000", "000869" ], + "000810" : [ "13:30", "350000", "000870" ], + "000811" : [ "13:31", "350000", "000871" ], + "000812" : [ "13:32", "350000", "000872" ], + "000813" : [ "13:33", "350000", "000873" ], + "000814" : [ "13:34", "350000", "000874" ], + "000815" : [ "13:35", "350000", "000875" ], + "000816" : [ "13:36", "350000", "000876" ], + "000817" : [ "13:37", "350000", "000877" ], + "000818" : [ "13:38", "350000", "000878" ], + "000819" : [ "13:39", "350000", "000879" ], + "000820" : [ "13:40", "350000", "000880" ], + "000821" : [ "13:41", "350000", "000881" ], + "000822" : [ "13:42", "350000", "000882" ], + "000823" : [ "13:43", "350000", "000883" ], + "000824" : [ "13:44", "350000", "000884" ], + "000825" : [ "13:45", "350000", "000885" ], + "000826" : [ "13:46", "350000", "000886" ], + "000827" : [ "13:47", "350000", "000887" ], + "000828" : [ "13:48", "350000", "000888" ], + "000829" : [ "13:49", "350000", "000889" ], + "000830" : [ "13:50", "350000", "000890" ], + "000831" : [ "13:51", "350000", "000891" ], + "000832" : [ "13:52", "350000", "000892" ], + "000833" : [ "13:53", "350000", "000893" ], + "000834" : [ "13:54", "350000", "000894" ], + "000835" : [ "13:55", "350000", "000895" ], + "000836" : [ "13:56", "350000", "000896" ], + "000837" : [ "13:57", "350000", "000897" ], + "000838" : [ "13:58", "350000", "000898" ], + "000839" : [ "13:59", "350000", "000899" ], + "000840" : [ "14:00", "350000", "000900" ], + "000841" : [ "14:01", "350000", "000901" ], + "000842" : [ "14:02", "350000", "000902" ], + "000843" : [ "14:03", "350000", "000903" ], + "000844" : [ "14:04", "350000", "000904" ], + "000845" : [ "14:05", "350000", "000905" ], + "000846" : [ "14:06", "350000", "000906" ], + "000847" : [ "14:07", "350000", "000907" ], + "000848" : [ "14:08", "350000", "000908" ], + "000849" : [ "14:09", "350000", "000909" ], + "000850" : [ "14:10", "350000", "000910" ], + "000851" : [ "14:11", "350000", "000911" ], + "000852" : [ "14:12", "350000", "000912" ], + "000853" : [ "14:13", "350000", "000913" ], + "000854" : [ "14:14", "350000", "000914" ], + "000855" : [ "14:15", "350000", "000915" ], + "000856" : [ "14:16", "350000", "000916" ], + "000857" : [ "14:17", "350000", "000917" ], + "000858" : [ "14:18", "350000", "000918" ], + "000859" : [ "14:19", "350000", "000919" ], + "000860" : [ "14:20", "350000", "000920" ], + "000861" : [ "14:21", "350000", "000921" ], + "000862" : [ "14:22", "350000", "000922" ], + "000863" : [ "14:23", "350000", "000923" ], + "000864" : [ "14:24", "350000", "000924" ], + "000865" : [ "14:25", "350000", "000925" ], + "000866" : [ "14:26", "350000", "000926" ], + "000867" : [ "14:27", "350000", "000927" ], + "000868" : [ "14:28", "350000", "000928" ], + "000869" : [ "14:29", "350000", "000929" ], + "000870" : [ "14:30", "350000", "000930" ], + "000871" : [ "14:31", "350000", "000931" ], + "000872" : [ "14:32", "350000", "000932" ], + "000873" : [ "14:33", "350000", "000933" ], + "000874" : [ "14:34", "350000", "000934" ], + "000875" : [ "14:35", "350000", "000935" ], + "000876" : [ "14:36", "350000", "000936" ], + "000877" : [ "14:37", "350000", "000937" ], + "000878" : [ "14:38", "350000", "000938" ], + "000879" : [ "14:39", "350000", "000939" ], + "000880" : [ "14:40", "350000", "000940" ], + "000881" : [ "14:41", "350000", "000941" ], + "000882" : [ "14:42", "350000", "000942" ], + "000883" : [ "14:43", "350000", "000943" ], + "000884" : [ "14:44", "350000", "000944" ], + "000885" : [ "14:45", "350000", "000945" ], + "000886" : [ "14:46", "350000", "000946" ], + "000887" : [ "14:47", "350000", "000947" ], + "000888" : [ "14:48", "350000", "000948" ], + "000889" : [ "14:49", "350000", "000949" ], + "000890" : [ "14:50", "350000", "000950" ], + "000891" : [ "14:51", "350000", "000951" ], + "000892" : [ "14:52", "350000", "000952" ], + "000893" : [ "14:53", "350000", "000953" ], + "000894" : [ "14:54", "350000", "000954" ], + "000895" : [ "14:55", "350000", "000955" ], + "000896" : [ "14:56", "350000", "000956" ], + "000897" : [ "14:57", "350000", "000957" ], + "000898" : [ "14:58", "350000", "000958" ], + "000899" : [ "14:59", "350000", "000959" ], + "000900" : [ "15:00", "350000", "000960" ], + "000901" : [ "15:01", "350000", "000961" ], + "000902" : [ "15:02", "350000", "000962" ], + "000903" : [ "15:03", "350000", "000963" ], + "000904" : [ "15:04", "350000", "000964" ], + "000905" : [ "15:05", "350000", "000965" ], + "000906" : [ "15:06", "350000", "000966" ], + "000907" : [ "15:07", "350000", "000967" ], + "000908" : [ "15:08", "350000", "000968" ], + "000909" : [ "15:09", "350000", "000969" ], + "000910" : [ "15:10", "350000", "000970" ], + "000911" : [ "15:11", "350000", "000971" ], + "000912" : [ "15:12", "350000", "000972" ], + "000913" : [ "15:13", "350000", "000973" ], + "000914" : [ "15:14", "350000", "000974" ], + "000915" : [ "15:15", "350000", "000975" ], + "000916" : [ "15:16", "350000", "000976" ], + "000917" : [ "15:17", "350000", "000977" ], + "000918" : [ "15:18", "350000", "000978" ], + "000919" : [ "15:19", "350000", "000979" ], + "000920" : [ "15:20", "350000", "000980" ], + "000921" : [ "15:21", "350000", "000981" ], + "000922" : [ "15:22", "350000", "000982" ], + "000923" : [ "15:23", "350000", "000983" ], + "000924" : [ "15:24", "350000", "000984" ], + "000925" : [ "15:25", "350000", "000985" ], + "000926" : [ "15:26", "350000", "000986" ], + "000927" : [ "15:27", "350000", "000987" ], + "000928" : [ "15:28", "350000", "000988" ], + "000929" : [ "15:29", "350000", "000989" ], + "000930" : [ "15:30", "350000", "000990" ], + "000931" : [ "15:31", "350000", "000991" ], + "000932" : [ "15:32", "350000", "000992" ], + "000933" : [ "15:33", "350000", "000993" ], + "000934" : [ "15:34", "350000", "000994" ], + "000935" : [ "15:35", "350000", "000995" ], + "000936" : [ "15:36", "350000", "000996" ], + "000937" : [ "15:37", "350000", "000997" ], + "000938" : [ "15:38", "350000", "000998" ], + "000939" : [ "15:39", "350000", "000999" ], + "000940" : [ "15:40", "350000", "001000" ], + "000941" : [ "15:41", "350000", "001001" ], + "000942" : [ "15:42", "350000", "001002" ], + "000943" : [ "15:43", "350000", "001003" ], + "000944" : [ "15:44", "350000", "001004" ], + "000945" : [ "15:45", "350000", "001005" ], + "000946" : [ "15:46", "350000", "001006" ], + "000947" : [ "15:47", "350000", "001007" ], + "000948" : [ "15:48", "350000", "001008" ], + "000949" : [ "15:49", "350000", "001009" ], + "000950" : [ "15:50", "350000", "001010" ], + "000951" : [ "15:51", "350000", "001011" ], + "000952" : [ "15:52", "350000", "001012" ], + "000953" : [ "15:53", "350000", "001013" ], + "000954" : [ "15:54", "350000", "001014" ], + "000955" : [ "15:55", "350000", "001015" ], + "000956" : [ "15:56", "350000", "001016" ], + "000957" : [ "15:57", "350000", "001017" ], + "000958" : [ "15:58", "350000", "001018" ], + "000959" : [ "15:59", "350000", "001019" ], + "000960" : [ "16:00", "350000", "001020" ], + "000961" : [ "16:01", "350000", "001021" ], + "000962" : [ "16:02", "350000", "001022" ], + "000963" : [ "16:03", "350000", "001023" ], + "000964" : [ "16:04", "350000", "001024" ], + "000965" : [ "16:05", "350000", "001025" ], + "000966" : [ "16:06", "350000", "001026" ], + "000967" : [ "16:07", "350000", "001027" ], + "000968" : [ "16:08", "350000", "001028" ], + "000969" : [ "16:09", "350000", "001029" ], + "000970" : [ "16:10", "350000", "001030" ], + "000971" : [ "16:11", "350000", "001031" ], + "000972" : [ "16:12", "350000", "001032" ], + "000973" : [ "16:13", "350000", "001033" ], + "000974" : [ "16:14", "350000", "001034" ], + "000975" : [ "16:15", "350000", "001035" ], + "000976" : [ "16:16", "350000", "001036" ], + "000977" : [ "16:17", "350000", "001037" ], + "000978" : [ "16:18", "350000", "001038" ], + "000979" : [ "16:19", "350000", "001039" ], + "000980" : [ "16:20", "350000", "001040" ], + "000981" : [ "16:21", "350000", "001041" ], + "000982" : [ "16:22", "350000", "001042" ], + "000983" : [ "16:23", "350000", "001043" ], + "000984" : [ "16:24", "350000", "001044" ], + "000985" : [ "16:25", "350000", "001045" ], + "000986" : [ "16:26", "350000", "001046" ], + "000987" : [ "16:27", "350000", "001047" ], + "000988" : [ "16:28", "350000", "001048" ], + "000989" : [ "16:29", "350000", "001049" ], + "000990" : [ "16:30", "350000", "001050" ], + "000991" : [ "16:31", "350000", "001051" ], + "000992" : [ "16:32", "350000", "001052" ], + "000993" : [ "16:33", "350000", "001053" ], + "000994" : [ "16:34", "350000", "001054" ], + "000995" : [ "16:35", "350000", "001055" ], + "000996" : [ "16:36", "350000", "001056" ], + "000997" : [ "16:37", "350000", "001057" ], + "000998" : [ "16:38", "350000", "001058" ], + "000999" : [ "16:39", "350000", "001059" ], + "001000" : [ "16:40", "350000", "001060" ], + "001001" : [ "16:41", "350000", "001061" ], + "001002" : [ "16:42", "350000", "001062" ], + "001003" : [ "16:43", "350000", "001063" ], + "001004" : [ "16:44", "350000", "001064" ], + "001005" : [ "16:45", "350000", "001065" ], + "001006" : [ "16:46", "350000", "001066" ], + "001007" : [ "16:47", "350000", "001067" ], + "001008" : [ "16:48", "350000", "001068" ], + "001009" : [ "16:49", "350000", "001069" ], + "001010" : [ "16:50", "350000", "001070" ], + "001011" : [ "16:51", "350000", "001071" ], + "001012" : [ "16:52", "350000", "001072" ], + "001013" : [ "16:53", "350000", "001073" ], + "001014" : [ "16:54", "350000", "001074" ], + "001015" : [ "16:55", "350000", "001075" ], + "001016" : [ "16:56", "350000", "001076" ], + "001017" : [ "16:57", "350000", "001077" ], + "001018" : [ "16:58", "350000", "001078" ], + "001019" : [ "16:59", "350000", "001079" ], + "001020" : [ "17:00", "350000", "001080" ], + "001021" : [ "17:01", "350000", "001081" ], + "001022" : [ "17:02", "350000", "001082" ], + "001023" : [ "17:03", "350000", "001083" ], + "001024" : [ "17:04", "350000", "001084" ], + "001025" : [ "17:05", "350000", "001085" ], + "001026" : [ "17:06", "350000", "001086" ], + "001027" : [ "17:07", "350000", "001087" ], + "001028" : [ "17:08", "350000", "001088" ], + "001029" : [ "17:09", "350000", "001089" ], + "001030" : [ "17:10", "350000", "001090" ], + "001031" : [ "17:11", "350000", "001091" ], + "001032" : [ "17:12", "350000", "001092" ], + "001033" : [ "17:13", "350000", "001093" ], + "001034" : [ "17:14", "350000", "001094" ], + "001035" : [ "17:15", "350000", "001095" ], + "001036" : [ "17:16", "350000", "001096" ], + "001037" : [ "17:17", "350000", "001097" ], + "001038" : [ "17:18", "350000", "001098" ], + "001039" : [ "17:19", "350000", "001099" ], + "001040" : [ "17:20", "350000", "001100" ], + "001041" : [ "17:21", "350000", "001101" ], + "001042" : [ "17:22", "350000", "001102" ], + "001043" : [ "17:23", "350000", "001103" ], + "001044" : [ "17:24", "350000", "001104" ], + "001045" : [ "17:25", "350000", "001105" ], + "001046" : [ "17:26", "350000", "001106" ], + "001047" : [ "17:27", "350000", "001107" ], + "001048" : [ "17:28", "350000", "001108" ], + "001049" : [ "17:29", "350000", "001109" ], + "001050" : [ "17:30", "350000", "001110" ], + "001051" : [ "17:31", "350000", "001111" ], + "001052" : [ "17:32", "350000", "001112" ], + "001053" : [ "17:33", "350000", "001113" ], + "001054" : [ "17:34", "350000", "001114" ], + "001055" : [ "17:35", "350000", "001115" ], + "001056" : [ "17:36", "350000", "001116" ], + "001057" : [ "17:37", "350000", "001117" ], + "001058" : [ "17:38", "350000", "001118" ], + "001059" : [ "17:39", "350000", "001119" ], + "001060" : [ "17:40", "350000", "001120" ], + "001061" : [ "17:41", "350000", "001121" ], + "001062" : [ "17:42", "350000", "001122" ], + "001063" : [ "17:43", "350000", "001123" ], + "001064" : [ "17:44", "350000", "001124" ], + "001065" : [ "17:45", "350000", "001125" ], + "001066" : [ "17:46", "350000", "001126" ], + "001067" : [ "17:47", "350000", "001127" ], + "001068" : [ "17:48", "350000", "001128" ], + "001069" : [ "17:49", "350000", "001129" ], + "001070" : [ "17:50", "350000", "001130" ], + "001071" : [ "17:51", "350000", "001131" ], + "001072" : [ "17:52", "350000", "001132" ], + "001073" : [ "17:53", "350000", "001133" ], + "001074" : [ "17:54", "350000", "001134" ], + "001075" : [ "17:55", "350000", "001135" ], + "001076" : [ "17:56", "350000", "001136" ], + "001077" : [ "17:57", "350000", "001137" ], + "001078" : [ "17:58", "350000", "001138" ], + "001079" : [ "17:59", "350000", "001139" ], + "001080" : [ "18:00", "350000", "001140" ], + "001081" : [ "18:01", "350000", "001141" ], + "001082" : [ "18:02", "350000", "001142" ], + "001083" : [ "18:03", "350000", "001143" ], + "001084" : [ "18:04", "350000", "001144" ], + "001085" : [ "18:05", "350000", "001145" ], + "001086" : [ "18:06", "350000", "001146" ], + "001087" : [ "18:07", "350000", "001147" ], + "001088" : [ "18:08", "350000", "001148" ], + "001089" : [ "18:09", "350000", "001149" ], + "001090" : [ "18:10", "350000", "001150" ], + "001091" : [ "18:11", "350000", "001151" ], + "001092" : [ "18:12", "350000", "001152" ], + "001093" : [ "18:13", "350000", "001153" ], + "001094" : [ "18:14", "350000", "001154" ], + "001095" : [ "18:15", "350000", "001155" ], + "001096" : [ "18:16", "350000", "001156" ], + "001097" : [ "18:17", "350000", "001157" ], + "001098" : [ "18:18", "350000", "001158" ], + "001099" : [ "18:19", "350000", "001159" ], + "001100" : [ "18:20", "350000", "001160" ], + "001101" : [ "18:21", "350000", "001161" ], + "001102" : [ "18:22", "350000", "001162" ], + "001103" : [ "18:23", "350000", "001163" ], + "001104" : [ "18:24", "350000", "001164" ], + "001105" : [ "18:25", "350000", "001165" ], + "001106" : [ "18:26", "350000", "001166" ], + "001107" : [ "18:27", "350000", "001167" ], + "001108" : [ "18:28", "350000", "001168" ], + "001109" : [ "18:29", "350000", "001169" ], + "001110" : [ "18:30", "350000", "001170" ], + "001111" : [ "18:31", "350000", "001171" ], + "001112" : [ "18:32", "350000", "001172" ], + "001113" : [ "18:33", "350000", "001173" ], + "001114" : [ "18:34", "350000", "001174" ], + "001115" : [ "18:35", "350000", "001175" ], + "001116" : [ "18:36", "350000", "001176" ], + "001117" : [ "18:37", "350000", "001177" ], + "001118" : [ "18:38", "350000", "001178" ], + "001119" : [ "18:39", "350000", "001179" ], + "001120" : [ "18:40", "350000", "001180" ], + "001121" : [ "18:41", "350000", "001181" ], + "001122" : [ "18:42", "350000", "001182" ], + "001123" : [ "18:43", "350000", "001183" ], + "001124" : [ "18:44", "350000", "001184" ], + "001125" : [ "18:45", "350000", "001185" ], + "001126" : [ "18:46", "350000", "001186" ], + "001127" : [ "18:47", "350000", "001187" ], + "001128" : [ "18:48", "350000", "001188" ], + "001129" : [ "18:49", "350000", "001189" ], + "001130" : [ "18:50", "350000", "001190" ], + "001131" : [ "18:51", "350000", "001191" ], + "001132" : [ "18:52", "350000", "001192" ], + "001133" : [ "18:53", "350000", "001193" ], + "001134" : [ "18:54", "350000", "001194" ], + "001135" : [ "18:55", "350000", "001195" ], + "001136" : [ "18:56", "350000", "001196" ], + "001137" : [ "18:57", "350000", "001197" ], + "001138" : [ "18:58", "350000", "001198" ], + "001139" : [ "18:59", "350000", "001199" ], + "001140" : [ "19:00", "350000", "001200" ], + "001141" : [ "19:01", "350000", "001200" ], + "001142" : [ "19:02", "350000", "001200" ], + "001143" : [ "19:03", "350000", "001200" ], + "001144" : [ "19:04", "350000", "001200" ], + "001145" : [ "19:05", "350000", "001200" ], + "001146" : [ "19:06", "350000", "001200" ], + "001147" : [ "19:07", "350000", "001200" ], + "001148" : [ "19:08", "350000", "001200" ], + "001149" : [ "19:09", "350000", "001200" ], + "001150" : [ "19:10", "350000", "001200" ], + "001151" : [ "19:11", "350000", "001200" ], + "001152" : [ "19:12", "350000", "001200" ], + "001153" : [ "19:13", "350000", "001200" ], + "001154" : [ "19:14", "350000", "001200" ], + "001155" : [ "19:15", "350000", "001200" ], + "001156" : [ "19:16", "350000", "001200" ], + "001157" : [ "19:17", "350000", "001200" ], + "001158" : [ "19:18", "350000", "001200" ], + "001159" : [ "19:19", "350000", "001200" ], + "001160" : [ "19:20", "350000", "001200" ], + "001161" : [ "19:21", "350000", "001200" ], + "001162" : [ "19:22", "350000", "001200" ], + "001163" : [ "19:23", "350000", "001200" ], + "001164" : [ "19:24", "350000", "001200" ], + "001165" : [ "19:25", "350000", "001200" ], + "001166" : [ "19:26", "350000", "001200" ], + "001167" : [ "19:27", "350000", "001200" ], + "001168" : [ "19:28", "350000", "001200" ], + "001169" : [ "19:29", "350000", "001200" ], + "001170" : [ "19:30", "350000", "001200" ], + "001171" : [ "19:31", "350000", "001200" ], + "001172" : [ "19:32", "350000", "001200" ], + "001173" : [ "19:33", "350000", "001200" ], + "001174" : [ "19:34", "350000", "001200" ], + "001175" : [ "19:35", "350000", "001200" ], + "001176" : [ "19:36", "350000", "001200" ], + "001177" : [ "19:37", "350000", "001200" ], + "001178" : [ "19:38", "350000", "001200" ], + "001179" : [ "19:39", "350000", "001200" ], + "001180" : [ "19:40", "350000", "001200" ], + "001181" : [ "19:41", "350000", "001200" ], + "001182" : [ "19:42", "350000", "001200" ], + "001183" : [ "19:43", "350000", "001200" ], + "001184" : [ "19:44", "350000", "001200" ], + "001185" : [ "19:45", "350000", "001200" ], + "001186" : [ "19:46", "350000", "001200" ], + "001187" : [ "19:47", "350000", "001200" ], + "001188" : [ "19:48", "350000", "001200" ], + "001189" : [ "19:49", "350000", "001200" ], + "001190" : [ "19:50", "350000", "001200" ], + "001191" : [ "19:51", "350000", "001200" ], + "001192" : [ "19:52", "350000", "001200" ], + "001193" : [ "19:53", "350000", "001200" ], + "001194" : [ "19:54", "350000", "001200" ], + "001195" : [ "19:55", "350000", "001200" ], + "001196" : [ "19:56", "350000", "001200" ], + "001197" : [ "19:57", "350000", "001200" ], + "001198" : [ "19:58", "350000", "001200" ], + "001199" : [ "19:59", "350000", "001200" ], + "001200" : [ "20:00", "800000", "010420" ], + "001201" : [ "20:01", "800000", "010420" ], + "001202" : [ "20:02", "800000", "010420" ], + "001203" : [ "20:03", "800000", "010420" ], + "001204" : [ "20:04", "800000", "010420" ], + "001205" : [ "20:05", "800000", "010420" ], + "001206" : [ "20:06", "800000", "010420" ], + "001207" : [ "20:07", "800000", "010420" ], + "001208" : [ "20:08", "800000", "010420" ], + "001209" : [ "20:09", "800000", "010420" ], + "001210" : [ "20:10", "800000", "010420" ], + "001211" : [ "20:11", "800000", "010420" ], + "001212" : [ "20:12", "800000", "010420" ], + "001213" : [ "20:13", "800000", "010420" ], + "001214" : [ "20:14", "800000", "010420" ], + "001215" : [ "20:15", "800000", "010420" ], + "001216" : [ "20:16", "800000", "010420" ], + "001217" : [ "20:17", "800000", "010420" ], + "001218" : [ "20:18", "800000", "010420" ], + "001219" : [ "20:19", "800000", "010420" ], + "001220" : [ "20:20", "800000", "010420" ], + "001221" : [ "20:21", "800000", "010420" ], + "001222" : [ "20:22", "800000", "010420" ], + "001223" : [ "20:23", "800000", "010420" ], + "001224" : [ "20:24", "800000", "010420" ], + "001225" : [ "20:25", "800000", "010420" ], + "001226" : [ "20:26", "800000", "010420" ], + "001227" : [ "20:27", "800000", "010420" ], + "001228" : [ "20:28", "800000", "010420" ], + "001229" : [ "20:29", "800000", "010420" ], + "001230" : [ "20:30", "800000", "010420" ], + "001231" : [ "20:31", "800000", "010420" ], + "001232" : [ "20:32", "800000", "010420" ], + "001233" : [ "20:33", "800000", "010420" ], + "001234" : [ "20:34", "800000", "010420" ], + "001235" : [ "20:35", "800000", "010420" ], + "001236" : [ "20:36", "800000", "010420" ], + "001237" : [ "20:37", "800000", "010420" ], + "001238" : [ "20:38", "800000", "010420" ], + "001239" : [ "20:39", "800000", "010420" ], + "001240" : [ "20:40", "800000", "010420" ], + "001241" : [ "20:41", "800000", "010420" ], + "001242" : [ "20:42", "800000", "010420" ], + "001243" : [ "20:43", "800000", "010420" ], + "001244" : [ "20:44", "800000", "010420" ], + "001245" : [ "20:45", "800000", "010420" ], + "001246" : [ "20:46", "800000", "010420" ], + "001247" : [ "20:47", "800000", "010420" ], + "001248" : [ "20:48", "800000", "010420" ], + "001249" : [ "20:49", "800000", "010420" ], + "001250" : [ "20:50", "800000", "010420" ], + "001251" : [ "20:51", "800000", "010420" ], + "001252" : [ "20:52", "800000", "010420" ], + "001253" : [ "20:53", "800000", "010420" ], + "001254" : [ "20:54", "800000", "010420" ], + "001255" : [ "20:55", "800000", "010420" ], + "001256" : [ "20:56", "800000", "010420" ], + "001257" : [ "20:57", "800000", "010420" ], + "001258" : [ "20:58", "800000", "010420" ], + "001259" : [ "20:59", "800000", "010420" ], + "001260" : [ "21:00", "800000", "010420" ], + "001261" : [ "21:01", "800000", "010420" ], + "001262" : [ "21:02", "800000", "010420" ], + "001263" : [ "21:03", "800000", "010420" ], + "001264" : [ "21:04", "800000", "010420" ], + "001265" : [ "21:05", "800000", "010420" ], + "001266" : [ "21:06", "800000", "010420" ], + "001267" : [ "21:07", "800000", "010420" ], + "001268" : [ "21:08", "800000", "010420" ], + "001269" : [ "21:09", "800000", "010420" ], + "001270" : [ "21:10", "800000", "010420" ], + "001271" : [ "21:11", "800000", "010420" ], + "001272" : [ "21:12", "800000", "010420" ], + "001273" : [ "21:13", "800000", "010420" ], + "001274" : [ "21:14", "800000", "010420" ], + "001275" : [ "21:15", "800000", "010420" ], + "001276" : [ "21:16", "800000", "010420" ], + "001277" : [ "21:17", "800000", "010420" ], + "001278" : [ "21:18", "800000", "010420" ], + "001279" : [ "21:19", "800000", "010420" ], + "001280" : [ "21:20", "800000", "010420" ], + "001281" : [ "21:21", "800000", "010420" ], + "001282" : [ "21:22", "800000", "010420" ], + "001283" : [ "21:23", "800000", "010420" ], + "001284" : [ "21:24", "800000", "010420" ], + "001285" : [ "21:25", "800000", "010420" ], + "001286" : [ "21:26", "800000", "010420" ], + "001287" : [ "21:27", "800000", "010420" ], + "001288" : [ "21:28", "800000", "010420" ], + "001289" : [ "21:29", "800000", "010420" ], + "001290" : [ "21:30", "800000", "010420" ], + "001291" : [ "21:31", "800000", "010420" ], + "001292" : [ "21:32", "800000", "010420" ], + "001293" : [ "21:33", "800000", "010420" ], + "001294" : [ "21:34", "800000", "010420" ], + "001295" : [ "21:35", "800000", "010420" ], + "001296" : [ "21:36", "800000", "010420" ], + "001297" : [ "21:37", "800000", "010420" ], + "001298" : [ "21:38", "800000", "010420" ], + "001299" : [ "21:39", "800000", "010420" ], + "001300" : [ "21:40", "800000", "010420" ], + "001301" : [ "21:41", "800000", "010420" ], + "001302" : [ "21:42", "800000", "010420" ], + "001303" : [ "21:43", "800000", "010420" ], + "001304" : [ "21:44", "800000", "010420" ], + "001305" : [ "21:45", "800000", "010420" ], + "001306" : [ "21:46", "800000", "010420" ], + "001307" : [ "21:47", "800000", "010420" ], + "001308" : [ "21:48", "800000", "010420" ], + "001309" : [ "21:49", "800000", "010420" ], + "001310" : [ "21:50", "800000", "010420" ], + "001311" : [ "21:51", "800000", "010420" ], + "001312" : [ "21:52", "800000", "010420" ], + "001313" : [ "21:53", "800000", "010420" ], + "001314" : [ "21:54", "800000", "010420" ], + "001315" : [ "21:55", "800000", "010420" ], + "001316" : [ "21:56", "800000", "010420" ], + "001317" : [ "21:57", "800000", "010420" ], + "001318" : [ "21:58", "800000", "010420" ], + "001319" : [ "21:59", "800000", "010420" ], + "001320" : [ "22:00", "800000", "010420" ], + "001321" : [ "22:01", "800000", "010420" ], + "001322" : [ "22:02", "800000", "010420" ], + "001323" : [ "22:03", "800000", "010420" ], + "001324" : [ "22:04", "800000", "010420" ], + "001325" : [ "22:05", "800000", "010420" ], + "001326" : [ "22:06", "800000", "010420" ], + "001327" : [ "22:07", "800000", "010420" ], + "001328" : [ "22:08", "800000", "010420" ], + "001329" : [ "22:09", "800000", "010420" ], + "001330" : [ "22:10", "800000", "010420" ], + "001331" : [ "22:11", "800000", "010420" ], + "001332" : [ "22:12", "800000", "010420" ], + "001333" : [ "22:13", "800000", "010420" ], + "001334" : [ "22:14", "800000", "010420" ], + "001335" : [ "22:15", "800000", "010420" ], + "001336" : [ "22:16", "800000", "010420" ], + "001337" : [ "22:17", "800000", "010420" ], + "001338" : [ "22:18", "800000", "010420" ], + "001339" : [ "22:19", "800000", "010420" ], + "001340" : [ "22:20", "800000", "010420" ], + "001341" : [ "22:21", "800000", "010420" ], + "001342" : [ "22:22", "800000", "010420" ], + "001343" : [ "22:23", "800000", "010420" ], + "001344" : [ "22:24", "800000", "010420" ], + "001345" : [ "22:25", "800000", "010420" ], + "001346" : [ "22:26", "800000", "010420" ], + "001347" : [ "22:27", "800000", "010420" ], + "001348" : [ "22:28", "800000", "010420" ], + "001349" : [ "22:29", "800000", "010420" ], + "001350" : [ "22:30", "800000", "010420" ], + "001351" : [ "22:31", "800000", "010420" ], + "001352" : [ "22:32", "800000", "010420" ], + "001353" : [ "22:33", "800000", "010420" ], + "001354" : [ "22:34", "800000", "010420" ], + "001355" : [ "22:35", "800000", "010420" ], + "001356" : [ "22:36", "800000", "010420" ], + "001357" : [ "22:37", "800000", "010420" ], + "001358" : [ "22:38", "800000", "010420" ], + "001359" : [ "22:39", "800000", "010420" ], + "001360" : [ "22:40", "800000", "010420" ], + "001361" : [ "22:41", "800000", "010420" ], + "001362" : [ "22:42", "800000", "010420" ], + "001363" : [ "22:43", "800000", "010420" ], + "001364" : [ "22:44", "800000", "010420" ], + "001365" : [ "22:45", "800000", "010420" ], + "001366" : [ "22:46", "800000", "010420" ], + "001367" : [ "22:47", "800000", "010420" ], + "001368" : [ "22:48", "800000", "010420" ], + "001369" : [ "22:49", "800000", "010420" ], + "001370" : [ "22:50", "800000", "010420" ], + "001371" : [ "22:51", "800000", "010420" ], + "001372" : [ "22:52", "800000", "010420" ], + "001373" : [ "22:53", "800000", "010420" ], + "001374" : [ "22:54", "800000", "010420" ], + "001375" : [ "22:55", "800000", "010420" ], + "001376" : [ "22:56", "800000", "010420" ], + "001377" : [ "22:57", "800000", "010420" ], + "001378" : [ "22:58", "800000", "010420" ], + "001379" : [ "22:59", "800000", "010420" ], + "001380" : [ "23:00", "800000", "010420" ], + "001381" : [ "23:01", "800000", "010420" ], + "001382" : [ "23:02", "800000", "010420" ], + "001383" : [ "23:03", "800000", "010420" ], + "001384" : [ "23:04", "800000", "010420" ], + "001385" : [ "23:05", "800000", "010420" ], + "001386" : [ "23:06", "800000", "010420" ], + "001387" : [ "23:07", "800000", "010420" ], + "001388" : [ "23:08", "800000", "010420" ], + "001389" : [ "23:09", "800000", "010420" ], + "001390" : [ "23:10", "800000", "010420" ], + "001391" : [ "23:11", "800000", "010420" ], + "001392" : [ "23:12", "800000", "010420" ], + "001393" : [ "23:13", "800000", "010420" ], + "001394" : [ "23:14", "800000", "010420" ], + "001395" : [ "23:15", "800000", "010420" ], + "001396" : [ "23:16", "800000", "010420" ], + "001397" : [ "23:17", "800000", "010420" ], + "001398" : [ "23:18", "800000", "010420" ], + "001399" : [ "23:19", "800000", "010420" ], + "001400" : [ "23:20", "800000", "010420" ], + "001401" : [ "23:21", "800000", "010420" ], + "001402" : [ "23:22", "800000", "010420" ], + "001403" : [ "23:23", "800000", "010420" ], + "001404" : [ "23:24", "800000", "010420" ], + "001405" : [ "23:25", "800000", "010420" ], + "001406" : [ "23:26", "800000", "010420" ], + "001407" : [ "23:27", "800000", "010420" ], + "001408" : [ "23:28", "800000", "010420" ], + "001409" : [ "23:29", "800000", "010420" ], + "001410" : [ "23:30", "800000", "010420" ], + "001411" : [ "23:31", "800000", "010420" ], + "001412" : [ "23:32", "800000", "010420" ], + "001413" : [ "23:33", "800000", "010420" ], + "001414" : [ "23:34", "800000", "010420" ], + "001415" : [ "23:35", "800000", "010420" ], + "001416" : [ "23:36", "800000", "010420" ], + "001417" : [ "23:37", "800000", "010420" ], + "001418" : [ "23:38", "800000", "010420" ], + "001419" : [ "23:39", "800000", "010420" ], + "001420" : [ "23:40", "800000", "010420" ], + "001421" : [ "23:41", "800000", "010420" ], + "001422" : [ "23:42", "800000", "010420" ], + "001423" : [ "23:43", "800000", "010420" ], + "001424" : [ "23:44", "800000", "010420" ], + "001425" : [ "23:45", "800000", "010420" ], + "001426" : [ "23:46", "800000", "010420" ], + "001427" : [ "23:47", "800000", "010420" ], + "001428" : [ "23:48", "800000", "010420" ], + "001429" : [ "23:49", "800000", "010420" ], + "001430" : [ "23:50", "800000", "010420" ], + "001431" : [ "23:51", "800000", "010420" ], + "001432" : [ "23:52", "800000", "010420" ], + "001433" : [ "23:53", "800000", "010420" ], + "001434" : [ "23:54", "800000", "010420" ], + "001435" : [ "23:55", "800000", "010420" ], + "001436" : [ "23:56", "800000", "010420" ], + "001437" : [ "23:57", "800000", "010420" ], + "001438" : [ "23:58", "800000", "010420" ], + "001439" : [ "23:59", "800000", "010420" ] + }, + "Tuesday": { + "010000" : [ "00:00", "800000", "010420" ], + "010001" : [ "00:01", "800000", "010420" ], + "010002" : [ "00:02", "800000", "010420" ], + "010003" : [ "00:03", "800000", "010420" ], + "010004" : [ "00:04", "800000", "010420" ], + "010005" : [ "00:05", "800000", "010420" ], + "010006" : [ "00:06", "800000", "010420" ], + "010007" : [ "00:07", "800000", "010420" ], + "010008" : [ "00:08", "800000", "010420" ], + "010009" : [ "00:09", "800000", "010420" ], + "010010" : [ "00:10", "800000", "010420" ], + "010011" : [ "00:11", "800000", "010420" ], + "010012" : [ "00:12", "800000", "010420" ], + "010013" : [ "00:13", "800000", "010420" ], + "010014" : [ "00:14", "800000", "010420" ], + "010015" : [ "00:15", "800000", "010420" ], + "010016" : [ "00:16", "800000", "010420" ], + "010017" : [ "00:17", "800000", "010420" ], + "010018" : [ "00:18", "800000", "010420" ], + "010019" : [ "00:19", "800000", "010420" ], + "010020" : [ "00:20", "800000", "010420" ], + "010021" : [ "00:21", "800000", "010420" ], + "010022" : [ "00:22", "800000", "010420" ], + "010023" : [ "00:23", "800000", "010420" ], + "010024" : [ "00:24", "800000", "010420" ], + "010025" : [ "00:25", "800000", "010420" ], + "010026" : [ "00:26", "800000", "010420" ], + "010027" : [ "00:27", "800000", "010420" ], + "010028" : [ "00:28", "800000", "010420" ], + "010029" : [ "00:29", "800000", "010420" ], + "010030" : [ "00:30", "800000", "010420" ], + "010031" : [ "00:31", "800000", "010420" ], + "010032" : [ "00:32", "800000", "010420" ], + "010033" : [ "00:33", "800000", "010420" ], + "010034" : [ "00:34", "800000", "010420" ], + "010035" : [ "00:35", "800000", "010420" ], + "010036" : [ "00:36", "800000", "010420" ], + "010037" : [ "00:37", "800000", "010420" ], + "010038" : [ "00:38", "800000", "010420" ], + "010039" : [ "00:39", "800000", "010420" ], + "010040" : [ "00:40", "800000", "010420" ], + "010041" : [ "00:41", "800000", "010420" ], + "010042" : [ "00:42", "800000", "010420" ], + "010043" : [ "00:43", "800000", "010420" ], + "010044" : [ "00:44", "800000", "010420" ], + "010045" : [ "00:45", "800000", "010420" ], + "010046" : [ "00:46", "800000", "010420" ], + "010047" : [ "00:47", "800000", "010420" ], + "010048" : [ "00:48", "800000", "010420" ], + "010049" : [ "00:49", "800000", "010420" ], + "010050" : [ "00:50", "800000", "010420" ], + "010051" : [ "00:51", "800000", "010420" ], + "010052" : [ "00:52", "800000", "010420" ], + "010053" : [ "00:53", "800000", "010420" ], + "010054" : [ "00:54", "800000", "010420" ], + "010055" : [ "00:55", "800000", "010420" ], + "010056" : [ "00:56", "800000", "010420" ], + "010057" : [ "00:57", "800000", "010420" ], + "010058" : [ "00:58", "800000", "010420" ], + "010059" : [ "00:59", "800000", "010420" ], + "010060" : [ "01:00", "800000", "010420" ], + "010061" : [ "01:01", "800000", "010420" ], + "010062" : [ "01:02", "800000", "010420" ], + "010063" : [ "01:03", "800000", "010420" ], + "010064" : [ "01:04", "800000", "010420" ], + "010065" : [ "01:05", "800000", "010420" ], + "010066" : [ "01:06", "800000", "010420" ], + "010067" : [ "01:07", "800000", "010420" ], + "010068" : [ "01:08", "800000", "010420" ], + "010069" : [ "01:09", "800000", "010420" ], + "010070" : [ "01:10", "800000", "010420" ], + "010071" : [ "01:11", "800000", "010420" ], + "010072" : [ "01:12", "800000", "010420" ], + "010073" : [ "01:13", "800000", "010420" ], + "010074" : [ "01:14", "800000", "010420" ], + "010075" : [ "01:15", "800000", "010420" ], + "010076" : [ "01:16", "800000", "010420" ], + "010077" : [ "01:17", "800000", "010420" ], + "010078" : [ "01:18", "800000", "010420" ], + "010079" : [ "01:19", "800000", "010420" ], + "010080" : [ "01:20", "800000", "010420" ], + "010081" : [ "01:21", "800000", "010420" ], + "010082" : [ "01:22", "800000", "010420" ], + "010083" : [ "01:23", "800000", "010420" ], + "010084" : [ "01:24", "800000", "010420" ], + "010085" : [ "01:25", "800000", "010420" ], + "010086" : [ "01:26", "800000", "010420" ], + "010087" : [ "01:27", "800000", "010420" ], + "010088" : [ "01:28", "800000", "010420" ], + "010089" : [ "01:29", "800000", "010420" ], + "010090" : [ "01:30", "800000", "010420" ], + "010091" : [ "01:31", "800000", "010420" ], + "010092" : [ "01:32", "800000", "010420" ], + "010093" : [ "01:33", "800000", "010420" ], + "010094" : [ "01:34", "800000", "010420" ], + "010095" : [ "01:35", "800000", "010420" ], + "010096" : [ "01:36", "800000", "010420" ], + "010097" : [ "01:37", "800000", "010420" ], + "010098" : [ "01:38", "800000", "010420" ], + "010099" : [ "01:39", "800000", "010420" ], + "010100" : [ "01:40", "800000", "010420" ], + "010101" : [ "01:41", "800000", "010420" ], + "010102" : [ "01:42", "800000", "010420" ], + "010103" : [ "01:43", "800000", "010420" ], + "010104" : [ "01:44", "800000", "010420" ], + "010105" : [ "01:45", "800000", "010420" ], + "010106" : [ "01:46", "800000", "010420" ], + "010107" : [ "01:47", "800000", "010420" ], + "010108" : [ "01:48", "800000", "010420" ], + "010109" : [ "01:49", "800000", "010420" ], + "010110" : [ "01:50", "800000", "010420" ], + "010111" : [ "01:51", "800000", "010420" ], + "010112" : [ "01:52", "800000", "010420" ], + "010113" : [ "01:53", "800000", "010420" ], + "010114" : [ "01:54", "800000", "010420" ], + "010115" : [ "01:55", "800000", "010420" ], + "010116" : [ "01:56", "800000", "010420" ], + "010117" : [ "01:57", "800000", "010420" ], + "010118" : [ "01:58", "800000", "010420" ], + "010119" : [ "01:59", "800000", "010420" ], + "010120" : [ "02:00", "800000", "010420" ], + "010121" : [ "02:01", "800000", "010420" ], + "010122" : [ "02:02", "800000", "010420" ], + "010123" : [ "02:03", "800000", "010420" ], + "010124" : [ "02:04", "800000", "010420" ], + "010125" : [ "02:05", "800000", "010420" ], + "010126" : [ "02:06", "800000", "010420" ], + "010127" : [ "02:07", "800000", "010420" ], + "010128" : [ "02:08", "800000", "010420" ], + "010129" : [ "02:09", "800000", "010420" ], + "010130" : [ "02:10", "800000", "010420" ], + "010131" : [ "02:11", "800000", "010420" ], + "010132" : [ "02:12", "800000", "010420" ], + "010133" : [ "02:13", "800000", "010420" ], + "010134" : [ "02:14", "800000", "010420" ], + "010135" : [ "02:15", "800000", "010420" ], + "010136" : [ "02:16", "800000", "010420" ], + "010137" : [ "02:17", "800000", "010420" ], + "010138" : [ "02:18", "800000", "010420" ], + "010139" : [ "02:19", "800000", "010420" ], + "010140" : [ "02:20", "800000", "010420" ], + "010141" : [ "02:21", "800000", "010420" ], + "010142" : [ "02:22", "800000", "010420" ], + "010143" : [ "02:23", "800000", "010420" ], + "010144" : [ "02:24", "800000", "010420" ], + "010145" : [ "02:25", "800000", "010420" ], + "010146" : [ "02:26", "800000", "010420" ], + "010147" : [ "02:27", "800000", "010420" ], + "010148" : [ "02:28", "800000", "010420" ], + "010149" : [ "02:29", "800000", "010420" ], + "010150" : [ "02:30", "800000", "010420" ], + "010151" : [ "02:31", "800000", "010420" ], + "010152" : [ "02:32", "800000", "010420" ], + "010153" : [ "02:33", "800000", "010420" ], + "010154" : [ "02:34", "800000", "010420" ], + "010155" : [ "02:35", "800000", "010420" ], + "010156" : [ "02:36", "800000", "010420" ], + "010157" : [ "02:37", "800000", "010420" ], + "010158" : [ "02:38", "800000", "010420" ], + "010159" : [ "02:39", "800000", "010420" ], + "010160" : [ "02:40", "800000", "010420" ], + "010161" : [ "02:41", "800000", "010420" ], + "010162" : [ "02:42", "800000", "010420" ], + "010163" : [ "02:43", "800000", "010420" ], + "010164" : [ "02:44", "800000", "010420" ], + "010165" : [ "02:45", "800000", "010420" ], + "010166" : [ "02:46", "800000", "010420" ], + "010167" : [ "02:47", "800000", "010420" ], + "010168" : [ "02:48", "800000", "010420" ], + "010169" : [ "02:49", "800000", "010420" ], + "010170" : [ "02:50", "800000", "010420" ], + "010171" : [ "02:51", "800000", "010420" ], + "010172" : [ "02:52", "800000", "010420" ], + "010173" : [ "02:53", "800000", "010420" ], + "010174" : [ "02:54", "800000", "010420" ], + "010175" : [ "02:55", "800000", "010420" ], + "010176" : [ "02:56", "800000", "010420" ], + "010177" : [ "02:57", "800000", "010420" ], + "010178" : [ "02:58", "800000", "010420" ], + "010179" : [ "02:59", "800000", "010420" ], + "010180" : [ "03:00", "800000", "010420" ], + "010181" : [ "03:01", "800000", "010420" ], + "010182" : [ "03:02", "800000", "010420" ], + "010183" : [ "03:03", "800000", "010420" ], + "010184" : [ "03:04", "800000", "010420" ], + "010185" : [ "03:05", "800000", "010420" ], + "010186" : [ "03:06", "800000", "010420" ], + "010187" : [ "03:07", "800000", "010420" ], + "010188" : [ "03:08", "800000", "010420" ], + "010189" : [ "03:09", "800000", "010420" ], + "010190" : [ "03:10", "800000", "010420" ], + "010191" : [ "03:11", "800000", "010420" ], + "010192" : [ "03:12", "800000", "010420" ], + "010193" : [ "03:13", "800000", "010420" ], + "010194" : [ "03:14", "800000", "010420" ], + "010195" : [ "03:15", "800000", "010420" ], + "010196" : [ "03:16", "800000", "010420" ], + "010197" : [ "03:17", "800000", "010420" ], + "010198" : [ "03:18", "800000", "010420" ], + "010199" : [ "03:19", "800000", "010420" ], + "010200" : [ "03:20", "800000", "010420" ], + "010201" : [ "03:21", "800000", "010420" ], + "010202" : [ "03:22", "800000", "010420" ], + "010203" : [ "03:23", "800000", "010420" ], + "010204" : [ "03:24", "800000", "010420" ], + "010205" : [ "03:25", "800000", "010420" ], + "010206" : [ "03:26", "800000", "010420" ], + "010207" : [ "03:27", "800000", "010420" ], + "010208" : [ "03:28", "800000", "010420" ], + "010209" : [ "03:29", "800000", "010420" ], + "010210" : [ "03:30", "800000", "010420" ], + "010211" : [ "03:31", "800000", "010420" ], + "010212" : [ "03:32", "800000", "010420" ], + "010213" : [ "03:33", "800000", "010420" ], + "010214" : [ "03:34", "800000", "010420" ], + "010215" : [ "03:35", "800000", "010420" ], + "010216" : [ "03:36", "800000", "010420" ], + "010217" : [ "03:37", "800000", "010420" ], + "010218" : [ "03:38", "800000", "010420" ], + "010219" : [ "03:39", "800000", "010420" ], + "010220" : [ "03:40", "800000", "010420" ], + "010221" : [ "03:41", "800000", "010420" ], + "010222" : [ "03:42", "800000", "010420" ], + "010223" : [ "03:43", "800000", "010420" ], + "010224" : [ "03:44", "800000", "010420" ], + "010225" : [ "03:45", "800000", "010420" ], + "010226" : [ "03:46", "800000", "010420" ], + "010227" : [ "03:47", "800000", "010420" ], + "010228" : [ "03:48", "800000", "010420" ], + "010229" : [ "03:49", "800000", "010420" ], + "010230" : [ "03:50", "800000", "010420" ], + "010231" : [ "03:51", "800000", "010420" ], + "010232" : [ "03:52", "800000", "010420" ], + "010233" : [ "03:53", "800000", "010420" ], + "010234" : [ "03:54", "800000", "010420" ], + "010235" : [ "03:55", "800000", "010420" ], + "010236" : [ "03:56", "800000", "010420" ], + "010237" : [ "03:57", "800000", "010420" ], + "010238" : [ "03:58", "800000", "010420" ], + "010239" : [ "03:59", "800000", "010420" ], + "010240" : [ "04:00", "800000", "010420" ], + "010241" : [ "04:01", "800000", "010420" ], + "010242" : [ "04:02", "800000", "010420" ], + "010243" : [ "04:03", "800000", "010420" ], + "010244" : [ "04:04", "800000", "010420" ], + "010245" : [ "04:05", "800000", "010420" ], + "010246" : [ "04:06", "800000", "010420" ], + "010247" : [ "04:07", "800000", "010420" ], + "010248" : [ "04:08", "800000", "010420" ], + "010249" : [ "04:09", "800000", "010420" ], + "010250" : [ "04:10", "800000", "010420" ], + "010251" : [ "04:11", "800000", "010420" ], + "010252" : [ "04:12", "800000", "010420" ], + "010253" : [ "04:13", "800000", "010420" ], + "010254" : [ "04:14", "800000", "010420" ], + "010255" : [ "04:15", "800000", "010420" ], + "010256" : [ "04:16", "800000", "010420" ], + "010257" : [ "04:17", "800000", "010420" ], + "010258" : [ "04:18", "800000", "010420" ], + "010259" : [ "04:19", "800000", "010420" ], + "010260" : [ "04:20", "800000", "010420" ], + "010261" : [ "04:21", "800000", "010420" ], + "010262" : [ "04:22", "800000", "010420" ], + "010263" : [ "04:23", "800000", "010420" ], + "010264" : [ "04:24", "800000", "010420" ], + "010265" : [ "04:25", "800000", "010420" ], + "010266" : [ "04:26", "800000", "010420" ], + "010267" : [ "04:27", "800000", "010420" ], + "010268" : [ "04:28", "800000", "010420" ], + "010269" : [ "04:29", "800000", "010420" ], + "010270" : [ "04:30", "800000", "010420" ], + "010271" : [ "04:31", "800000", "010420" ], + "010272" : [ "04:32", "800000", "010420" ], + "010273" : [ "04:33", "800000", "010420" ], + "010274" : [ "04:34", "800000", "010420" ], + "010275" : [ "04:35", "800000", "010420" ], + "010276" : [ "04:36", "800000", "010420" ], + "010277" : [ "04:37", "800000", "010420" ], + "010278" : [ "04:38", "800000", "010420" ], + "010279" : [ "04:39", "800000", "010420" ], + "010280" : [ "04:40", "800000", "010420" ], + "010281" : [ "04:41", "800000", "010420" ], + "010282" : [ "04:42", "800000", "010420" ], + "010283" : [ "04:43", "800000", "010420" ], + "010284" : [ "04:44", "800000", "010420" ], + "010285" : [ "04:45", "800000", "010420" ], + "010286" : [ "04:46", "800000", "010420" ], + "010287" : [ "04:47", "800000", "010420" ], + "010288" : [ "04:48", "800000", "010420" ], + "010289" : [ "04:49", "800000", "010420" ], + "010290" : [ "04:50", "800000", "010420" ], + "010291" : [ "04:51", "800000", "010420" ], + "010292" : [ "04:52", "800000", "010420" ], + "010293" : [ "04:53", "800000", "010420" ], + "010294" : [ "04:54", "800000", "010420" ], + "010295" : [ "04:55", "800000", "010420" ], + "010296" : [ "04:56", "800000", "010420" ], + "010297" : [ "04:57", "800000", "010420" ], + "010298" : [ "04:58", "800000", "010420" ], + "010299" : [ "04:59", "800000", "010420" ], + "010300" : [ "05:00", "800000", "010420" ], + "010301" : [ "05:01", "800000", "010420" ], + "010302" : [ "05:02", "800000", "010420" ], + "010303" : [ "05:03", "800000", "010420" ], + "010304" : [ "05:04", "800000", "010420" ], + "010305" : [ "05:05", "800000", "010420" ], + "010306" : [ "05:06", "800000", "010420" ], + "010307" : [ "05:07", "800000", "010420" ], + "010308" : [ "05:08", "800000", "010420" ], + "010309" : [ "05:09", "800000", "010420" ], + "010310" : [ "05:10", "800000", "010420" ], + "010311" : [ "05:11", "800000", "010420" ], + "010312" : [ "05:12", "800000", "010420" ], + "010313" : [ "05:13", "800000", "010420" ], + "010314" : [ "05:14", "800000", "010420" ], + "010315" : [ "05:15", "800000", "010420" ], + "010316" : [ "05:16", "800000", "010420" ], + "010317" : [ "05:17", "800000", "010420" ], + "010318" : [ "05:18", "800000", "010420" ], + "010319" : [ "05:19", "800000", "010420" ], + "010320" : [ "05:20", "800000", "010420" ], + "010321" : [ "05:21", "800000", "010420" ], + "010322" : [ "05:22", "800000", "010420" ], + "010323" : [ "05:23", "800000", "010420" ], + "010324" : [ "05:24", "800000", "010420" ], + "010325" : [ "05:25", "800000", "010420" ], + "010326" : [ "05:26", "800000", "010420" ], + "010327" : [ "05:27", "800000", "010420" ], + "010328" : [ "05:28", "800000", "010420" ], + "010329" : [ "05:29", "800000", "010420" ], + "010330" : [ "05:30", "800000", "010420" ], + "010331" : [ "05:31", "800000", "010420" ], + "010332" : [ "05:32", "800000", "010420" ], + "010333" : [ "05:33", "800000", "010420" ], + "010334" : [ "05:34", "800000", "010420" ], + "010335" : [ "05:35", "800000", "010420" ], + "010336" : [ "05:36", "800000", "010420" ], + "010337" : [ "05:37", "800000", "010420" ], + "010338" : [ "05:38", "800000", "010420" ], + "010339" : [ "05:39", "800000", "010420" ], + "010340" : [ "05:40", "800000", "010420" ], + "010341" : [ "05:41", "800000", "010420" ], + "010342" : [ "05:42", "800000", "010420" ], + "010343" : [ "05:43", "800000", "010420" ], + "010344" : [ "05:44", "800000", "010420" ], + "010345" : [ "05:45", "800000", "010420" ], + "010346" : [ "05:46", "800000", "010420" ], + "010347" : [ "05:47", "800000", "010420" ], + "010348" : [ "05:48", "800000", "010420" ], + "010349" : [ "05:49", "800000", "010420" ], + "010350" : [ "05:50", "800000", "010420" ], + "010351" : [ "05:51", "800000", "010420" ], + "010352" : [ "05:52", "800000", "010420" ], + "010353" : [ "05:53", "800000", "010420" ], + "010354" : [ "05:54", "800000", "010420" ], + "010355" : [ "05:55", "800000", "010420" ], + "010356" : [ "05:56", "800000", "010420" ], + "010357" : [ "05:57", "800000", "010420" ], + "010358" : [ "05:58", "800000", "010420" ], + "010359" : [ "05:59", "800000", "010420" ], + "010360" : [ "06:00", "800000", "010420" ], + "010361" : [ "06:01", "800000", "010420" ], + "010362" : [ "06:02", "800000", "010420" ], + "010363" : [ "06:03", "800000", "010420" ], + "010364" : [ "06:04", "800000", "010420" ], + "010365" : [ "06:05", "800000", "010420" ], + "010366" : [ "06:06", "800000", "010420" ], + "010367" : [ "06:07", "800000", "010420" ], + "010368" : [ "06:08", "800000", "010420" ], + "010369" : [ "06:09", "800000", "010420" ], + "010370" : [ "06:10", "800000", "010420" ], + "010371" : [ "06:11", "800000", "010420" ], + "010372" : [ "06:12", "800000", "010420" ], + "010373" : [ "06:13", "800000", "010420" ], + "010374" : [ "06:14", "800000", "010420" ], + "010375" : [ "06:15", "800000", "010420" ], + "010376" : [ "06:16", "800000", "010420" ], + "010377" : [ "06:17", "800000", "010420" ], + "010378" : [ "06:18", "800000", "010420" ], + "010379" : [ "06:19", "800000", "010420" ], + "010380" : [ "06:20", "800000", "010420" ], + "010381" : [ "06:21", "800000", "010420" ], + "010382" : [ "06:22", "800000", "010420" ], + "010383" : [ "06:23", "800000", "010420" ], + "010384" : [ "06:24", "800000", "010420" ], + "010385" : [ "06:25", "800000", "010420" ], + "010386" : [ "06:26", "800000", "010420" ], + "010387" : [ "06:27", "800000", "010420" ], + "010388" : [ "06:28", "800000", "010420" ], + "010389" : [ "06:29", "800000", "010420" ], + "010390" : [ "06:30", "800000", "010420" ], + "010391" : [ "06:31", "800000", "010420" ], + "010392" : [ "06:32", "800000", "010420" ], + "010393" : [ "06:33", "800000", "010420" ], + "010394" : [ "06:34", "800000", "010420" ], + "010395" : [ "06:35", "800000", "010420" ], + "010396" : [ "06:36", "800000", "010420" ], + "010397" : [ "06:37", "800000", "010420" ], + "010398" : [ "06:38", "800000", "010420" ], + "010399" : [ "06:39", "800000", "010420" ], + "010400" : [ "06:40", "800000", "010420" ], + "010401" : [ "06:41", "800000", "010420" ], + "010402" : [ "06:42", "800000", "010420" ], + "010403" : [ "06:43", "800000", "010420" ], + "010404" : [ "06:44", "800000", "010420" ], + "010405" : [ "06:45", "800000", "010420" ], + "010406" : [ "06:46", "800000", "010420" ], + "010407" : [ "06:47", "800000", "010420" ], + "010408" : [ "06:48", "800000", "010420" ], + "010409" : [ "06:49", "800000", "010420" ], + "010410" : [ "06:50", "800000", "010420" ], + "010411" : [ "06:51", "800000", "010420" ], + "010412" : [ "06:52", "800000", "010420" ], + "010413" : [ "06:53", "800000", "010420" ], + "010414" : [ "06:54", "800000", "010420" ], + "010415" : [ "06:55", "800000", "010420" ], + "010416" : [ "06:56", "800000", "010420" ], + "010417" : [ "06:57", "800000", "010420" ], + "010418" : [ "06:58", "800000", "010420" ], + "010419" : [ "06:59", "800000", "010420" ], + "010420" : [ "07:00", "350000", "010480" ], + "010421" : [ "07:01", "350000", "010481" ], + "010422" : [ "07:02", "350000", "010482" ], + "010423" : [ "07:03", "350000", "010483" ], + "010424" : [ "07:04", "350000", "010484" ], + "010425" : [ "07:05", "350000", "010485" ], + "010426" : [ "07:06", "350000", "010486" ], + "010427" : [ "07:07", "350000", "010487" ], + "010428" : [ "07:08", "350000", "010488" ], + "010429" : [ "07:09", "350000", "010489" ], + "010430" : [ "07:10", "350000", "010490" ], + "010431" : [ "07:11", "350000", "010491" ], + "010432" : [ "07:12", "350000", "010492" ], + "010433" : [ "07:13", "350000", "010493" ], + "010434" : [ "07:14", "350000", "010494" ], + "010435" : [ "07:15", "350000", "010495" ], + "010436" : [ "07:16", "350000", "010496" ], + "010437" : [ "07:17", "350000", "010497" ], + "010438" : [ "07:18", "350000", "010498" ], + "010439" : [ "07:19", "350000", "010499" ], + "010440" : [ "07:20", "350000", "010500" ], + "010441" : [ "07:21", "350000", "010501" ], + "010442" : [ "07:22", "350000", "010502" ], + "010443" : [ "07:23", "350000", "010503" ], + "010444" : [ "07:24", "350000", "010504" ], + "010445" : [ "07:25", "350000", "010505" ], + "010446" : [ "07:26", "350000", "010506" ], + "010447" : [ "07:27", "350000", "010507" ], + "010448" : [ "07:28", "350000", "010508" ], + "010449" : [ "07:29", "350000", "010509" ], + "010450" : [ "07:30", "350000", "010510" ], + "010451" : [ "07:31", "350000", "010511" ], + "010452" : [ "07:32", "350000", "010512" ], + "010453" : [ "07:33", "350000", "010513" ], + "010454" : [ "07:34", "350000", "010514" ], + "010455" : [ "07:35", "350000", "010515" ], + "010456" : [ "07:36", "350000", "010516" ], + "010457" : [ "07:37", "350000", "010517" ], + "010458" : [ "07:38", "350000", "010518" ], + "010459" : [ "07:39", "350000", "010519" ], + "010460" : [ "07:40", "350000", "010520" ], + "010461" : [ "07:41", "350000", "010521" ], + "010462" : [ "07:42", "350000", "010522" ], + "010463" : [ "07:43", "350000", "010523" ], + "010464" : [ "07:44", "350000", "010524" ], + "010465" : [ "07:45", "350000", "010525" ], + "010466" : [ "07:46", "350000", "010526" ], + "010467" : [ "07:47", "350000", "010527" ], + "010468" : [ "07:48", "350000", "010528" ], + "010469" : [ "07:49", "350000", "010529" ], + "010470" : [ "07:50", "350000", "010530" ], + "010471" : [ "07:51", "350000", "010531" ], + "010472" : [ "07:52", "350000", "010532" ], + "010473" : [ "07:53", "350000", "010533" ], + "010474" : [ "07:54", "350000", "010534" ], + "010475" : [ "07:55", "350000", "010535" ], + "010476" : [ "07:56", "350000", "010536" ], + "010477" : [ "07:57", "350000", "010537" ], + "010478" : [ "07:58", "350000", "010538" ], + "010479" : [ "07:59", "350000", "010539" ], + "010480" : [ "08:00", "350000", "010540" ], + "010481" : [ "08:01", "350000", "010541" ], + "010482" : [ "08:02", "350000", "010542" ], + "010483" : [ "08:03", "350000", "010543" ], + "010484" : [ "08:04", "350000", "010544" ], + "010485" : [ "08:05", "350000", "010545" ], + "010486" : [ "08:06", "350000", "010546" ], + "010487" : [ "08:07", "350000", "010547" ], + "010488" : [ "08:08", "350000", "010548" ], + "010489" : [ "08:09", "350000", "010549" ], + "010490" : [ "08:10", "350000", "010550" ], + "010491" : [ "08:11", "350000", "010551" ], + "010492" : [ "08:12", "350000", "010552" ], + "010493" : [ "08:13", "350000", "010553" ], + "010494" : [ "08:14", "350000", "010554" ], + "010495" : [ "08:15", "350000", "010555" ], + "010496" : [ "08:16", "350000", "010556" ], + "010497" : [ "08:17", "350000", "010557" ], + "010498" : [ "08:18", "350000", "010558" ], + "010499" : [ "08:19", "350000", "010559" ], + "010500" : [ "08:20", "350000", "010560" ], + "010501" : [ "08:21", "350000", "010561" ], + "010502" : [ "08:22", "350000", "010562" ], + "010503" : [ "08:23", "350000", "010563" ], + "010504" : [ "08:24", "350000", "010564" ], + "010505" : [ "08:25", "350000", "010565" ], + "010506" : [ "08:26", "350000", "010566" ], + "010507" : [ "08:27", "350000", "010567" ], + "010508" : [ "08:28", "350000", "010568" ], + "010509" : [ "08:29", "350000", "010569" ], + "010510" : [ "08:30", "350000", "010570" ], + "010511" : [ "08:31", "350000", "010571" ], + "010512" : [ "08:32", "350000", "010572" ], + "010513" : [ "08:33", "350000", "010573" ], + "010514" : [ "08:34", "350000", "010574" ], + "010515" : [ "08:35", "350000", "010575" ], + "010516" : [ "08:36", "350000", "010576" ], + "010517" : [ "08:37", "350000", "010577" ], + "010518" : [ "08:38", "350000", "010578" ], + "010519" : [ "08:39", "350000", "010579" ], + "010520" : [ "08:40", "350000", "010580" ], + "010521" : [ "08:41", "350000", "010581" ], + "010522" : [ "08:42", "350000", "010582" ], + "010523" : [ "08:43", "350000", "010583" ], + "010524" : [ "08:44", "350000", "010584" ], + "010525" : [ "08:45", "350000", "010585" ], + "010526" : [ "08:46", "350000", "010586" ], + "010527" : [ "08:47", "350000", "010587" ], + "010528" : [ "08:48", "350000", "010588" ], + "010529" : [ "08:49", "350000", "010589" ], + "010530" : [ "08:50", "350000", "010590" ], + "010531" : [ "08:51", "350000", "010591" ], + "010532" : [ "08:52", "350000", "010592" ], + "010533" : [ "08:53", "350000", "010593" ], + "010534" : [ "08:54", "350000", "010594" ], + "010535" : [ "08:55", "350000", "010595" ], + "010536" : [ "08:56", "350000", "010596" ], + "010537" : [ "08:57", "350000", "010597" ], + "010538" : [ "08:58", "350000", "010598" ], + "010539" : [ "08:59", "350000", "010599" ], + "010540" : [ "09:00", "350000", "010600" ], + "010541" : [ "09:01", "350000", "010601" ], + "010542" : [ "09:02", "350000", "010602" ], + "010543" : [ "09:03", "350000", "010603" ], + "010544" : [ "09:04", "350000", "010604" ], + "010545" : [ "09:05", "350000", "010605" ], + "010546" : [ "09:06", "350000", "010606" ], + "010547" : [ "09:07", "350000", "010607" ], + "010548" : [ "09:08", "350000", "010608" ], + "010549" : [ "09:09", "350000", "010609" ], + "010550" : [ "09:10", "350000", "010610" ], + "010551" : [ "09:11", "350000", "010611" ], + "010552" : [ "09:12", "350000", "010612" ], + "010553" : [ "09:13", "350000", "010613" ], + "010554" : [ "09:14", "350000", "010614" ], + "010555" : [ "09:15", "350000", "010615" ], + "010556" : [ "09:16", "350000", "010616" ], + "010557" : [ "09:17", "350000", "010617" ], + "010558" : [ "09:18", "350000", "010618" ], + "010559" : [ "09:19", "350000", "010619" ], + "010560" : [ "09:20", "350000", "010620" ], + "010561" : [ "09:21", "350000", "010621" ], + "010562" : [ "09:22", "350000", "010622" ], + "010563" : [ "09:23", "350000", "010623" ], + "010564" : [ "09:24", "350000", "010624" ], + "010565" : [ "09:25", "350000", "010625" ], + "010566" : [ "09:26", "350000", "010626" ], + "010567" : [ "09:27", "350000", "010627" ], + "010568" : [ "09:28", "350000", "010628" ], + "010569" : [ "09:29", "350000", "010629" ], + "010570" : [ "09:30", "350000", "010630" ], + "010571" : [ "09:31", "350000", "010631" ], + "010572" : [ "09:32", "350000", "010632" ], + "010573" : [ "09:33", "350000", "010633" ], + "010574" : [ "09:34", "350000", "010634" ], + "010575" : [ "09:35", "350000", "010635" ], + "010576" : [ "09:36", "350000", "010636" ], + "010577" : [ "09:37", "350000", "010637" ], + "010578" : [ "09:38", "350000", "010638" ], + "010579" : [ "09:39", "350000", "010639" ], + "010580" : [ "09:40", "350000", "010640" ], + "010581" : [ "09:41", "350000", "010641" ], + "010582" : [ "09:42", "350000", "010642" ], + "010583" : [ "09:43", "350000", "010643" ], + "010584" : [ "09:44", "350000", "010644" ], + "010585" : [ "09:45", "350000", "010645" ], + "010586" : [ "09:46", "350000", "010646" ], + "010587" : [ "09:47", "350000", "010647" ], + "010588" : [ "09:48", "350000", "010648" ], + "010589" : [ "09:49", "350000", "010649" ], + "010590" : [ "09:50", "350000", "010650" ], + "010591" : [ "09:51", "350000", "010651" ], + "010592" : [ "09:52", "350000", "010652" ], + "010593" : [ "09:53", "350000", "010653" ], + "010594" : [ "09:54", "350000", "010654" ], + "010595" : [ "09:55", "350000", "010655" ], + "010596" : [ "09:56", "350000", "010656" ], + "010597" : [ "09:57", "350000", "010657" ], + "010598" : [ "09:58", "350000", "010658" ], + "010599" : [ "09:59", "350000", "010659" ], + "010600" : [ "10:00", "350000", "010660" ], + "010601" : [ "10:01", "350000", "010661" ], + "010602" : [ "10:02", "350000", "010662" ], + "010603" : [ "10:03", "350000", "010663" ], + "010604" : [ "10:04", "350000", "010664" ], + "010605" : [ "10:05", "350000", "010665" ], + "010606" : [ "10:06", "350000", "010666" ], + "010607" : [ "10:07", "350000", "010667" ], + "010608" : [ "10:08", "350000", "010668" ], + "010609" : [ "10:09", "350000", "010669" ], + "010610" : [ "10:10", "350000", "010670" ], + "010611" : [ "10:11", "350000", "010671" ], + "010612" : [ "10:12", "350000", "010672" ], + "010613" : [ "10:13", "350000", "010673" ], + "010614" : [ "10:14", "350000", "010674" ], + "010615" : [ "10:15", "350000", "010675" ], + "010616" : [ "10:16", "350000", "010676" ], + "010617" : [ "10:17", "350000", "010677" ], + "010618" : [ "10:18", "350000", "010678" ], + "010619" : [ "10:19", "350000", "010679" ], + "010620" : [ "10:20", "350000", "010680" ], + "010621" : [ "10:21", "350000", "010681" ], + "010622" : [ "10:22", "350000", "010682" ], + "010623" : [ "10:23", "350000", "010683" ], + "010624" : [ "10:24", "350000", "010684" ], + "010625" : [ "10:25", "350000", "010685" ], + "010626" : [ "10:26", "350000", "010686" ], + "010627" : [ "10:27", "350000", "010687" ], + "010628" : [ "10:28", "350000", "010688" ], + "010629" : [ "10:29", "350000", "010689" ], + "010630" : [ "10:30", "350000", "010690" ], + "010631" : [ "10:31", "350000", "010691" ], + "010632" : [ "10:32", "350000", "010692" ], + "010633" : [ "10:33", "350000", "010693" ], + "010634" : [ "10:34", "350000", "010694" ], + "010635" : [ "10:35", "350000", "010695" ], + "010636" : [ "10:36", "350000", "010696" ], + "010637" : [ "10:37", "350000", "010697" ], + "010638" : [ "10:38", "350000", "010698" ], + "010639" : [ "10:39", "350000", "010699" ], + "010640" : [ "10:40", "350000", "010700" ], + "010641" : [ "10:41", "350000", "010701" ], + "010642" : [ "10:42", "350000", "010702" ], + "010643" : [ "10:43", "350000", "010703" ], + "010644" : [ "10:44", "350000", "010704" ], + "010645" : [ "10:45", "350000", "010705" ], + "010646" : [ "10:46", "350000", "010706" ], + "010647" : [ "10:47", "350000", "010707" ], + "010648" : [ "10:48", "350000", "010708" ], + "010649" : [ "10:49", "350000", "010709" ], + "010650" : [ "10:50", "350000", "010710" ], + "010651" : [ "10:51", "350000", "010711" ], + "010652" : [ "10:52", "350000", "010712" ], + "010653" : [ "10:53", "350000", "010713" ], + "010654" : [ "10:54", "350000", "010714" ], + "010655" : [ "10:55", "350000", "010715" ], + "010656" : [ "10:56", "350000", "010716" ], + "010657" : [ "10:57", "350000", "010717" ], + "010658" : [ "10:58", "350000", "010718" ], + "010659" : [ "10:59", "350000", "010719" ], + "010660" : [ "11:00", "350000", "010720" ], + "010661" : [ "11:01", "350000", "010721" ], + "010662" : [ "11:02", "350000", "010722" ], + "010663" : [ "11:03", "350000", "010723" ], + "010664" : [ "11:04", "350000", "010724" ], + "010665" : [ "11:05", "350000", "010725" ], + "010666" : [ "11:06", "350000", "010726" ], + "010667" : [ "11:07", "350000", "010727" ], + "010668" : [ "11:08", "350000", "010728" ], + "010669" : [ "11:09", "350000", "010729" ], + "010670" : [ "11:10", "350000", "010730" ], + "010671" : [ "11:11", "350000", "010731" ], + "010672" : [ "11:12", "350000", "010732" ], + "010673" : [ "11:13", "350000", "010733" ], + "010674" : [ "11:14", "350000", "010734" ], + "010675" : [ "11:15", "350000", "010735" ], + "010676" : [ "11:16", "350000", "010736" ], + "010677" : [ "11:17", "350000", "010737" ], + "010678" : [ "11:18", "350000", "010738" ], + "010679" : [ "11:19", "350000", "010739" ], + "010680" : [ "11:20", "350000", "010740" ], + "010681" : [ "11:21", "350000", "010741" ], + "010682" : [ "11:22", "350000", "010742" ], + "010683" : [ "11:23", "350000", "010743" ], + "010684" : [ "11:24", "350000", "010744" ], + "010685" : [ "11:25", "350000", "010745" ], + "010686" : [ "11:26", "350000", "010746" ], + "010687" : [ "11:27", "350000", "010747" ], + "010688" : [ "11:28", "350000", "010748" ], + "010689" : [ "11:29", "350000", "010749" ], + "010690" : [ "11:30", "350000", "010750" ], + "010691" : [ "11:31", "350000", "010751" ], + "010692" : [ "11:32", "350000", "010752" ], + "010693" : [ "11:33", "350000", "010753" ], + "010694" : [ "11:34", "350000", "010754" ], + "010695" : [ "11:35", "350000", "010755" ], + "010696" : [ "11:36", "350000", "010756" ], + "010697" : [ "11:37", "350000", "010757" ], + "010698" : [ "11:38", "350000", "010758" ], + "010699" : [ "11:39", "350000", "010759" ], + "010700" : [ "11:40", "350000", "010760" ], + "010701" : [ "11:41", "350000", "010761" ], + "010702" : [ "11:42", "350000", "010762" ], + "010703" : [ "11:43", "350000", "010763" ], + "010704" : [ "11:44", "350000", "010764" ], + "010705" : [ "11:45", "350000", "010765" ], + "010706" : [ "11:46", "350000", "010766" ], + "010707" : [ "11:47", "350000", "010767" ], + "010708" : [ "11:48", "350000", "010768" ], + "010709" : [ "11:49", "350000", "010769" ], + "010710" : [ "11:50", "350000", "010770" ], + "010711" : [ "11:51", "350000", "010771" ], + "010712" : [ "11:52", "350000", "010772" ], + "010713" : [ "11:53", "350000", "010773" ], + "010714" : [ "11:54", "350000", "010774" ], + "010715" : [ "11:55", "350000", "010775" ], + "010716" : [ "11:56", "350000", "010776" ], + "010717" : [ "11:57", "350000", "010777" ], + "010718" : [ "11:58", "350000", "010778" ], + "010719" : [ "11:59", "350000", "010779" ], + "010720" : [ "12:00", "350000", "010780" ], + "010721" : [ "12:01", "350000", "010781" ], + "010722" : [ "12:02", "350000", "010782" ], + "010723" : [ "12:03", "350000", "010783" ], + "010724" : [ "12:04", "350000", "010784" ], + "010725" : [ "12:05", "350000", "010785" ], + "010726" : [ "12:06", "350000", "010786" ], + "010727" : [ "12:07", "350000", "010787" ], + "010728" : [ "12:08", "350000", "010788" ], + "010729" : [ "12:09", "350000", "010789" ], + "010730" : [ "12:10", "350000", "010790" ], + "010731" : [ "12:11", "350000", "010791" ], + "010732" : [ "12:12", "350000", "010792" ], + "010733" : [ "12:13", "350000", "010793" ], + "010734" : [ "12:14", "350000", "010794" ], + "010735" : [ "12:15", "350000", "010795" ], + "010736" : [ "12:16", "350000", "010796" ], + "010737" : [ "12:17", "350000", "010797" ], + "010738" : [ "12:18", "350000", "010798" ], + "010739" : [ "12:19", "350000", "010799" ], + "010740" : [ "12:20", "350000", "010800" ], + "010741" : [ "12:21", "350000", "010801" ], + "010742" : [ "12:22", "350000", "010802" ], + "010743" : [ "12:23", "350000", "010803" ], + "010744" : [ "12:24", "350000", "010804" ], + "010745" : [ "12:25", "350000", "010805" ], + "010746" : [ "12:26", "350000", "010806" ], + "010747" : [ "12:27", "350000", "010807" ], + "010748" : [ "12:28", "350000", "010808" ], + "010749" : [ "12:29", "350000", "010809" ], + "010750" : [ "12:30", "350000", "010810" ], + "010751" : [ "12:31", "350000", "010811" ], + "010752" : [ "12:32", "350000", "010812" ], + "010753" : [ "12:33", "350000", "010813" ], + "010754" : [ "12:34", "350000", "010814" ], + "010755" : [ "12:35", "350000", "010815" ], + "010756" : [ "12:36", "350000", "010816" ], + "010757" : [ "12:37", "350000", "010817" ], + "010758" : [ "12:38", "350000", "010818" ], + "010759" : [ "12:39", "350000", "010819" ], + "010760" : [ "12:40", "350000", "010820" ], + "010761" : [ "12:41", "350000", "010821" ], + "010762" : [ "12:42", "350000", "010822" ], + "010763" : [ "12:43", "350000", "010823" ], + "010764" : [ "12:44", "350000", "010824" ], + "010765" : [ "12:45", "350000", "010825" ], + "010766" : [ "12:46", "350000", "010826" ], + "010767" : [ "12:47", "350000", "010827" ], + "010768" : [ "12:48", "350000", "010828" ], + "010769" : [ "12:49", "350000", "010829" ], + "010770" : [ "12:50", "350000", "010830" ], + "010771" : [ "12:51", "350000", "010831" ], + "010772" : [ "12:52", "350000", "010832" ], + "010773" : [ "12:53", "350000", "010833" ], + "010774" : [ "12:54", "350000", "010834" ], + "010775" : [ "12:55", "350000", "010835" ], + "010776" : [ "12:56", "350000", "010836" ], + "010777" : [ "12:57", "350000", "010837" ], + "010778" : [ "12:58", "350000", "010838" ], + "010779" : [ "12:59", "350000", "010839" ], + "010780" : [ "13:00", "350000", "010840" ], + "010781" : [ "13:01", "350000", "010841" ], + "010782" : [ "13:02", "350000", "010842" ], + "010783" : [ "13:03", "350000", "010843" ], + "010784" : [ "13:04", "350000", "010844" ], + "010785" : [ "13:05", "350000", "010845" ], + "010786" : [ "13:06", "350000", "010846" ], + "010787" : [ "13:07", "350000", "010847" ], + "010788" : [ "13:08", "350000", "010848" ], + "010789" : [ "13:09", "350000", "010849" ], + "010790" : [ "13:10", "350000", "010850" ], + "010791" : [ "13:11", "350000", "010851" ], + "010792" : [ "13:12", "350000", "010852" ], + "010793" : [ "13:13", "350000", "010853" ], + "010794" : [ "13:14", "350000", "010854" ], + "010795" : [ "13:15", "350000", "010855" ], + "010796" : [ "13:16", "350000", "010856" ], + "010797" : [ "13:17", "350000", "010857" ], + "010798" : [ "13:18", "350000", "010858" ], + "010799" : [ "13:19", "350000", "010859" ], + "010800" : [ "13:20", "350000", "010860" ], + "010801" : [ "13:21", "350000", "010861" ], + "010802" : [ "13:22", "350000", "010862" ], + "010803" : [ "13:23", "350000", "010863" ], + "010804" : [ "13:24", "350000", "010864" ], + "010805" : [ "13:25", "350000", "010865" ], + "010806" : [ "13:26", "350000", "010866" ], + "010807" : [ "13:27", "350000", "010867" ], + "010808" : [ "13:28", "350000", "010868" ], + "010809" : [ "13:29", "350000", "010869" ], + "010810" : [ "13:30", "350000", "010870" ], + "010811" : [ "13:31", "350000", "010871" ], + "010812" : [ "13:32", "350000", "010872" ], + "010813" : [ "13:33", "350000", "010873" ], + "010814" : [ "13:34", "350000", "010874" ], + "010815" : [ "13:35", "350000", "010875" ], + "010816" : [ "13:36", "350000", "010876" ], + "010817" : [ "13:37", "350000", "010877" ], + "010818" : [ "13:38", "350000", "010878" ], + "010819" : [ "13:39", "350000", "010879" ], + "010820" : [ "13:40", "350000", "010880" ], + "010821" : [ "13:41", "350000", "010881" ], + "010822" : [ "13:42", "350000", "010882" ], + "010823" : [ "13:43", "350000", "010883" ], + "010824" : [ "13:44", "350000", "010884" ], + "010825" : [ "13:45", "350000", "010885" ], + "010826" : [ "13:46", "350000", "010886" ], + "010827" : [ "13:47", "350000", "010887" ], + "010828" : [ "13:48", "350000", "010888" ], + "010829" : [ "13:49", "350000", "010889" ], + "010830" : [ "13:50", "350000", "010890" ], + "010831" : [ "13:51", "350000", "010891" ], + "010832" : [ "13:52", "350000", "010892" ], + "010833" : [ "13:53", "350000", "010893" ], + "010834" : [ "13:54", "350000", "010894" ], + "010835" : [ "13:55", "350000", "010895" ], + "010836" : [ "13:56", "350000", "010896" ], + "010837" : [ "13:57", "350000", "010897" ], + "010838" : [ "13:58", "350000", "010898" ], + "010839" : [ "13:59", "350000", "010899" ], + "010840" : [ "14:00", "350000", "010900" ], + "010841" : [ "14:01", "350000", "010901" ], + "010842" : [ "14:02", "350000", "010902" ], + "010843" : [ "14:03", "350000", "010903" ], + "010844" : [ "14:04", "350000", "010904" ], + "010845" : [ "14:05", "350000", "010905" ], + "010846" : [ "14:06", "350000", "010906" ], + "010847" : [ "14:07", "350000", "010907" ], + "010848" : [ "14:08", "350000", "010908" ], + "010849" : [ "14:09", "350000", "010909" ], + "010850" : [ "14:10", "350000", "010910" ], + "010851" : [ "14:11", "350000", "010911" ], + "010852" : [ "14:12", "350000", "010912" ], + "010853" : [ "14:13", "350000", "010913" ], + "010854" : [ "14:14", "350000", "010914" ], + "010855" : [ "14:15", "350000", "010915" ], + "010856" : [ "14:16", "350000", "010916" ], + "010857" : [ "14:17", "350000", "010917" ], + "010858" : [ "14:18", "350000", "010918" ], + "010859" : [ "14:19", "350000", "010919" ], + "010860" : [ "14:20", "350000", "010920" ], + "010861" : [ "14:21", "350000", "010921" ], + "010862" : [ "14:22", "350000", "010922" ], + "010863" : [ "14:23", "350000", "010923" ], + "010864" : [ "14:24", "350000", "010924" ], + "010865" : [ "14:25", "350000", "010925" ], + "010866" : [ "14:26", "350000", "010926" ], + "010867" : [ "14:27", "350000", "010927" ], + "010868" : [ "14:28", "350000", "010928" ], + "010869" : [ "14:29", "350000", "010929" ], + "010870" : [ "14:30", "350000", "010930" ], + "010871" : [ "14:31", "350000", "010931" ], + "010872" : [ "14:32", "350000", "010932" ], + "010873" : [ "14:33", "350000", "010933" ], + "010874" : [ "14:34", "350000", "010934" ], + "010875" : [ "14:35", "350000", "010935" ], + "010876" : [ "14:36", "350000", "010936" ], + "010877" : [ "14:37", "350000", "010937" ], + "010878" : [ "14:38", "350000", "010938" ], + "010879" : [ "14:39", "350000", "010939" ], + "010880" : [ "14:40", "350000", "010940" ], + "010881" : [ "14:41", "350000", "010941" ], + "010882" : [ "14:42", "350000", "010942" ], + "010883" : [ "14:43", "350000", "010943" ], + "010884" : [ "14:44", "350000", "010944" ], + "010885" : [ "14:45", "350000", "010945" ], + "010886" : [ "14:46", "350000", "010946" ], + "010887" : [ "14:47", "350000", "010947" ], + "010888" : [ "14:48", "350000", "010948" ], + "010889" : [ "14:49", "350000", "010949" ], + "010890" : [ "14:50", "350000", "010950" ], + "010891" : [ "14:51", "350000", "010951" ], + "010892" : [ "14:52", "350000", "010952" ], + "010893" : [ "14:53", "350000", "010953" ], + "010894" : [ "14:54", "350000", "010954" ], + "010895" : [ "14:55", "350000", "010955" ], + "010896" : [ "14:56", "350000", "010956" ], + "010897" : [ "14:57", "350000", "010957" ], + "010898" : [ "14:58", "350000", "010958" ], + "010899" : [ "14:59", "350000", "010959" ], + "010900" : [ "15:00", "350000", "010960" ], + "010901" : [ "15:01", "350000", "010961" ], + "010902" : [ "15:02", "350000", "010962" ], + "010903" : [ "15:03", "350000", "010963" ], + "010904" : [ "15:04", "350000", "010964" ], + "010905" : [ "15:05", "350000", "010965" ], + "010906" : [ "15:06", "350000", "010966" ], + "010907" : [ "15:07", "350000", "010967" ], + "010908" : [ "15:08", "350000", "010968" ], + "010909" : [ "15:09", "350000", "010969" ], + "010910" : [ "15:10", "350000", "010970" ], + "010911" : [ "15:11", "350000", "010971" ], + "010912" : [ "15:12", "350000", "010972" ], + "010913" : [ "15:13", "350000", "010973" ], + "010914" : [ "15:14", "350000", "010974" ], + "010915" : [ "15:15", "350000", "010975" ], + "010916" : [ "15:16", "350000", "010976" ], + "010917" : [ "15:17", "350000", "010977" ], + "010918" : [ "15:18", "350000", "010978" ], + "010919" : [ "15:19", "350000", "010979" ], + "010920" : [ "15:20", "350000", "010980" ], + "010921" : [ "15:21", "350000", "010981" ], + "010922" : [ "15:22", "350000", "010982" ], + "010923" : [ "15:23", "350000", "010983" ], + "010924" : [ "15:24", "350000", "010984" ], + "010925" : [ "15:25", "350000", "010985" ], + "010926" : [ "15:26", "350000", "010986" ], + "010927" : [ "15:27", "350000", "010987" ], + "010928" : [ "15:28", "350000", "010988" ], + "010929" : [ "15:29", "350000", "010989" ], + "010930" : [ "15:30", "350000", "010990" ], + "010931" : [ "15:31", "350000", "010991" ], + "010932" : [ "15:32", "350000", "010992" ], + "010933" : [ "15:33", "350000", "010993" ], + "010934" : [ "15:34", "350000", "010994" ], + "010935" : [ "15:35", "350000", "010995" ], + "010936" : [ "15:36", "350000", "010996" ], + "010937" : [ "15:37", "350000", "010997" ], + "010938" : [ "15:38", "350000", "010998" ], + "010939" : [ "15:39", "350000", "010999" ], + "010940" : [ "15:40", "350000", "011000" ], + "010941" : [ "15:41", "350000", "011001" ], + "010942" : [ "15:42", "350000", "011002" ], + "010943" : [ "15:43", "350000", "011003" ], + "010944" : [ "15:44", "350000", "011004" ], + "010945" : [ "15:45", "350000", "011005" ], + "010946" : [ "15:46", "350000", "011006" ], + "010947" : [ "15:47", "350000", "011007" ], + "010948" : [ "15:48", "350000", "011008" ], + "010949" : [ "15:49", "350000", "011009" ], + "010950" : [ "15:50", "350000", "011010" ], + "010951" : [ "15:51", "350000", "011011" ], + "010952" : [ "15:52", "350000", "011012" ], + "010953" : [ "15:53", "350000", "011013" ], + "010954" : [ "15:54", "350000", "011014" ], + "010955" : [ "15:55", "350000", "011015" ], + "010956" : [ "15:56", "350000", "011016" ], + "010957" : [ "15:57", "350000", "011017" ], + "010958" : [ "15:58", "350000", "011018" ], + "010959" : [ "15:59", "350000", "011019" ], + "010960" : [ "16:00", "350000", "011020" ], + "010961" : [ "16:01", "350000", "011021" ], + "010962" : [ "16:02", "350000", "011022" ], + "010963" : [ "16:03", "350000", "011023" ], + "010964" : [ "16:04", "350000", "011024" ], + "010965" : [ "16:05", "350000", "011025" ], + "010966" : [ "16:06", "350000", "011026" ], + "010967" : [ "16:07", "350000", "011027" ], + "010968" : [ "16:08", "350000", "011028" ], + "010969" : [ "16:09", "350000", "011029" ], + "010970" : [ "16:10", "350000", "011030" ], + "010971" : [ "16:11", "350000", "011031" ], + "010972" : [ "16:12", "350000", "011032" ], + "010973" : [ "16:13", "350000", "011033" ], + "010974" : [ "16:14", "350000", "011034" ], + "010975" : [ "16:15", "350000", "011035" ], + "010976" : [ "16:16", "350000", "011036" ], + "010977" : [ "16:17", "350000", "011037" ], + "010978" : [ "16:18", "350000", "011038" ], + "010979" : [ "16:19", "350000", "011039" ], + "010980" : [ "16:20", "350000", "011040" ], + "010981" : [ "16:21", "350000", "011041" ], + "010982" : [ "16:22", "350000", "011042" ], + "010983" : [ "16:23", "350000", "011043" ], + "010984" : [ "16:24", "350000", "011044" ], + "010985" : [ "16:25", "350000", "011045" ], + "010986" : [ "16:26", "350000", "011046" ], + "010987" : [ "16:27", "350000", "011047" ], + "010988" : [ "16:28", "350000", "011048" ], + "010989" : [ "16:29", "350000", "011049" ], + "010990" : [ "16:30", "350000", "011050" ], + "010991" : [ "16:31", "350000", "011051" ], + "010992" : [ "16:32", "350000", "011052" ], + "010993" : [ "16:33", "350000", "011053" ], + "010994" : [ "16:34", "350000", "011054" ], + "010995" : [ "16:35", "350000", "011055" ], + "010996" : [ "16:36", "350000", "011056" ], + "010997" : [ "16:37", "350000", "011057" ], + "010998" : [ "16:38", "350000", "011058" ], + "010999" : [ "16:39", "350000", "011059" ], + "011000" : [ "16:40", "350000", "011060" ], + "011001" : [ "16:41", "350000", "011061" ], + "011002" : [ "16:42", "350000", "011062" ], + "011003" : [ "16:43", "350000", "011063" ], + "011004" : [ "16:44", "350000", "011064" ], + "011005" : [ "16:45", "350000", "011065" ], + "011006" : [ "16:46", "350000", "011066" ], + "011007" : [ "16:47", "350000", "011067" ], + "011008" : [ "16:48", "350000", "011068" ], + "011009" : [ "16:49", "350000", "011069" ], + "011010" : [ "16:50", "350000", "011070" ], + "011011" : [ "16:51", "350000", "011071" ], + "011012" : [ "16:52", "350000", "011072" ], + "011013" : [ "16:53", "350000", "011073" ], + "011014" : [ "16:54", "350000", "011074" ], + "011015" : [ "16:55", "350000", "011075" ], + "011016" : [ "16:56", "350000", "011076" ], + "011017" : [ "16:57", "350000", "011077" ], + "011018" : [ "16:58", "350000", "011078" ], + "011019" : [ "16:59", "350000", "011079" ], + "011020" : [ "17:00", "350000", "011080" ], + "011021" : [ "17:01", "350000", "011081" ], + "011022" : [ "17:02", "350000", "011082" ], + "011023" : [ "17:03", "350000", "011083" ], + "011024" : [ "17:04", "350000", "011084" ], + "011025" : [ "17:05", "350000", "011085" ], + "011026" : [ "17:06", "350000", "011086" ], + "011027" : [ "17:07", "350000", "011087" ], + "011028" : [ "17:08", "350000", "011088" ], + "011029" : [ "17:09", "350000", "011089" ], + "011030" : [ "17:10", "350000", "011090" ], + "011031" : [ "17:11", "350000", "011091" ], + "011032" : [ "17:12", "350000", "011092" ], + "011033" : [ "17:13", "350000", "011093" ], + "011034" : [ "17:14", "350000", "011094" ], + "011035" : [ "17:15", "350000", "011095" ], + "011036" : [ "17:16", "350000", "011096" ], + "011037" : [ "17:17", "350000", "011097" ], + "011038" : [ "17:18", "350000", "011098" ], + "011039" : [ "17:19", "350000", "011099" ], + "011040" : [ "17:20", "350000", "011100" ], + "011041" : [ "17:21", "350000", "011101" ], + "011042" : [ "17:22", "350000", "011102" ], + "011043" : [ "17:23", "350000", "011103" ], + "011044" : [ "17:24", "350000", "011104" ], + "011045" : [ "17:25", "350000", "011105" ], + "011046" : [ "17:26", "350000", "011106" ], + "011047" : [ "17:27", "350000", "011107" ], + "011048" : [ "17:28", "350000", "011108" ], + "011049" : [ "17:29", "350000", "011109" ], + "011050" : [ "17:30", "350000", "011110" ], + "011051" : [ "17:31", "350000", "011111" ], + "011052" : [ "17:32", "350000", "011112" ], + "011053" : [ "17:33", "350000", "011113" ], + "011054" : [ "17:34", "350000", "011114" ], + "011055" : [ "17:35", "350000", "011115" ], + "011056" : [ "17:36", "350000", "011116" ], + "011057" : [ "17:37", "350000", "011117" ], + "011058" : [ "17:38", "350000", "011118" ], + "011059" : [ "17:39", "350000", "011119" ], + "011060" : [ "17:40", "350000", "011120" ], + "011061" : [ "17:41", "350000", "011121" ], + "011062" : [ "17:42", "350000", "011122" ], + "011063" : [ "17:43", "350000", "011123" ], + "011064" : [ "17:44", "350000", "011124" ], + "011065" : [ "17:45", "350000", "011125" ], + "011066" : [ "17:46", "350000", "011126" ], + "011067" : [ "17:47", "350000", "011127" ], + "011068" : [ "17:48", "350000", "011128" ], + "011069" : [ "17:49", "350000", "011129" ], + "011070" : [ "17:50", "350000", "011130" ], + "011071" : [ "17:51", "350000", "011131" ], + "011072" : [ "17:52", "350000", "011132" ], + "011073" : [ "17:53", "350000", "011133" ], + "011074" : [ "17:54", "350000", "011134" ], + "011075" : [ "17:55", "350000", "011135" ], + "011076" : [ "17:56", "350000", "011136" ], + "011077" : [ "17:57", "350000", "011137" ], + "011078" : [ "17:58", "350000", "011138" ], + "011079" : [ "17:59", "350000", "011139" ], + "011080" : [ "18:00", "350000", "011140" ], + "011081" : [ "18:01", "350000", "011141" ], + "011082" : [ "18:02", "350000", "011142" ], + "011083" : [ "18:03", "350000", "011143" ], + "011084" : [ "18:04", "350000", "011144" ], + "011085" : [ "18:05", "350000", "011145" ], + "011086" : [ "18:06", "350000", "011146" ], + "011087" : [ "18:07", "350000", "011147" ], + "011088" : [ "18:08", "350000", "011148" ], + "011089" : [ "18:09", "350000", "011149" ], + "011090" : [ "18:10", "350000", "011150" ], + "011091" : [ "18:11", "350000", "011151" ], + "011092" : [ "18:12", "350000", "011152" ], + "011093" : [ "18:13", "350000", "011153" ], + "011094" : [ "18:14", "350000", "011154" ], + "011095" : [ "18:15", "350000", "011155" ], + "011096" : [ "18:16", "350000", "011156" ], + "011097" : [ "18:17", "350000", "011157" ], + "011098" : [ "18:18", "350000", "011158" ], + "011099" : [ "18:19", "350000", "011159" ], + "011100" : [ "18:20", "350000", "011160" ], + "011101" : [ "18:21", "350000", "011161" ], + "011102" : [ "18:22", "350000", "011162" ], + "011103" : [ "18:23", "350000", "011163" ], + "011104" : [ "18:24", "350000", "011164" ], + "011105" : [ "18:25", "350000", "011165" ], + "011106" : [ "18:26", "350000", "011166" ], + "011107" : [ "18:27", "350000", "011167" ], + "011108" : [ "18:28", "350000", "011168" ], + "011109" : [ "18:29", "350000", "011169" ], + "011110" : [ "18:30", "350000", "011170" ], + "011111" : [ "18:31", "350000", "011171" ], + "011112" : [ "18:32", "350000", "011172" ], + "011113" : [ "18:33", "350000", "011173" ], + "011114" : [ "18:34", "350000", "011174" ], + "011115" : [ "18:35", "350000", "011175" ], + "011116" : [ "18:36", "350000", "011176" ], + "011117" : [ "18:37", "350000", "011177" ], + "011118" : [ "18:38", "350000", "011178" ], + "011119" : [ "18:39", "350000", "011179" ], + "011120" : [ "18:40", "350000", "011180" ], + "011121" : [ "18:41", "350000", "011181" ], + "011122" : [ "18:42", "350000", "011182" ], + "011123" : [ "18:43", "350000", "011183" ], + "011124" : [ "18:44", "350000", "011184" ], + "011125" : [ "18:45", "350000", "011185" ], + "011126" : [ "18:46", "350000", "011186" ], + "011127" : [ "18:47", "350000", "011187" ], + "011128" : [ "18:48", "350000", "011188" ], + "011129" : [ "18:49", "350000", "011189" ], + "011130" : [ "18:50", "350000", "011190" ], + "011131" : [ "18:51", "350000", "011191" ], + "011132" : [ "18:52", "350000", "011192" ], + "011133" : [ "18:53", "350000", "011193" ], + "011134" : [ "18:54", "350000", "011194" ], + "011135" : [ "18:55", "350000", "011195" ], + "011136" : [ "18:56", "350000", "011196" ], + "011137" : [ "18:57", "350000", "011197" ], + "011138" : [ "18:58", "350000", "011198" ], + "011139" : [ "18:59", "350000", "011199" ], + "011140" : [ "19:00", "350000", "011200" ], + "011141" : [ "19:01", "350000", "011200" ], + "011142" : [ "19:02", "350000", "011200" ], + "011143" : [ "19:03", "350000", "011200" ], + "011144" : [ "19:04", "350000", "011200" ], + "011145" : [ "19:05", "350000", "011200" ], + "011146" : [ "19:06", "350000", "011200" ], + "011147" : [ "19:07", "350000", "011200" ], + "011148" : [ "19:08", "350000", "011200" ], + "011149" : [ "19:09", "350000", "011200" ], + "011150" : [ "19:10", "350000", "011200" ], + "011151" : [ "19:11", "350000", "011200" ], + "011152" : [ "19:12", "350000", "011200" ], + "011153" : [ "19:13", "350000", "011200" ], + "011154" : [ "19:14", "350000", "011200" ], + "011155" : [ "19:15", "350000", "011200" ], + "011156" : [ "19:16", "350000", "011200" ], + "011157" : [ "19:17", "350000", "011200" ], + "011158" : [ "19:18", "350000", "011200" ], + "011159" : [ "19:19", "350000", "011200" ], + "011160" : [ "19:20", "350000", "011200" ], + "011161" : [ "19:21", "350000", "011200" ], + "011162" : [ "19:22", "350000", "011200" ], + "011163" : [ "19:23", "350000", "011200" ], + "011164" : [ "19:24", "350000", "011200" ], + "011165" : [ "19:25", "350000", "011200" ], + "011166" : [ "19:26", "350000", "011200" ], + "011167" : [ "19:27", "350000", "011200" ], + "011168" : [ "19:28", "350000", "011200" ], + "011169" : [ "19:29", "350000", "011200" ], + "011170" : [ "19:30", "350000", "011200" ], + "011171" : [ "19:31", "350000", "011200" ], + "011172" : [ "19:32", "350000", "011200" ], + "011173" : [ "19:33", "350000", "011200" ], + "011174" : [ "19:34", "350000", "011200" ], + "011175" : [ "19:35", "350000", "011200" ], + "011176" : [ "19:36", "350000", "011200" ], + "011177" : [ "19:37", "350000", "011200" ], + "011178" : [ "19:38", "350000", "011200" ], + "011179" : [ "19:39", "350000", "011200" ], + "011180" : [ "19:40", "350000", "011200" ], + "011181" : [ "19:41", "350000", "011200" ], + "011182" : [ "19:42", "350000", "011200" ], + "011183" : [ "19:43", "350000", "011200" ], + "011184" : [ "19:44", "350000", "011200" ], + "011185" : [ "19:45", "350000", "011200" ], + "011186" : [ "19:46", "350000", "011200" ], + "011187" : [ "19:47", "350000", "011200" ], + "011188" : [ "19:48", "350000", "011200" ], + "011189" : [ "19:49", "350000", "011200" ], + "011190" : [ "19:50", "350000", "011200" ], + "011191" : [ "19:51", "350000", "011200" ], + "011192" : [ "19:52", "350000", "011200" ], + "011193" : [ "19:53", "350000", "011200" ], + "011194" : [ "19:54", "350000", "011200" ], + "011195" : [ "19:55", "350000", "011200" ], + "011196" : [ "19:56", "350000", "011200" ], + "011197" : [ "19:57", "350000", "011200" ], + "011198" : [ "19:58", "350000", "011200" ], + "011199" : [ "19:59", "350000", "011200" ], + "011200" : [ "20:00", "800000", "020420" ], + "011201" : [ "20:01", "800000", "020420" ], + "011202" : [ "20:02", "800000", "020420" ], + "011203" : [ "20:03", "800000", "020420" ], + "011204" : [ "20:04", "800000", "020420" ], + "011205" : [ "20:05", "800000", "020420" ], + "011206" : [ "20:06", "800000", "020420" ], + "011207" : [ "20:07", "800000", "020420" ], + "011208" : [ "20:08", "800000", "020420" ], + "011209" : [ "20:09", "800000", "020420" ], + "011210" : [ "20:10", "800000", "020420" ], + "011211" : [ "20:11", "800000", "020420" ], + "011212" : [ "20:12", "800000", "020420" ], + "011213" : [ "20:13", "800000", "020420" ], + "011214" : [ "20:14", "800000", "020420" ], + "011215" : [ "20:15", "800000", "020420" ], + "011216" : [ "20:16", "800000", "020420" ], + "011217" : [ "20:17", "800000", "020420" ], + "011218" : [ "20:18", "800000", "020420" ], + "011219" : [ "20:19", "800000", "020420" ], + "011220" : [ "20:20", "800000", "020420" ], + "011221" : [ "20:21", "800000", "020420" ], + "011222" : [ "20:22", "800000", "020420" ], + "011223" : [ "20:23", "800000", "020420" ], + "011224" : [ "20:24", "800000", "020420" ], + "011225" : [ "20:25", "800000", "020420" ], + "011226" : [ "20:26", "800000", "020420" ], + "011227" : [ "20:27", "800000", "020420" ], + "011228" : [ "20:28", "800000", "020420" ], + "011229" : [ "20:29", "800000", "020420" ], + "011230" : [ "20:30", "800000", "020420" ], + "011231" : [ "20:31", "800000", "020420" ], + "011232" : [ "20:32", "800000", "020420" ], + "011233" : [ "20:33", "800000", "020420" ], + "011234" : [ "20:34", "800000", "020420" ], + "011235" : [ "20:35", "800000", "020420" ], + "011236" : [ "20:36", "800000", "020420" ], + "011237" : [ "20:37", "800000", "020420" ], + "011238" : [ "20:38", "800000", "020420" ], + "011239" : [ "20:39", "800000", "020420" ], + "011240" : [ "20:40", "800000", "020420" ], + "011241" : [ "20:41", "800000", "020420" ], + "011242" : [ "20:42", "800000", "020420" ], + "011243" : [ "20:43", "800000", "020420" ], + "011244" : [ "20:44", "800000", "020420" ], + "011245" : [ "20:45", "800000", "020420" ], + "011246" : [ "20:46", "800000", "020420" ], + "011247" : [ "20:47", "800000", "020420" ], + "011248" : [ "20:48", "800000", "020420" ], + "011249" : [ "20:49", "800000", "020420" ], + "011250" : [ "20:50", "800000", "020420" ], + "011251" : [ "20:51", "800000", "020420" ], + "011252" : [ "20:52", "800000", "020420" ], + "011253" : [ "20:53", "800000", "020420" ], + "011254" : [ "20:54", "800000", "020420" ], + "011255" : [ "20:55", "800000", "020420" ], + "011256" : [ "20:56", "800000", "020420" ], + "011257" : [ "20:57", "800000", "020420" ], + "011258" : [ "20:58", "800000", "020420" ], + "011259" : [ "20:59", "800000", "020420" ], + "011260" : [ "21:00", "800000", "020420" ], + "011261" : [ "21:01", "800000", "020420" ], + "011262" : [ "21:02", "800000", "020420" ], + "011263" : [ "21:03", "800000", "020420" ], + "011264" : [ "21:04", "800000", "020420" ], + "011265" : [ "21:05", "800000", "020420" ], + "011266" : [ "21:06", "800000", "020420" ], + "011267" : [ "21:07", "800000", "020420" ], + "011268" : [ "21:08", "800000", "020420" ], + "011269" : [ "21:09", "800000", "020420" ], + "011270" : [ "21:10", "800000", "020420" ], + "011271" : [ "21:11", "800000", "020420" ], + "011272" : [ "21:12", "800000", "020420" ], + "011273" : [ "21:13", "800000", "020420" ], + "011274" : [ "21:14", "800000", "020420" ], + "011275" : [ "21:15", "800000", "020420" ], + "011276" : [ "21:16", "800000", "020420" ], + "011277" : [ "21:17", "800000", "020420" ], + "011278" : [ "21:18", "800000", "020420" ], + "011279" : [ "21:19", "800000", "020420" ], + "011280" : [ "21:20", "800000", "020420" ], + "011281" : [ "21:21", "800000", "020420" ], + "011282" : [ "21:22", "800000", "020420" ], + "011283" : [ "21:23", "800000", "020420" ], + "011284" : [ "21:24", "800000", "020420" ], + "011285" : [ "21:25", "800000", "020420" ], + "011286" : [ "21:26", "800000", "020420" ], + "011287" : [ "21:27", "800000", "020420" ], + "011288" : [ "21:28", "800000", "020420" ], + "011289" : [ "21:29", "800000", "020420" ], + "011290" : [ "21:30", "800000", "020420" ], + "011291" : [ "21:31", "800000", "020420" ], + "011292" : [ "21:32", "800000", "020420" ], + "011293" : [ "21:33", "800000", "020420" ], + "011294" : [ "21:34", "800000", "020420" ], + "011295" : [ "21:35", "800000", "020420" ], + "011296" : [ "21:36", "800000", "020420" ], + "011297" : [ "21:37", "800000", "020420" ], + "011298" : [ "21:38", "800000", "020420" ], + "011299" : [ "21:39", "800000", "020420" ], + "011300" : [ "21:40", "800000", "020420" ], + "011301" : [ "21:41", "800000", "020420" ], + "011302" : [ "21:42", "800000", "020420" ], + "011303" : [ "21:43", "800000", "020420" ], + "011304" : [ "21:44", "800000", "020420" ], + "011305" : [ "21:45", "800000", "020420" ], + "011306" : [ "21:46", "800000", "020420" ], + "011307" : [ "21:47", "800000", "020420" ], + "011308" : [ "21:48", "800000", "020420" ], + "011309" : [ "21:49", "800000", "020420" ], + "011310" : [ "21:50", "800000", "020420" ], + "011311" : [ "21:51", "800000", "020420" ], + "011312" : [ "21:52", "800000", "020420" ], + "011313" : [ "21:53", "800000", "020420" ], + "011314" : [ "21:54", "800000", "020420" ], + "011315" : [ "21:55", "800000", "020420" ], + "011316" : [ "21:56", "800000", "020420" ], + "011317" : [ "21:57", "800000", "020420" ], + "011318" : [ "21:58", "800000", "020420" ], + "011319" : [ "21:59", "800000", "020420" ], + "011320" : [ "22:00", "800000", "020420" ], + "011321" : [ "22:01", "800000", "020420" ], + "011322" : [ "22:02", "800000", "020420" ], + "011323" : [ "22:03", "800000", "020420" ], + "011324" : [ "22:04", "800000", "020420" ], + "011325" : [ "22:05", "800000", "020420" ], + "011326" : [ "22:06", "800000", "020420" ], + "011327" : [ "22:07", "800000", "020420" ], + "011328" : [ "22:08", "800000", "020420" ], + "011329" : [ "22:09", "800000", "020420" ], + "011330" : [ "22:10", "800000", "020420" ], + "011331" : [ "22:11", "800000", "020420" ], + "011332" : [ "22:12", "800000", "020420" ], + "011333" : [ "22:13", "800000", "020420" ], + "011334" : [ "22:14", "800000", "020420" ], + "011335" : [ "22:15", "800000", "020420" ], + "011336" : [ "22:16", "800000", "020420" ], + "011337" : [ "22:17", "800000", "020420" ], + "011338" : [ "22:18", "800000", "020420" ], + "011339" : [ "22:19", "800000", "020420" ], + "011340" : [ "22:20", "800000", "020420" ], + "011341" : [ "22:21", "800000", "020420" ], + "011342" : [ "22:22", "800000", "020420" ], + "011343" : [ "22:23", "800000", "020420" ], + "011344" : [ "22:24", "800000", "020420" ], + "011345" : [ "22:25", "800000", "020420" ], + "011346" : [ "22:26", "800000", "020420" ], + "011347" : [ "22:27", "800000", "020420" ], + "011348" : [ "22:28", "800000", "020420" ], + "011349" : [ "22:29", "800000", "020420" ], + "011350" : [ "22:30", "800000", "020420" ], + "011351" : [ "22:31", "800000", "020420" ], + "011352" : [ "22:32", "800000", "020420" ], + "011353" : [ "22:33", "800000", "020420" ], + "011354" : [ "22:34", "800000", "020420" ], + "011355" : [ "22:35", "800000", "020420" ], + "011356" : [ "22:36", "800000", "020420" ], + "011357" : [ "22:37", "800000", "020420" ], + "011358" : [ "22:38", "800000", "020420" ], + "011359" : [ "22:39", "800000", "020420" ], + "011360" : [ "22:40", "800000", "020420" ], + "011361" : [ "22:41", "800000", "020420" ], + "011362" : [ "22:42", "800000", "020420" ], + "011363" : [ "22:43", "800000", "020420" ], + "011364" : [ "22:44", "800000", "020420" ], + "011365" : [ "22:45", "800000", "020420" ], + "011366" : [ "22:46", "800000", "020420" ], + "011367" : [ "22:47", "800000", "020420" ], + "011368" : [ "22:48", "800000", "020420" ], + "011369" : [ "22:49", "800000", "020420" ], + "011370" : [ "22:50", "800000", "020420" ], + "011371" : [ "22:51", "800000", "020420" ], + "011372" : [ "22:52", "800000", "020420" ], + "011373" : [ "22:53", "800000", "020420" ], + "011374" : [ "22:54", "800000", "020420" ], + "011375" : [ "22:55", "800000", "020420" ], + "011376" : [ "22:56", "800000", "020420" ], + "011377" : [ "22:57", "800000", "020420" ], + "011378" : [ "22:58", "800000", "020420" ], + "011379" : [ "22:59", "800000", "020420" ], + "011380" : [ "23:00", "800000", "020420" ], + "011381" : [ "23:01", "800000", "020420" ], + "011382" : [ "23:02", "800000", "020420" ], + "011383" : [ "23:03", "800000", "020420" ], + "011384" : [ "23:04", "800000", "020420" ], + "011385" : [ "23:05", "800000", "020420" ], + "011386" : [ "23:06", "800000", "020420" ], + "011387" : [ "23:07", "800000", "020420" ], + "011388" : [ "23:08", "800000", "020420" ], + "011389" : [ "23:09", "800000", "020420" ], + "011390" : [ "23:10", "800000", "020420" ], + "011391" : [ "23:11", "800000", "020420" ], + "011392" : [ "23:12", "800000", "020420" ], + "011393" : [ "23:13", "800000", "020420" ], + "011394" : [ "23:14", "800000", "020420" ], + "011395" : [ "23:15", "800000", "020420" ], + "011396" : [ "23:16", "800000", "020420" ], + "011397" : [ "23:17", "800000", "020420" ], + "011398" : [ "23:18", "800000", "020420" ], + "011399" : [ "23:19", "800000", "020420" ], + "011400" : [ "23:20", "800000", "020420" ], + "011401" : [ "23:21", "800000", "020420" ], + "011402" : [ "23:22", "800000", "020420" ], + "011403" : [ "23:23", "800000", "020420" ], + "011404" : [ "23:24", "800000", "020420" ], + "011405" : [ "23:25", "800000", "020420" ], + "011406" : [ "23:26", "800000", "020420" ], + "011407" : [ "23:27", "800000", "020420" ], + "011408" : [ "23:28", "800000", "020420" ], + "011409" : [ "23:29", "800000", "020420" ], + "011410" : [ "23:30", "800000", "020420" ], + "011411" : [ "23:31", "800000", "020420" ], + "011412" : [ "23:32", "800000", "020420" ], + "011413" : [ "23:33", "800000", "020420" ], + "011414" : [ "23:34", "800000", "020420" ], + "011415" : [ "23:35", "800000", "020420" ], + "011416" : [ "23:36", "800000", "020420" ], + "011417" : [ "23:37", "800000", "020420" ], + "011418" : [ "23:38", "800000", "020420" ], + "011419" : [ "23:39", "800000", "020420" ], + "011420" : [ "23:40", "800000", "020420" ], + "011421" : [ "23:41", "800000", "020420" ], + "011422" : [ "23:42", "800000", "020420" ], + "011423" : [ "23:43", "800000", "020420" ], + "011424" : [ "23:44", "800000", "020420" ], + "011425" : [ "23:45", "800000", "020420" ], + "011426" : [ "23:46", "800000", "020420" ], + "011427" : [ "23:47", "800000", "020420" ], + "011428" : [ "23:48", "800000", "020420" ], + "011429" : [ "23:49", "800000", "020420" ], + "011430" : [ "23:50", "800000", "020420" ], + "011431" : [ "23:51", "800000", "020420" ], + "011432" : [ "23:52", "800000", "020420" ], + "011433" : [ "23:53", "800000", "020420" ], + "011434" : [ "23:54", "800000", "020420" ], + "011435" : [ "23:55", "800000", "020420" ], + "011436" : [ "23:56", "800000", "020420" ], + "011437" : [ "23:57", "800000", "020420" ], + "011438" : [ "23:58", "800000", "020420" ], + "011439" : [ "23:59", "800000", "020420" ] + }, + "Wednesday": { + "020000" : [ "00:00", "800000", "020420" ], + "020001" : [ "00:01", "800000", "020420" ], + "020002" : [ "00:02", "800000", "020420" ], + "020003" : [ "00:03", "800000", "020420" ], + "020004" : [ "00:04", "800000", "020420" ], + "020005" : [ "00:05", "800000", "020420" ], + "020006" : [ "00:06", "800000", "020420" ], + "020007" : [ "00:07", "800000", "020420" ], + "020008" : [ "00:08", "800000", "020420" ], + "020009" : [ "00:09", "800000", "020420" ], + "020010" : [ "00:10", "800000", "020420" ], + "020011" : [ "00:11", "800000", "020420" ], + "020012" : [ "00:12", "800000", "020420" ], + "020013" : [ "00:13", "800000", "020420" ], + "020014" : [ "00:14", "800000", "020420" ], + "020015" : [ "00:15", "800000", "020420" ], + "020016" : [ "00:16", "800000", "020420" ], + "020017" : [ "00:17", "800000", "020420" ], + "020018" : [ "00:18", "800000", "020420" ], + "020019" : [ "00:19", "800000", "020420" ], + "020020" : [ "00:20", "800000", "020420" ], + "020021" : [ "00:21", "800000", "020420" ], + "020022" : [ "00:22", "800000", "020420" ], + "020023" : [ "00:23", "800000", "020420" ], + "020024" : [ "00:24", "800000", "020420" ], + "020025" : [ "00:25", "800000", "020420" ], + "020026" : [ "00:26", "800000", "020420" ], + "020027" : [ "00:27", "800000", "020420" ], + "020028" : [ "00:28", "800000", "020420" ], + "020029" : [ "00:29", "800000", "020420" ], + "020030" : [ "00:30", "800000", "020420" ], + "020031" : [ "00:31", "800000", "020420" ], + "020032" : [ "00:32", "800000", "020420" ], + "020033" : [ "00:33", "800000", "020420" ], + "020034" : [ "00:34", "800000", "020420" ], + "020035" : [ "00:35", "800000", "020420" ], + "020036" : [ "00:36", "800000", "020420" ], + "020037" : [ "00:37", "800000", "020420" ], + "020038" : [ "00:38", "800000", "020420" ], + "020039" : [ "00:39", "800000", "020420" ], + "020040" : [ "00:40", "800000", "020420" ], + "020041" : [ "00:41", "800000", "020420" ], + "020042" : [ "00:42", "800000", "020420" ], + "020043" : [ "00:43", "800000", "020420" ], + "020044" : [ "00:44", "800000", "020420" ], + "020045" : [ "00:45", "800000", "020420" ], + "020046" : [ "00:46", "800000", "020420" ], + "020047" : [ "00:47", "800000", "020420" ], + "020048" : [ "00:48", "800000", "020420" ], + "020049" : [ "00:49", "800000", "020420" ], + "020050" : [ "00:50", "800000", "020420" ], + "020051" : [ "00:51", "800000", "020420" ], + "020052" : [ "00:52", "800000", "020420" ], + "020053" : [ "00:53", "800000", "020420" ], + "020054" : [ "00:54", "800000", "020420" ], + "020055" : [ "00:55", "800000", "020420" ], + "020056" : [ "00:56", "800000", "020420" ], + "020057" : [ "00:57", "800000", "020420" ], + "020058" : [ "00:58", "800000", "020420" ], + "020059" : [ "00:59", "800000", "020420" ], + "020060" : [ "01:00", "800000", "020420" ], + "020061" : [ "01:01", "800000", "020420" ], + "020062" : [ "01:02", "800000", "020420" ], + "020063" : [ "01:03", "800000", "020420" ], + "020064" : [ "01:04", "800000", "020420" ], + "020065" : [ "01:05", "800000", "020420" ], + "020066" : [ "01:06", "800000", "020420" ], + "020067" : [ "01:07", "800000", "020420" ], + "020068" : [ "01:08", "800000", "020420" ], + "020069" : [ "01:09", "800000", "020420" ], + "020070" : [ "01:10", "800000", "020420" ], + "020071" : [ "01:11", "800000", "020420" ], + "020072" : [ "01:12", "800000", "020420" ], + "020073" : [ "01:13", "800000", "020420" ], + "020074" : [ "01:14", "800000", "020420" ], + "020075" : [ "01:15", "800000", "020420" ], + "020076" : [ "01:16", "800000", "020420" ], + "020077" : [ "01:17", "800000", "020420" ], + "020078" : [ "01:18", "800000", "020420" ], + "020079" : [ "01:19", "800000", "020420" ], + "020080" : [ "01:20", "800000", "020420" ], + "020081" : [ "01:21", "800000", "020420" ], + "020082" : [ "01:22", "800000", "020420" ], + "020083" : [ "01:23", "800000", "020420" ], + "020084" : [ "01:24", "800000", "020420" ], + "020085" : [ "01:25", "800000", "020420" ], + "020086" : [ "01:26", "800000", "020420" ], + "020087" : [ "01:27", "800000", "020420" ], + "020088" : [ "01:28", "800000", "020420" ], + "020089" : [ "01:29", "800000", "020420" ], + "020090" : [ "01:30", "800000", "020420" ], + "020091" : [ "01:31", "800000", "020420" ], + "020092" : [ "01:32", "800000", "020420" ], + "020093" : [ "01:33", "800000", "020420" ], + "020094" : [ "01:34", "800000", "020420" ], + "020095" : [ "01:35", "800000", "020420" ], + "020096" : [ "01:36", "800000", "020420" ], + "020097" : [ "01:37", "800000", "020420" ], + "020098" : [ "01:38", "800000", "020420" ], + "020099" : [ "01:39", "800000", "020420" ], + "020100" : [ "01:40", "800000", "020420" ], + "020101" : [ "01:41", "800000", "020420" ], + "020102" : [ "01:42", "800000", "020420" ], + "020103" : [ "01:43", "800000", "020420" ], + "020104" : [ "01:44", "800000", "020420" ], + "020105" : [ "01:45", "800000", "020420" ], + "020106" : [ "01:46", "800000", "020420" ], + "020107" : [ "01:47", "800000", "020420" ], + "020108" : [ "01:48", "800000", "020420" ], + "020109" : [ "01:49", "800000", "020420" ], + "020110" : [ "01:50", "800000", "020420" ], + "020111" : [ "01:51", "800000", "020420" ], + "020112" : [ "01:52", "800000", "020420" ], + "020113" : [ "01:53", "800000", "020420" ], + "020114" : [ "01:54", "800000", "020420" ], + "020115" : [ "01:55", "800000", "020420" ], + "020116" : [ "01:56", "800000", "020420" ], + "020117" : [ "01:57", "800000", "020420" ], + "020118" : [ "01:58", "800000", "020420" ], + "020119" : [ "01:59", "800000", "020420" ], + "020120" : [ "02:00", "800000", "020420" ], + "020121" : [ "02:01", "800000", "020420" ], + "020122" : [ "02:02", "800000", "020420" ], + "020123" : [ "02:03", "800000", "020420" ], + "020124" : [ "02:04", "800000", "020420" ], + "020125" : [ "02:05", "800000", "020420" ], + "020126" : [ "02:06", "800000", "020420" ], + "020127" : [ "02:07", "800000", "020420" ], + "020128" : [ "02:08", "800000", "020420" ], + "020129" : [ "02:09", "800000", "020420" ], + "020130" : [ "02:10", "800000", "020420" ], + "020131" : [ "02:11", "800000", "020420" ], + "020132" : [ "02:12", "800000", "020420" ], + "020133" : [ "02:13", "800000", "020420" ], + "020134" : [ "02:14", "800000", "020420" ], + "020135" : [ "02:15", "800000", "020420" ], + "020136" : [ "02:16", "800000", "020420" ], + "020137" : [ "02:17", "800000", "020420" ], + "020138" : [ "02:18", "800000", "020420" ], + "020139" : [ "02:19", "800000", "020420" ], + "020140" : [ "02:20", "800000", "020420" ], + "020141" : [ "02:21", "800000", "020420" ], + "020142" : [ "02:22", "800000", "020420" ], + "020143" : [ "02:23", "800000", "020420" ], + "020144" : [ "02:24", "800000", "020420" ], + "020145" : [ "02:25", "800000", "020420" ], + "020146" : [ "02:26", "800000", "020420" ], + "020147" : [ "02:27", "800000", "020420" ], + "020148" : [ "02:28", "800000", "020420" ], + "020149" : [ "02:29", "800000", "020420" ], + "020150" : [ "02:30", "800000", "020420" ], + "020151" : [ "02:31", "800000", "020420" ], + "020152" : [ "02:32", "800000", "020420" ], + "020153" : [ "02:33", "800000", "020420" ], + "020154" : [ "02:34", "800000", "020420" ], + "020155" : [ "02:35", "800000", "020420" ], + "020156" : [ "02:36", "800000", "020420" ], + "020157" : [ "02:37", "800000", "020420" ], + "020158" : [ "02:38", "800000", "020420" ], + "020159" : [ "02:39", "800000", "020420" ], + "020160" : [ "02:40", "800000", "020420" ], + "020161" : [ "02:41", "800000", "020420" ], + "020162" : [ "02:42", "800000", "020420" ], + "020163" : [ "02:43", "800000", "020420" ], + "020164" : [ "02:44", "800000", "020420" ], + "020165" : [ "02:45", "800000", "020420" ], + "020166" : [ "02:46", "800000", "020420" ], + "020167" : [ "02:47", "800000", "020420" ], + "020168" : [ "02:48", "800000", "020420" ], + "020169" : [ "02:49", "800000", "020420" ], + "020170" : [ "02:50", "800000", "020420" ], + "020171" : [ "02:51", "800000", "020420" ], + "020172" : [ "02:52", "800000", "020420" ], + "020173" : [ "02:53", "800000", "020420" ], + "020174" : [ "02:54", "800000", "020420" ], + "020175" : [ "02:55", "800000", "020420" ], + "020176" : [ "02:56", "800000", "020420" ], + "020177" : [ "02:57", "800000", "020420" ], + "020178" : [ "02:58", "800000", "020420" ], + "020179" : [ "02:59", "800000", "020420" ], + "020180" : [ "03:00", "800000", "020420" ], + "020181" : [ "03:01", "800000", "020420" ], + "020182" : [ "03:02", "800000", "020420" ], + "020183" : [ "03:03", "800000", "020420" ], + "020184" : [ "03:04", "800000", "020420" ], + "020185" : [ "03:05", "800000", "020420" ], + "020186" : [ "03:06", "800000", "020420" ], + "020187" : [ "03:07", "800000", "020420" ], + "020188" : [ "03:08", "800000", "020420" ], + "020189" : [ "03:09", "800000", "020420" ], + "020190" : [ "03:10", "800000", "020420" ], + "020191" : [ "03:11", "800000", "020420" ], + "020192" : [ "03:12", "800000", "020420" ], + "020193" : [ "03:13", "800000", "020420" ], + "020194" : [ "03:14", "800000", "020420" ], + "020195" : [ "03:15", "800000", "020420" ], + "020196" : [ "03:16", "800000", "020420" ], + "020197" : [ "03:17", "800000", "020420" ], + "020198" : [ "03:18", "800000", "020420" ], + "020199" : [ "03:19", "800000", "020420" ], + "020200" : [ "03:20", "800000", "020420" ], + "020201" : [ "03:21", "800000", "020420" ], + "020202" : [ "03:22", "800000", "020420" ], + "020203" : [ "03:23", "800000", "020420" ], + "020204" : [ "03:24", "800000", "020420" ], + "020205" : [ "03:25", "800000", "020420" ], + "020206" : [ "03:26", "800000", "020420" ], + "020207" : [ "03:27", "800000", "020420" ], + "020208" : [ "03:28", "800000", "020420" ], + "020209" : [ "03:29", "800000", "020420" ], + "020210" : [ "03:30", "800000", "020420" ], + "020211" : [ "03:31", "800000", "020420" ], + "020212" : [ "03:32", "800000", "020420" ], + "020213" : [ "03:33", "800000", "020420" ], + "020214" : [ "03:34", "800000", "020420" ], + "020215" : [ "03:35", "800000", "020420" ], + "020216" : [ "03:36", "800000", "020420" ], + "020217" : [ "03:37", "800000", "020420" ], + "020218" : [ "03:38", "800000", "020420" ], + "020219" : [ "03:39", "800000", "020420" ], + "020220" : [ "03:40", "800000", "020420" ], + "020221" : [ "03:41", "800000", "020420" ], + "020222" : [ "03:42", "800000", "020420" ], + "020223" : [ "03:43", "800000", "020420" ], + "020224" : [ "03:44", "800000", "020420" ], + "020225" : [ "03:45", "800000", "020420" ], + "020226" : [ "03:46", "800000", "020420" ], + "020227" : [ "03:47", "800000", "020420" ], + "020228" : [ "03:48", "800000", "020420" ], + "020229" : [ "03:49", "800000", "020420" ], + "020230" : [ "03:50", "800000", "020420" ], + "020231" : [ "03:51", "800000", "020420" ], + "020232" : [ "03:52", "800000", "020420" ], + "020233" : [ "03:53", "800000", "020420" ], + "020234" : [ "03:54", "800000", "020420" ], + "020235" : [ "03:55", "800000", "020420" ], + "020236" : [ "03:56", "800000", "020420" ], + "020237" : [ "03:57", "800000", "020420" ], + "020238" : [ "03:58", "800000", "020420" ], + "020239" : [ "03:59", "800000", "020420" ], + "020240" : [ "04:00", "800000", "020420" ], + "020241" : [ "04:01", "800000", "020420" ], + "020242" : [ "04:02", "800000", "020420" ], + "020243" : [ "04:03", "800000", "020420" ], + "020244" : [ "04:04", "800000", "020420" ], + "020245" : [ "04:05", "800000", "020420" ], + "020246" : [ "04:06", "800000", "020420" ], + "020247" : [ "04:07", "800000", "020420" ], + "020248" : [ "04:08", "800000", "020420" ], + "020249" : [ "04:09", "800000", "020420" ], + "020250" : [ "04:10", "800000", "020420" ], + "020251" : [ "04:11", "800000", "020420" ], + "020252" : [ "04:12", "800000", "020420" ], + "020253" : [ "04:13", "800000", "020420" ], + "020254" : [ "04:14", "800000", "020420" ], + "020255" : [ "04:15", "800000", "020420" ], + "020256" : [ "04:16", "800000", "020420" ], + "020257" : [ "04:17", "800000", "020420" ], + "020258" : [ "04:18", "800000", "020420" ], + "020259" : [ "04:19", "800000", "020420" ], + "020260" : [ "04:20", "800000", "020420" ], + "020261" : [ "04:21", "800000", "020420" ], + "020262" : [ "04:22", "800000", "020420" ], + "020263" : [ "04:23", "800000", "020420" ], + "020264" : [ "04:24", "800000", "020420" ], + "020265" : [ "04:25", "800000", "020420" ], + "020266" : [ "04:26", "800000", "020420" ], + "020267" : [ "04:27", "800000", "020420" ], + "020268" : [ "04:28", "800000", "020420" ], + "020269" : [ "04:29", "800000", "020420" ], + "020270" : [ "04:30", "800000", "020420" ], + "020271" : [ "04:31", "800000", "020420" ], + "020272" : [ "04:32", "800000", "020420" ], + "020273" : [ "04:33", "800000", "020420" ], + "020274" : [ "04:34", "800000", "020420" ], + "020275" : [ "04:35", "800000", "020420" ], + "020276" : [ "04:36", "800000", "020420" ], + "020277" : [ "04:37", "800000", "020420" ], + "020278" : [ "04:38", "800000", "020420" ], + "020279" : [ "04:39", "800000", "020420" ], + "020280" : [ "04:40", "800000", "020420" ], + "020281" : [ "04:41", "800000", "020420" ], + "020282" : [ "04:42", "800000", "020420" ], + "020283" : [ "04:43", "800000", "020420" ], + "020284" : [ "04:44", "800000", "020420" ], + "020285" : [ "04:45", "800000", "020420" ], + "020286" : [ "04:46", "800000", "020420" ], + "020287" : [ "04:47", "800000", "020420" ], + "020288" : [ "04:48", "800000", "020420" ], + "020289" : [ "04:49", "800000", "020420" ], + "020290" : [ "04:50", "800000", "020420" ], + "020291" : [ "04:51", "800000", "020420" ], + "020292" : [ "04:52", "800000", "020420" ], + "020293" : [ "04:53", "800000", "020420" ], + "020294" : [ "04:54", "800000", "020420" ], + "020295" : [ "04:55", "800000", "020420" ], + "020296" : [ "04:56", "800000", "020420" ], + "020297" : [ "04:57", "800000", "020420" ], + "020298" : [ "04:58", "800000", "020420" ], + "020299" : [ "04:59", "800000", "020420" ], + "020300" : [ "05:00", "800000", "020420" ], + "020301" : [ "05:01", "800000", "020420" ], + "020302" : [ "05:02", "800000", "020420" ], + "020303" : [ "05:03", "800000", "020420" ], + "020304" : [ "05:04", "800000", "020420" ], + "020305" : [ "05:05", "800000", "020420" ], + "020306" : [ "05:06", "800000", "020420" ], + "020307" : [ "05:07", "800000", "020420" ], + "020308" : [ "05:08", "800000", "020420" ], + "020309" : [ "05:09", "800000", "020420" ], + "020310" : [ "05:10", "800000", "020420" ], + "020311" : [ "05:11", "800000", "020420" ], + "020312" : [ "05:12", "800000", "020420" ], + "020313" : [ "05:13", "800000", "020420" ], + "020314" : [ "05:14", "800000", "020420" ], + "020315" : [ "05:15", "800000", "020420" ], + "020316" : [ "05:16", "800000", "020420" ], + "020317" : [ "05:17", "800000", "020420" ], + "020318" : [ "05:18", "800000", "020420" ], + "020319" : [ "05:19", "800000", "020420" ], + "020320" : [ "05:20", "800000", "020420" ], + "020321" : [ "05:21", "800000", "020420" ], + "020322" : [ "05:22", "800000", "020420" ], + "020323" : [ "05:23", "800000", "020420" ], + "020324" : [ "05:24", "800000", "020420" ], + "020325" : [ "05:25", "800000", "020420" ], + "020326" : [ "05:26", "800000", "020420" ], + "020327" : [ "05:27", "800000", "020420" ], + "020328" : [ "05:28", "800000", "020420" ], + "020329" : [ "05:29", "800000", "020420" ], + "020330" : [ "05:30", "800000", "020420" ], + "020331" : [ "05:31", "800000", "020420" ], + "020332" : [ "05:32", "800000", "020420" ], + "020333" : [ "05:33", "800000", "020420" ], + "020334" : [ "05:34", "800000", "020420" ], + "020335" : [ "05:35", "800000", "020420" ], + "020336" : [ "05:36", "800000", "020420" ], + "020337" : [ "05:37", "800000", "020420" ], + "020338" : [ "05:38", "800000", "020420" ], + "020339" : [ "05:39", "800000", "020420" ], + "020340" : [ "05:40", "800000", "020420" ], + "020341" : [ "05:41", "800000", "020420" ], + "020342" : [ "05:42", "800000", "020420" ], + "020343" : [ "05:43", "800000", "020420" ], + "020344" : [ "05:44", "800000", "020420" ], + "020345" : [ "05:45", "800000", "020420" ], + "020346" : [ "05:46", "800000", "020420" ], + "020347" : [ "05:47", "800000", "020420" ], + "020348" : [ "05:48", "800000", "020420" ], + "020349" : [ "05:49", "800000", "020420" ], + "020350" : [ "05:50", "800000", "020420" ], + "020351" : [ "05:51", "800000", "020420" ], + "020352" : [ "05:52", "800000", "020420" ], + "020353" : [ "05:53", "800000", "020420" ], + "020354" : [ "05:54", "800000", "020420" ], + "020355" : [ "05:55", "800000", "020420" ], + "020356" : [ "05:56", "800000", "020420" ], + "020357" : [ "05:57", "800000", "020420" ], + "020358" : [ "05:58", "800000", "020420" ], + "020359" : [ "05:59", "800000", "020420" ], + "020360" : [ "06:00", "800000", "020420" ], + "020361" : [ "06:01", "800000", "020420" ], + "020362" : [ "06:02", "800000", "020420" ], + "020363" : [ "06:03", "800000", "020420" ], + "020364" : [ "06:04", "800000", "020420" ], + "020365" : [ "06:05", "800000", "020420" ], + "020366" : [ "06:06", "800000", "020420" ], + "020367" : [ "06:07", "800000", "020420" ], + "020368" : [ "06:08", "800000", "020420" ], + "020369" : [ "06:09", "800000", "020420" ], + "020370" : [ "06:10", "800000", "020420" ], + "020371" : [ "06:11", "800000", "020420" ], + "020372" : [ "06:12", "800000", "020420" ], + "020373" : [ "06:13", "800000", "020420" ], + "020374" : [ "06:14", "800000", "020420" ], + "020375" : [ "06:15", "800000", "020420" ], + "020376" : [ "06:16", "800000", "020420" ], + "020377" : [ "06:17", "800000", "020420" ], + "020378" : [ "06:18", "800000", "020420" ], + "020379" : [ "06:19", "800000", "020420" ], + "020380" : [ "06:20", "800000", "020420" ], + "020381" : [ "06:21", "800000", "020420" ], + "020382" : [ "06:22", "800000", "020420" ], + "020383" : [ "06:23", "800000", "020420" ], + "020384" : [ "06:24", "800000", "020420" ], + "020385" : [ "06:25", "800000", "020420" ], + "020386" : [ "06:26", "800000", "020420" ], + "020387" : [ "06:27", "800000", "020420" ], + "020388" : [ "06:28", "800000", "020420" ], + "020389" : [ "06:29", "800000", "020420" ], + "020390" : [ "06:30", "800000", "020420" ], + "020391" : [ "06:31", "800000", "020420" ], + "020392" : [ "06:32", "800000", "020420" ], + "020393" : [ "06:33", "800000", "020420" ], + "020394" : [ "06:34", "800000", "020420" ], + "020395" : [ "06:35", "800000", "020420" ], + "020396" : [ "06:36", "800000", "020420" ], + "020397" : [ "06:37", "800000", "020420" ], + "020398" : [ "06:38", "800000", "020420" ], + "020399" : [ "06:39", "800000", "020420" ], + "020400" : [ "06:40", "800000", "020420" ], + "020401" : [ "06:41", "800000", "020420" ], + "020402" : [ "06:42", "800000", "020420" ], + "020403" : [ "06:43", "800000", "020420" ], + "020404" : [ "06:44", "800000", "020420" ], + "020405" : [ "06:45", "800000", "020420" ], + "020406" : [ "06:46", "800000", "020420" ], + "020407" : [ "06:47", "800000", "020420" ], + "020408" : [ "06:48", "800000", "020420" ], + "020409" : [ "06:49", "800000", "020420" ], + "020410" : [ "06:50", "800000", "020420" ], + "020411" : [ "06:51", "800000", "020420" ], + "020412" : [ "06:52", "800000", "020420" ], + "020413" : [ "06:53", "800000", "020420" ], + "020414" : [ "06:54", "800000", "020420" ], + "020415" : [ "06:55", "800000", "020420" ], + "020416" : [ "06:56", "800000", "020420" ], + "020417" : [ "06:57", "800000", "020420" ], + "020418" : [ "06:58", "800000", "020420" ], + "020419" : [ "06:59", "800000", "020420" ], + "020420" : [ "07:00", "350000", "020480" ], + "020421" : [ "07:01", "350000", "020481" ], + "020422" : [ "07:02", "350000", "020482" ], + "020423" : [ "07:03", "350000", "020483" ], + "020424" : [ "07:04", "350000", "020484" ], + "020425" : [ "07:05", "350000", "020485" ], + "020426" : [ "07:06", "350000", "020486" ], + "020427" : [ "07:07", "350000", "020487" ], + "020428" : [ "07:08", "350000", "020488" ], + "020429" : [ "07:09", "350000", "020489" ], + "020430" : [ "07:10", "350000", "020490" ], + "020431" : [ "07:11", "350000", "020491" ], + "020432" : [ "07:12", "350000", "020492" ], + "020433" : [ "07:13", "350000", "020493" ], + "020434" : [ "07:14", "350000", "020494" ], + "020435" : [ "07:15", "350000", "020495" ], + "020436" : [ "07:16", "350000", "020496" ], + "020437" : [ "07:17", "350000", "020497" ], + "020438" : [ "07:18", "350000", "020498" ], + "020439" : [ "07:19", "350000", "020499" ], + "020440" : [ "07:20", "350000", "020500" ], + "020441" : [ "07:21", "350000", "020501" ], + "020442" : [ "07:22", "350000", "020502" ], + "020443" : [ "07:23", "350000", "020503" ], + "020444" : [ "07:24", "350000", "020504" ], + "020445" : [ "07:25", "350000", "020505" ], + "020446" : [ "07:26", "350000", "020506" ], + "020447" : [ "07:27", "350000", "020507" ], + "020448" : [ "07:28", "350000", "020508" ], + "020449" : [ "07:29", "350000", "020509" ], + "020450" : [ "07:30", "350000", "020510" ], + "020451" : [ "07:31", "350000", "020511" ], + "020452" : [ "07:32", "350000", "020512" ], + "020453" : [ "07:33", "350000", "020513" ], + "020454" : [ "07:34", "350000", "020514" ], + "020455" : [ "07:35", "350000", "020515" ], + "020456" : [ "07:36", "350000", "020516" ], + "020457" : [ "07:37", "350000", "020517" ], + "020458" : [ "07:38", "350000", "020518" ], + "020459" : [ "07:39", "350000", "020519" ], + "020460" : [ "07:40", "350000", "020520" ], + "020461" : [ "07:41", "350000", "020521" ], + "020462" : [ "07:42", "350000", "020522" ], + "020463" : [ "07:43", "350000", "020523" ], + "020464" : [ "07:44", "350000", "020524" ], + "020465" : [ "07:45", "350000", "020525" ], + "020466" : [ "07:46", "350000", "020526" ], + "020467" : [ "07:47", "350000", "020527" ], + "020468" : [ "07:48", "350000", "020528" ], + "020469" : [ "07:49", "350000", "020529" ], + "020470" : [ "07:50", "350000", "020530" ], + "020471" : [ "07:51", "350000", "020531" ], + "020472" : [ "07:52", "350000", "020532" ], + "020473" : [ "07:53", "350000", "020533" ], + "020474" : [ "07:54", "350000", "020534" ], + "020475" : [ "07:55", "350000", "020535" ], + "020476" : [ "07:56", "350000", "020536" ], + "020477" : [ "07:57", "350000", "020537" ], + "020478" : [ "07:58", "350000", "020538" ], + "020479" : [ "07:59", "350000", "020539" ], + "020480" : [ "08:00", "350000", "020540" ], + "020481" : [ "08:01", "350000", "020541" ], + "020482" : [ "08:02", "350000", "020542" ], + "020483" : [ "08:03", "350000", "020543" ], + "020484" : [ "08:04", "350000", "020544" ], + "020485" : [ "08:05", "350000", "020545" ], + "020486" : [ "08:06", "350000", "020546" ], + "020487" : [ "08:07", "350000", "020547" ], + "020488" : [ "08:08", "350000", "020548" ], + "020489" : [ "08:09", "350000", "020549" ], + "020490" : [ "08:10", "350000", "020550" ], + "020491" : [ "08:11", "350000", "020551" ], + "020492" : [ "08:12", "350000", "020552" ], + "020493" : [ "08:13", "350000", "020553" ], + "020494" : [ "08:14", "350000", "020554" ], + "020495" : [ "08:15", "350000", "020555" ], + "020496" : [ "08:16", "350000", "020556" ], + "020497" : [ "08:17", "350000", "020557" ], + "020498" : [ "08:18", "350000", "020558" ], + "020499" : [ "08:19", "350000", "020559" ], + "020500" : [ "08:20", "350000", "020560" ], + "020501" : [ "08:21", "350000", "020561" ], + "020502" : [ "08:22", "350000", "020562" ], + "020503" : [ "08:23", "350000", "020563" ], + "020504" : [ "08:24", "350000", "020564" ], + "020505" : [ "08:25", "350000", "020565" ], + "020506" : [ "08:26", "350000", "020566" ], + "020507" : [ "08:27", "350000", "020567" ], + "020508" : [ "08:28", "350000", "020568" ], + "020509" : [ "08:29", "350000", "020569" ], + "020510" : [ "08:30", "350000", "020570" ], + "020511" : [ "08:31", "350000", "020571" ], + "020512" : [ "08:32", "350000", "020572" ], + "020513" : [ "08:33", "350000", "020573" ], + "020514" : [ "08:34", "350000", "020574" ], + "020515" : [ "08:35", "350000", "020575" ], + "020516" : [ "08:36", "350000", "020576" ], + "020517" : [ "08:37", "350000", "020577" ], + "020518" : [ "08:38", "350000", "020578" ], + "020519" : [ "08:39", "350000", "020579" ], + "020520" : [ "08:40", "350000", "020580" ], + "020521" : [ "08:41", "350000", "020581" ], + "020522" : [ "08:42", "350000", "020582" ], + "020523" : [ "08:43", "350000", "020583" ], + "020524" : [ "08:44", "350000", "020584" ], + "020525" : [ "08:45", "350000", "020585" ], + "020526" : [ "08:46", "350000", "020586" ], + "020527" : [ "08:47", "350000", "020587" ], + "020528" : [ "08:48", "350000", "020588" ], + "020529" : [ "08:49", "350000", "020589" ], + "020530" : [ "08:50", "350000", "020590" ], + "020531" : [ "08:51", "350000", "020591" ], + "020532" : [ "08:52", "350000", "020592" ], + "020533" : [ "08:53", "350000", "020593" ], + "020534" : [ "08:54", "350000", "020594" ], + "020535" : [ "08:55", "350000", "020595" ], + "020536" : [ "08:56", "350000", "020596" ], + "020537" : [ "08:57", "350000", "020597" ], + "020538" : [ "08:58", "350000", "020598" ], + "020539" : [ "08:59", "350000", "020599" ], + "020540" : [ "09:00", "350000", "020600" ], + "020541" : [ "09:01", "350000", "020601" ], + "020542" : [ "09:02", "350000", "020602" ], + "020543" : [ "09:03", "350000", "020603" ], + "020544" : [ "09:04", "350000", "020604" ], + "020545" : [ "09:05", "350000", "020605" ], + "020546" : [ "09:06", "350000", "020606" ], + "020547" : [ "09:07", "350000", "020607" ], + "020548" : [ "09:08", "350000", "020608" ], + "020549" : [ "09:09", "350000", "020609" ], + "020550" : [ "09:10", "350000", "020610" ], + "020551" : [ "09:11", "350000", "020611" ], + "020552" : [ "09:12", "350000", "020612" ], + "020553" : [ "09:13", "350000", "020613" ], + "020554" : [ "09:14", "350000", "020614" ], + "020555" : [ "09:15", "350000", "020615" ], + "020556" : [ "09:16", "350000", "020616" ], + "020557" : [ "09:17", "350000", "020617" ], + "020558" : [ "09:18", "350000", "020618" ], + "020559" : [ "09:19", "350000", "020619" ], + "020560" : [ "09:20", "350000", "020620" ], + "020561" : [ "09:21", "350000", "020621" ], + "020562" : [ "09:22", "350000", "020622" ], + "020563" : [ "09:23", "350000", "020623" ], + "020564" : [ "09:24", "350000", "020624" ], + "020565" : [ "09:25", "350000", "020625" ], + "020566" : [ "09:26", "350000", "020626" ], + "020567" : [ "09:27", "350000", "020627" ], + "020568" : [ "09:28", "350000", "020628" ], + "020569" : [ "09:29", "350000", "020629" ], + "020570" : [ "09:30", "350000", "020630" ], + "020571" : [ "09:31", "350000", "020631" ], + "020572" : [ "09:32", "350000", "020632" ], + "020573" : [ "09:33", "350000", "020633" ], + "020574" : [ "09:34", "350000", "020634" ], + "020575" : [ "09:35", "350000", "020635" ], + "020576" : [ "09:36", "350000", "020636" ], + "020577" : [ "09:37", "350000", "020637" ], + "020578" : [ "09:38", "350000", "020638" ], + "020579" : [ "09:39", "350000", "020639" ], + "020580" : [ "09:40", "350000", "020640" ], + "020581" : [ "09:41", "350000", "020641" ], + "020582" : [ "09:42", "350000", "020642" ], + "020583" : [ "09:43", "350000", "020643" ], + "020584" : [ "09:44", "350000", "020644" ], + "020585" : [ "09:45", "350000", "020645" ], + "020586" : [ "09:46", "350000", "020646" ], + "020587" : [ "09:47", "350000", "020647" ], + "020588" : [ "09:48", "350000", "020648" ], + "020589" : [ "09:49", "350000", "020649" ], + "020590" : [ "09:50", "350000", "020650" ], + "020591" : [ "09:51", "350000", "020651" ], + "020592" : [ "09:52", "350000", "020652" ], + "020593" : [ "09:53", "350000", "020653" ], + "020594" : [ "09:54", "350000", "020654" ], + "020595" : [ "09:55", "350000", "020655" ], + "020596" : [ "09:56", "350000", "020656" ], + "020597" : [ "09:57", "350000", "020657" ], + "020598" : [ "09:58", "350000", "020658" ], + "020599" : [ "09:59", "350000", "020659" ], + "020600" : [ "10:00", "350000", "020660" ], + "020601" : [ "10:01", "350000", "020661" ], + "020602" : [ "10:02", "350000", "020662" ], + "020603" : [ "10:03", "350000", "020663" ], + "020604" : [ "10:04", "350000", "020664" ], + "020605" : [ "10:05", "350000", "020665" ], + "020606" : [ "10:06", "350000", "020666" ], + "020607" : [ "10:07", "350000", "020667" ], + "020608" : [ "10:08", "350000", "020668" ], + "020609" : [ "10:09", "350000", "020669" ], + "020610" : [ "10:10", "350000", "020670" ], + "020611" : [ "10:11", "350000", "020671" ], + "020612" : [ "10:12", "350000", "020672" ], + "020613" : [ "10:13", "350000", "020673" ], + "020614" : [ "10:14", "350000", "020674" ], + "020615" : [ "10:15", "350000", "020675" ], + "020616" : [ "10:16", "350000", "020676" ], + "020617" : [ "10:17", "350000", "020677" ], + "020618" : [ "10:18", "350000", "020678" ], + "020619" : [ "10:19", "350000", "020679" ], + "020620" : [ "10:20", "350000", "020680" ], + "020621" : [ "10:21", "350000", "020681" ], + "020622" : [ "10:22", "350000", "020682" ], + "020623" : [ "10:23", "350000", "020683" ], + "020624" : [ "10:24", "350000", "020684" ], + "020625" : [ "10:25", "350000", "020685" ], + "020626" : [ "10:26", "350000", "020686" ], + "020627" : [ "10:27", "350000", "020687" ], + "020628" : [ "10:28", "350000", "020688" ], + "020629" : [ "10:29", "350000", "020689" ], + "020630" : [ "10:30", "350000", "020690" ], + "020631" : [ "10:31", "350000", "020691" ], + "020632" : [ "10:32", "350000", "020692" ], + "020633" : [ "10:33", "350000", "020693" ], + "020634" : [ "10:34", "350000", "020694" ], + "020635" : [ "10:35", "350000", "020695" ], + "020636" : [ "10:36", "350000", "020696" ], + "020637" : [ "10:37", "350000", "020697" ], + "020638" : [ "10:38", "350000", "020698" ], + "020639" : [ "10:39", "350000", "020699" ], + "020640" : [ "10:40", "350000", "020700" ], + "020641" : [ "10:41", "350000", "020701" ], + "020642" : [ "10:42", "350000", "020702" ], + "020643" : [ "10:43", "350000", "020703" ], + "020644" : [ "10:44", "350000", "020704" ], + "020645" : [ "10:45", "350000", "020705" ], + "020646" : [ "10:46", "350000", "020706" ], + "020647" : [ "10:47", "350000", "020707" ], + "020648" : [ "10:48", "350000", "020708" ], + "020649" : [ "10:49", "350000", "020709" ], + "020650" : [ "10:50", "350000", "020710" ], + "020651" : [ "10:51", "350000", "020711" ], + "020652" : [ "10:52", "350000", "020712" ], + "020653" : [ "10:53", "350000", "020713" ], + "020654" : [ "10:54", "350000", "020714" ], + "020655" : [ "10:55", "350000", "020715" ], + "020656" : [ "10:56", "350000", "020716" ], + "020657" : [ "10:57", "350000", "020717" ], + "020658" : [ "10:58", "350000", "020718" ], + "020659" : [ "10:59", "350000", "020719" ], + "020660" : [ "11:00", "350000", "020720" ], + "020661" : [ "11:01", "350000", "020721" ], + "020662" : [ "11:02", "350000", "020722" ], + "020663" : [ "11:03", "350000", "020723" ], + "020664" : [ "11:04", "350000", "020724" ], + "020665" : [ "11:05", "350000", "020725" ], + "020666" : [ "11:06", "350000", "020726" ], + "020667" : [ "11:07", "350000", "020727" ], + "020668" : [ "11:08", "350000", "020728" ], + "020669" : [ "11:09", "350000", "020729" ], + "020670" : [ "11:10", "350000", "020730" ], + "020671" : [ "11:11", "350000", "020731" ], + "020672" : [ "11:12", "350000", "020732" ], + "020673" : [ "11:13", "350000", "020733" ], + "020674" : [ "11:14", "350000", "020734" ], + "020675" : [ "11:15", "350000", "020735" ], + "020676" : [ "11:16", "350000", "020736" ], + "020677" : [ "11:17", "350000", "020737" ], + "020678" : [ "11:18", "350000", "020738" ], + "020679" : [ "11:19", "350000", "020739" ], + "020680" : [ "11:20", "350000", "020740" ], + "020681" : [ "11:21", "350000", "020741" ], + "020682" : [ "11:22", "350000", "020742" ], + "020683" : [ "11:23", "350000", "020743" ], + "020684" : [ "11:24", "350000", "020744" ], + "020685" : [ "11:25", "350000", "020745" ], + "020686" : [ "11:26", "350000", "020746" ], + "020687" : [ "11:27", "350000", "020747" ], + "020688" : [ "11:28", "350000", "020748" ], + "020689" : [ "11:29", "350000", "020749" ], + "020690" : [ "11:30", "350000", "020750" ], + "020691" : [ "11:31", "350000", "020751" ], + "020692" : [ "11:32", "350000", "020752" ], + "020693" : [ "11:33", "350000", "020753" ], + "020694" : [ "11:34", "350000", "020754" ], + "020695" : [ "11:35", "350000", "020755" ], + "020696" : [ "11:36", "350000", "020756" ], + "020697" : [ "11:37", "350000", "020757" ], + "020698" : [ "11:38", "350000", "020758" ], + "020699" : [ "11:39", "350000", "020759" ], + "020700" : [ "11:40", "350000", "020760" ], + "020701" : [ "11:41", "350000", "020761" ], + "020702" : [ "11:42", "350000", "020762" ], + "020703" : [ "11:43", "350000", "020763" ], + "020704" : [ "11:44", "350000", "020764" ], + "020705" : [ "11:45", "350000", "020765" ], + "020706" : [ "11:46", "350000", "020766" ], + "020707" : [ "11:47", "350000", "020767" ], + "020708" : [ "11:48", "350000", "020768" ], + "020709" : [ "11:49", "350000", "020769" ], + "020710" : [ "11:50", "350000", "020770" ], + "020711" : [ "11:51", "350000", "020771" ], + "020712" : [ "11:52", "350000", "020772" ], + "020713" : [ "11:53", "350000", "020773" ], + "020714" : [ "11:54", "350000", "020774" ], + "020715" : [ "11:55", "350000", "020775" ], + "020716" : [ "11:56", "350000", "020776" ], + "020717" : [ "11:57", "350000", "020777" ], + "020718" : [ "11:58", "350000", "020778" ], + "020719" : [ "11:59", "350000", "020779" ], + "020720" : [ "12:00", "350000", "020780" ], + "020721" : [ "12:01", "350000", "020781" ], + "020722" : [ "12:02", "350000", "020782" ], + "020723" : [ "12:03", "350000", "020783" ], + "020724" : [ "12:04", "350000", "020784" ], + "020725" : [ "12:05", "350000", "020785" ], + "020726" : [ "12:06", "350000", "020786" ], + "020727" : [ "12:07", "350000", "020787" ], + "020728" : [ "12:08", "350000", "020788" ], + "020729" : [ "12:09", "350000", "020789" ], + "020730" : [ "12:10", "350000", "020790" ], + "020731" : [ "12:11", "350000", "020791" ], + "020732" : [ "12:12", "350000", "020792" ], + "020733" : [ "12:13", "350000", "020793" ], + "020734" : [ "12:14", "350000", "020794" ], + "020735" : [ "12:15", "350000", "020795" ], + "020736" : [ "12:16", "350000", "020796" ], + "020737" : [ "12:17", "350000", "020797" ], + "020738" : [ "12:18", "350000", "020798" ], + "020739" : [ "12:19", "350000", "020799" ], + "020740" : [ "12:20", "350000", "020800" ], + "020741" : [ "12:21", "350000", "020801" ], + "020742" : [ "12:22", "350000", "020802" ], + "020743" : [ "12:23", "350000", "020803" ], + "020744" : [ "12:24", "350000", "020804" ], + "020745" : [ "12:25", "350000", "020805" ], + "020746" : [ "12:26", "350000", "020806" ], + "020747" : [ "12:27", "350000", "020807" ], + "020748" : [ "12:28", "350000", "020808" ], + "020749" : [ "12:29", "350000", "020809" ], + "020750" : [ "12:30", "350000", "020810" ], + "020751" : [ "12:31", "350000", "020811" ], + "020752" : [ "12:32", "350000", "020812" ], + "020753" : [ "12:33", "350000", "020813" ], + "020754" : [ "12:34", "350000", "020814" ], + "020755" : [ "12:35", "350000", "020815" ], + "020756" : [ "12:36", "350000", "020816" ], + "020757" : [ "12:37", "350000", "020817" ], + "020758" : [ "12:38", "350000", "020818" ], + "020759" : [ "12:39", "350000", "020819" ], + "020760" : [ "12:40", "350000", "020820" ], + "020761" : [ "12:41", "350000", "020821" ], + "020762" : [ "12:42", "350000", "020822" ], + "020763" : [ "12:43", "350000", "020823" ], + "020764" : [ "12:44", "350000", "020824" ], + "020765" : [ "12:45", "350000", "020825" ], + "020766" : [ "12:46", "350000", "020826" ], + "020767" : [ "12:47", "350000", "020827" ], + "020768" : [ "12:48", "350000", "020828" ], + "020769" : [ "12:49", "350000", "020829" ], + "020770" : [ "12:50", "350000", "020830" ], + "020771" : [ "12:51", "350000", "020831" ], + "020772" : [ "12:52", "350000", "020832" ], + "020773" : [ "12:53", "350000", "020833" ], + "020774" : [ "12:54", "350000", "020834" ], + "020775" : [ "12:55", "350000", "020835" ], + "020776" : [ "12:56", "350000", "020836" ], + "020777" : [ "12:57", "350000", "020837" ], + "020778" : [ "12:58", "350000", "020838" ], + "020779" : [ "12:59", "350000", "020839" ], + "020780" : [ "13:00", "350000", "020840" ], + "020781" : [ "13:01", "350000", "020841" ], + "020782" : [ "13:02", "350000", "020842" ], + "020783" : [ "13:03", "350000", "020843" ], + "020784" : [ "13:04", "350000", "020844" ], + "020785" : [ "13:05", "350000", "020845" ], + "020786" : [ "13:06", "350000", "020846" ], + "020787" : [ "13:07", "350000", "020847" ], + "020788" : [ "13:08", "350000", "020848" ], + "020789" : [ "13:09", "350000", "020849" ], + "020790" : [ "13:10", "350000", "020850" ], + "020791" : [ "13:11", "350000", "020851" ], + "020792" : [ "13:12", "350000", "020852" ], + "020793" : [ "13:13", "350000", "020853" ], + "020794" : [ "13:14", "350000", "020854" ], + "020795" : [ "13:15", "350000", "020855" ], + "020796" : [ "13:16", "350000", "020856" ], + "020797" : [ "13:17", "350000", "020857" ], + "020798" : [ "13:18", "350000", "020858" ], + "020799" : [ "13:19", "350000", "020859" ], + "020800" : [ "13:20", "350000", "020860" ], + "020801" : [ "13:21", "350000", "020861" ], + "020802" : [ "13:22", "350000", "020862" ], + "020803" : [ "13:23", "350000", "020863" ], + "020804" : [ "13:24", "350000", "020864" ], + "020805" : [ "13:25", "350000", "020865" ], + "020806" : [ "13:26", "350000", "020866" ], + "020807" : [ "13:27", "350000", "020867" ], + "020808" : [ "13:28", "350000", "020868" ], + "020809" : [ "13:29", "350000", "020869" ], + "020810" : [ "13:30", "350000", "020870" ], + "020811" : [ "13:31", "350000", "020871" ], + "020812" : [ "13:32", "350000", "020872" ], + "020813" : [ "13:33", "350000", "020873" ], + "020814" : [ "13:34", "350000", "020874" ], + "020815" : [ "13:35", "350000", "020875" ], + "020816" : [ "13:36", "350000", "020876" ], + "020817" : [ "13:37", "350000", "020877" ], + "020818" : [ "13:38", "350000", "020878" ], + "020819" : [ "13:39", "350000", "020879" ], + "020820" : [ "13:40", "350000", "020880" ], + "020821" : [ "13:41", "350000", "020881" ], + "020822" : [ "13:42", "350000", "020882" ], + "020823" : [ "13:43", "350000", "020883" ], + "020824" : [ "13:44", "350000", "020884" ], + "020825" : [ "13:45", "350000", "020885" ], + "020826" : [ "13:46", "350000", "020886" ], + "020827" : [ "13:47", "350000", "020887" ], + "020828" : [ "13:48", "350000", "020888" ], + "020829" : [ "13:49", "350000", "020889" ], + "020830" : [ "13:50", "350000", "020890" ], + "020831" : [ "13:51", "350000", "020891" ], + "020832" : [ "13:52", "350000", "020892" ], + "020833" : [ "13:53", "350000", "020893" ], + "020834" : [ "13:54", "350000", "020894" ], + "020835" : [ "13:55", "350000", "020895" ], + "020836" : [ "13:56", "350000", "020896" ], + "020837" : [ "13:57", "350000", "020897" ], + "020838" : [ "13:58", "350000", "020898" ], + "020839" : [ "13:59", "350000", "020899" ], + "020840" : [ "14:00", "350000", "020900" ], + "020841" : [ "14:01", "350000", "020901" ], + "020842" : [ "14:02", "350000", "020902" ], + "020843" : [ "14:03", "350000", "020903" ], + "020844" : [ "14:04", "350000", "020904" ], + "020845" : [ "14:05", "350000", "020905" ], + "020846" : [ "14:06", "350000", "020906" ], + "020847" : [ "14:07", "350000", "020907" ], + "020848" : [ "14:08", "350000", "020908" ], + "020849" : [ "14:09", "350000", "020909" ], + "020850" : [ "14:10", "350000", "020910" ], + "020851" : [ "14:11", "350000", "020911" ], + "020852" : [ "14:12", "350000", "020912" ], + "020853" : [ "14:13", "350000", "020913" ], + "020854" : [ "14:14", "350000", "020914" ], + "020855" : [ "14:15", "350000", "020915" ], + "020856" : [ "14:16", "350000", "020916" ], + "020857" : [ "14:17", "350000", "020917" ], + "020858" : [ "14:18", "350000", "020918" ], + "020859" : [ "14:19", "350000", "020919" ], + "020860" : [ "14:20", "350000", "020920" ], + "020861" : [ "14:21", "350000", "020921" ], + "020862" : [ "14:22", "350000", "020922" ], + "020863" : [ "14:23", "350000", "020923" ], + "020864" : [ "14:24", "350000", "020924" ], + "020865" : [ "14:25", "350000", "020925" ], + "020866" : [ "14:26", "350000", "020926" ], + "020867" : [ "14:27", "350000", "020927" ], + "020868" : [ "14:28", "350000", "020928" ], + "020869" : [ "14:29", "350000", "020929" ], + "020870" : [ "14:30", "350000", "020930" ], + "020871" : [ "14:31", "350000", "020931" ], + "020872" : [ "14:32", "350000", "020932" ], + "020873" : [ "14:33", "350000", "020933" ], + "020874" : [ "14:34", "350000", "020934" ], + "020875" : [ "14:35", "350000", "020935" ], + "020876" : [ "14:36", "350000", "020936" ], + "020877" : [ "14:37", "350000", "020937" ], + "020878" : [ "14:38", "350000", "020938" ], + "020879" : [ "14:39", "350000", "020939" ], + "020880" : [ "14:40", "350000", "020940" ], + "020881" : [ "14:41", "350000", "020941" ], + "020882" : [ "14:42", "350000", "020942" ], + "020883" : [ "14:43", "350000", "020943" ], + "020884" : [ "14:44", "350000", "020944" ], + "020885" : [ "14:45", "350000", "020945" ], + "020886" : [ "14:46", "350000", "020946" ], + "020887" : [ "14:47", "350000", "020947" ], + "020888" : [ "14:48", "350000", "020948" ], + "020889" : [ "14:49", "350000", "020949" ], + "020890" : [ "14:50", "350000", "020950" ], + "020891" : [ "14:51", "350000", "020951" ], + "020892" : [ "14:52", "350000", "020952" ], + "020893" : [ "14:53", "350000", "020953" ], + "020894" : [ "14:54", "350000", "020954" ], + "020895" : [ "14:55", "350000", "020955" ], + "020896" : [ "14:56", "350000", "020956" ], + "020897" : [ "14:57", "350000", "020957" ], + "020898" : [ "14:58", "350000", "020958" ], + "020899" : [ "14:59", "350000", "020959" ], + "020900" : [ "15:00", "350000", "020960" ], + "020901" : [ "15:01", "350000", "020961" ], + "020902" : [ "15:02", "350000", "020962" ], + "020903" : [ "15:03", "350000", "020963" ], + "020904" : [ "15:04", "350000", "020964" ], + "020905" : [ "15:05", "350000", "020965" ], + "020906" : [ "15:06", "350000", "020966" ], + "020907" : [ "15:07", "350000", "020967" ], + "020908" : [ "15:08", "350000", "020968" ], + "020909" : [ "15:09", "350000", "020969" ], + "020910" : [ "15:10", "350000", "020970" ], + "020911" : [ "15:11", "350000", "020971" ], + "020912" : [ "15:12", "350000", "020972" ], + "020913" : [ "15:13", "350000", "020973" ], + "020914" : [ "15:14", "350000", "020974" ], + "020915" : [ "15:15", "350000", "020975" ], + "020916" : [ "15:16", "350000", "020976" ], + "020917" : [ "15:17", "350000", "020977" ], + "020918" : [ "15:18", "350000", "020978" ], + "020919" : [ "15:19", "350000", "020979" ], + "020920" : [ "15:20", "350000", "020980" ], + "020921" : [ "15:21", "350000", "020981" ], + "020922" : [ "15:22", "350000", "020982" ], + "020923" : [ "15:23", "350000", "020983" ], + "020924" : [ "15:24", "350000", "020984" ], + "020925" : [ "15:25", "350000", "020985" ], + "020926" : [ "15:26", "350000", "020986" ], + "020927" : [ "15:27", "350000", "020987" ], + "020928" : [ "15:28", "350000", "020988" ], + "020929" : [ "15:29", "350000", "020989" ], + "020930" : [ "15:30", "350000", "020990" ], + "020931" : [ "15:31", "350000", "020991" ], + "020932" : [ "15:32", "350000", "020992" ], + "020933" : [ "15:33", "350000", "020993" ], + "020934" : [ "15:34", "350000", "020994" ], + "020935" : [ "15:35", "350000", "020995" ], + "020936" : [ "15:36", "350000", "020996" ], + "020937" : [ "15:37", "350000", "020997" ], + "020938" : [ "15:38", "350000", "020998" ], + "020939" : [ "15:39", "350000", "020999" ], + "020940" : [ "15:40", "350000", "021000" ], + "020941" : [ "15:41", "350000", "021001" ], + "020942" : [ "15:42", "350000", "021002" ], + "020943" : [ "15:43", "350000", "021003" ], + "020944" : [ "15:44", "350000", "021004" ], + "020945" : [ "15:45", "350000", "021005" ], + "020946" : [ "15:46", "350000", "021006" ], + "020947" : [ "15:47", "350000", "021007" ], + "020948" : [ "15:48", "350000", "021008" ], + "020949" : [ "15:49", "350000", "021009" ], + "020950" : [ "15:50", "350000", "021010" ], + "020951" : [ "15:51", "350000", "021011" ], + "020952" : [ "15:52", "350000", "021012" ], + "020953" : [ "15:53", "350000", "021013" ], + "020954" : [ "15:54", "350000", "021014" ], + "020955" : [ "15:55", "350000", "021015" ], + "020956" : [ "15:56", "350000", "021016" ], + "020957" : [ "15:57", "350000", "021017" ], + "020958" : [ "15:58", "350000", "021018" ], + "020959" : [ "15:59", "350000", "021019" ], + "020960" : [ "16:00", "350000", "021020" ], + "020961" : [ "16:01", "350000", "021021" ], + "020962" : [ "16:02", "350000", "021022" ], + "020963" : [ "16:03", "350000", "021023" ], + "020964" : [ "16:04", "350000", "021024" ], + "020965" : [ "16:05", "350000", "021025" ], + "020966" : [ "16:06", "350000", "021026" ], + "020967" : [ "16:07", "350000", "021027" ], + "020968" : [ "16:08", "350000", "021028" ], + "020969" : [ "16:09", "350000", "021029" ], + "020970" : [ "16:10", "350000", "021030" ], + "020971" : [ "16:11", "350000", "021031" ], + "020972" : [ "16:12", "350000", "021032" ], + "020973" : [ "16:13", "350000", "021033" ], + "020974" : [ "16:14", "350000", "021034" ], + "020975" : [ "16:15", "350000", "021035" ], + "020976" : [ "16:16", "350000", "021036" ], + "020977" : [ "16:17", "350000", "021037" ], + "020978" : [ "16:18", "350000", "021038" ], + "020979" : [ "16:19", "350000", "021039" ], + "020980" : [ "16:20", "350000", "021040" ], + "020981" : [ "16:21", "350000", "021041" ], + "020982" : [ "16:22", "350000", "021042" ], + "020983" : [ "16:23", "350000", "021043" ], + "020984" : [ "16:24", "350000", "021044" ], + "020985" : [ "16:25", "350000", "021045" ], + "020986" : [ "16:26", "350000", "021046" ], + "020987" : [ "16:27", "350000", "021047" ], + "020988" : [ "16:28", "350000", "021048" ], + "020989" : [ "16:29", "350000", "021049" ], + "020990" : [ "16:30", "350000", "021050" ], + "020991" : [ "16:31", "350000", "021051" ], + "020992" : [ "16:32", "350000", "021052" ], + "020993" : [ "16:33", "350000", "021053" ], + "020994" : [ "16:34", "350000", "021054" ], + "020995" : [ "16:35", "350000", "021055" ], + "020996" : [ "16:36", "350000", "021056" ], + "020997" : [ "16:37", "350000", "021057" ], + "020998" : [ "16:38", "350000", "021058" ], + "020999" : [ "16:39", "350000", "021059" ], + "021000" : [ "16:40", "350000", "021060" ], + "021001" : [ "16:41", "350000", "021061" ], + "021002" : [ "16:42", "350000", "021062" ], + "021003" : [ "16:43", "350000", "021063" ], + "021004" : [ "16:44", "350000", "021064" ], + "021005" : [ "16:45", "350000", "021065" ], + "021006" : [ "16:46", "350000", "021066" ], + "021007" : [ "16:47", "350000", "021067" ], + "021008" : [ "16:48", "350000", "021068" ], + "021009" : [ "16:49", "350000", "021069" ], + "021010" : [ "16:50", "350000", "021070" ], + "021011" : [ "16:51", "350000", "021071" ], + "021012" : [ "16:52", "350000", "021072" ], + "021013" : [ "16:53", "350000", "021073" ], + "021014" : [ "16:54", "350000", "021074" ], + "021015" : [ "16:55", "350000", "021075" ], + "021016" : [ "16:56", "350000", "021076" ], + "021017" : [ "16:57", "350000", "021077" ], + "021018" : [ "16:58", "350000", "021078" ], + "021019" : [ "16:59", "350000", "021079" ], + "021020" : [ "17:00", "350000", "021080" ], + "021021" : [ "17:01", "350000", "021081" ], + "021022" : [ "17:02", "350000", "021082" ], + "021023" : [ "17:03", "350000", "021083" ], + "021024" : [ "17:04", "350000", "021084" ], + "021025" : [ "17:05", "350000", "021085" ], + "021026" : [ "17:06", "350000", "021086" ], + "021027" : [ "17:07", "350000", "021087" ], + "021028" : [ "17:08", "350000", "021088" ], + "021029" : [ "17:09", "350000", "021089" ], + "021030" : [ "17:10", "350000", "021090" ], + "021031" : [ "17:11", "350000", "021091" ], + "021032" : [ "17:12", "350000", "021092" ], + "021033" : [ "17:13", "350000", "021093" ], + "021034" : [ "17:14", "350000", "021094" ], + "021035" : [ "17:15", "350000", "021095" ], + "021036" : [ "17:16", "350000", "021096" ], + "021037" : [ "17:17", "350000", "021097" ], + "021038" : [ "17:18", "350000", "021098" ], + "021039" : [ "17:19", "350000", "021099" ], + "021040" : [ "17:20", "350000", "021100" ], + "021041" : [ "17:21", "350000", "021101" ], + "021042" : [ "17:22", "350000", "021102" ], + "021043" : [ "17:23", "350000", "021103" ], + "021044" : [ "17:24", "350000", "021104" ], + "021045" : [ "17:25", "350000", "021105" ], + "021046" : [ "17:26", "350000", "021106" ], + "021047" : [ "17:27", "350000", "021107" ], + "021048" : [ "17:28", "350000", "021108" ], + "021049" : [ "17:29", "350000", "021109" ], + "021050" : [ "17:30", "350000", "021110" ], + "021051" : [ "17:31", "350000", "021111" ], + "021052" : [ "17:32", "350000", "021112" ], + "021053" : [ "17:33", "350000", "021113" ], + "021054" : [ "17:34", "350000", "021114" ], + "021055" : [ "17:35", "350000", "021115" ], + "021056" : [ "17:36", "350000", "021116" ], + "021057" : [ "17:37", "350000", "021117" ], + "021058" : [ "17:38", "350000", "021118" ], + "021059" : [ "17:39", "350000", "021119" ], + "021060" : [ "17:40", "350000", "021120" ], + "021061" : [ "17:41", "350000", "021121" ], + "021062" : [ "17:42", "350000", "021122" ], + "021063" : [ "17:43", "350000", "021123" ], + "021064" : [ "17:44", "350000", "021124" ], + "021065" : [ "17:45", "350000", "021125" ], + "021066" : [ "17:46", "350000", "021126" ], + "021067" : [ "17:47", "350000", "021127" ], + "021068" : [ "17:48", "350000", "021128" ], + "021069" : [ "17:49", "350000", "021129" ], + "021070" : [ "17:50", "350000", "021130" ], + "021071" : [ "17:51", "350000", "021131" ], + "021072" : [ "17:52", "350000", "021132" ], + "021073" : [ "17:53", "350000", "021133" ], + "021074" : [ "17:54", "350000", "021134" ], + "021075" : [ "17:55", "350000", "021135" ], + "021076" : [ "17:56", "350000", "021136" ], + "021077" : [ "17:57", "350000", "021137" ], + "021078" : [ "17:58", "350000", "021138" ], + "021079" : [ "17:59", "350000", "021139" ], + "021080" : [ "18:00", "350000", "021140" ], + "021081" : [ "18:01", "350000", "021141" ], + "021082" : [ "18:02", "350000", "021142" ], + "021083" : [ "18:03", "350000", "021143" ], + "021084" : [ "18:04", "350000", "021144" ], + "021085" : [ "18:05", "350000", "021145" ], + "021086" : [ "18:06", "350000", "021146" ], + "021087" : [ "18:07", "350000", "021147" ], + "021088" : [ "18:08", "350000", "021148" ], + "021089" : [ "18:09", "350000", "021149" ], + "021090" : [ "18:10", "350000", "021150" ], + "021091" : [ "18:11", "350000", "021151" ], + "021092" : [ "18:12", "350000", "021152" ], + "021093" : [ "18:13", "350000", "021153" ], + "021094" : [ "18:14", "350000", "021154" ], + "021095" : [ "18:15", "350000", "021155" ], + "021096" : [ "18:16", "350000", "021156" ], + "021097" : [ "18:17", "350000", "021157" ], + "021098" : [ "18:18", "350000", "021158" ], + "021099" : [ "18:19", "350000", "021159" ], + "021100" : [ "18:20", "350000", "021160" ], + "021101" : [ "18:21", "350000", "021161" ], + "021102" : [ "18:22", "350000", "021162" ], + "021103" : [ "18:23", "350000", "021163" ], + "021104" : [ "18:24", "350000", "021164" ], + "021105" : [ "18:25", "350000", "021165" ], + "021106" : [ "18:26", "350000", "021166" ], + "021107" : [ "18:27", "350000", "021167" ], + "021108" : [ "18:28", "350000", "021168" ], + "021109" : [ "18:29", "350000", "021169" ], + "021110" : [ "18:30", "350000", "021170" ], + "021111" : [ "18:31", "350000", "021171" ], + "021112" : [ "18:32", "350000", "021172" ], + "021113" : [ "18:33", "350000", "021173" ], + "021114" : [ "18:34", "350000", "021174" ], + "021115" : [ "18:35", "350000", "021175" ], + "021116" : [ "18:36", "350000", "021176" ], + "021117" : [ "18:37", "350000", "021177" ], + "021118" : [ "18:38", "350000", "021178" ], + "021119" : [ "18:39", "350000", "021179" ], + "021120" : [ "18:40", "350000", "021180" ], + "021121" : [ "18:41", "350000", "021181" ], + "021122" : [ "18:42", "350000", "021182" ], + "021123" : [ "18:43", "350000", "021183" ], + "021124" : [ "18:44", "350000", "021184" ], + "021125" : [ "18:45", "350000", "021185" ], + "021126" : [ "18:46", "350000", "021186" ], + "021127" : [ "18:47", "350000", "021187" ], + "021128" : [ "18:48", "350000", "021188" ], + "021129" : [ "18:49", "350000", "021189" ], + "021130" : [ "18:50", "350000", "021190" ], + "021131" : [ "18:51", "350000", "021191" ], + "021132" : [ "18:52", "350000", "021192" ], + "021133" : [ "18:53", "350000", "021193" ], + "021134" : [ "18:54", "350000", "021194" ], + "021135" : [ "18:55", "350000", "021195" ], + "021136" : [ "18:56", "350000", "021196" ], + "021137" : [ "18:57", "350000", "021197" ], + "021138" : [ "18:58", "350000", "021198" ], + "021139" : [ "18:59", "350000", "021199" ], + "021140" : [ "19:00", "350000", "021200" ], + "021141" : [ "19:01", "350000", "021200" ], + "021142" : [ "19:02", "350000", "021200" ], + "021143" : [ "19:03", "350000", "021200" ], + "021144" : [ "19:04", "350000", "021200" ], + "021145" : [ "19:05", "350000", "021200" ], + "021146" : [ "19:06", "350000", "021200" ], + "021147" : [ "19:07", "350000", "021200" ], + "021148" : [ "19:08", "350000", "021200" ], + "021149" : [ "19:09", "350000", "021200" ], + "021150" : [ "19:10", "350000", "021200" ], + "021151" : [ "19:11", "350000", "021200" ], + "021152" : [ "19:12", "350000", "021200" ], + "021153" : [ "19:13", "350000", "021200" ], + "021154" : [ "19:14", "350000", "021200" ], + "021155" : [ "19:15", "350000", "021200" ], + "021156" : [ "19:16", "350000", "021200" ], + "021157" : [ "19:17", "350000", "021200" ], + "021158" : [ "19:18", "350000", "021200" ], + "021159" : [ "19:19", "350000", "021200" ], + "021160" : [ "19:20", "350000", "021200" ], + "021161" : [ "19:21", "350000", "021200" ], + "021162" : [ "19:22", "350000", "021200" ], + "021163" : [ "19:23", "350000", "021200" ], + "021164" : [ "19:24", "350000", "021200" ], + "021165" : [ "19:25", "350000", "021200" ], + "021166" : [ "19:26", "350000", "021200" ], + "021167" : [ "19:27", "350000", "021200" ], + "021168" : [ "19:28", "350000", "021200" ], + "021169" : [ "19:29", "350000", "021200" ], + "021170" : [ "19:30", "350000", "021200" ], + "021171" : [ "19:31", "350000", "021200" ], + "021172" : [ "19:32", "350000", "021200" ], + "021173" : [ "19:33", "350000", "021200" ], + "021174" : [ "19:34", "350000", "021200" ], + "021175" : [ "19:35", "350000", "021200" ], + "021176" : [ "19:36", "350000", "021200" ], + "021177" : [ "19:37", "350000", "021200" ], + "021178" : [ "19:38", "350000", "021200" ], + "021179" : [ "19:39", "350000", "021200" ], + "021180" : [ "19:40", "350000", "021200" ], + "021181" : [ "19:41", "350000", "021200" ], + "021182" : [ "19:42", "350000", "021200" ], + "021183" : [ "19:43", "350000", "021200" ], + "021184" : [ "19:44", "350000", "021200" ], + "021185" : [ "19:45", "350000", "021200" ], + "021186" : [ "19:46", "350000", "021200" ], + "021187" : [ "19:47", "350000", "021200" ], + "021188" : [ "19:48", "350000", "021200" ], + "021189" : [ "19:49", "350000", "021200" ], + "021190" : [ "19:50", "350000", "021200" ], + "021191" : [ "19:51", "350000", "021200" ], + "021192" : [ "19:52", "350000", "021200" ], + "021193" : [ "19:53", "350000", "021200" ], + "021194" : [ "19:54", "350000", "021200" ], + "021195" : [ "19:55", "350000", "021200" ], + "021196" : [ "19:56", "350000", "021200" ], + "021197" : [ "19:57", "350000", "021200" ], + "021198" : [ "19:58", "350000", "021200" ], + "021199" : [ "19:59", "350000", "021200" ], + "021200" : [ "20:00", "800000", "030420" ], + "021201" : [ "20:01", "800000", "030420" ], + "021202" : [ "20:02", "800000", "030420" ], + "021203" : [ "20:03", "800000", "030420" ], + "021204" : [ "20:04", "800000", "030420" ], + "021205" : [ "20:05", "800000", "030420" ], + "021206" : [ "20:06", "800000", "030420" ], + "021207" : [ "20:07", "800000", "030420" ], + "021208" : [ "20:08", "800000", "030420" ], + "021209" : [ "20:09", "800000", "030420" ], + "021210" : [ "20:10", "800000", "030420" ], + "021211" : [ "20:11", "800000", "030420" ], + "021212" : [ "20:12", "800000", "030420" ], + "021213" : [ "20:13", "800000", "030420" ], + "021214" : [ "20:14", "800000", "030420" ], + "021215" : [ "20:15", "800000", "030420" ], + "021216" : [ "20:16", "800000", "030420" ], + "021217" : [ "20:17", "800000", "030420" ], + "021218" : [ "20:18", "800000", "030420" ], + "021219" : [ "20:19", "800000", "030420" ], + "021220" : [ "20:20", "800000", "030420" ], + "021221" : [ "20:21", "800000", "030420" ], + "021222" : [ "20:22", "800000", "030420" ], + "021223" : [ "20:23", "800000", "030420" ], + "021224" : [ "20:24", "800000", "030420" ], + "021225" : [ "20:25", "800000", "030420" ], + "021226" : [ "20:26", "800000", "030420" ], + "021227" : [ "20:27", "800000", "030420" ], + "021228" : [ "20:28", "800000", "030420" ], + "021229" : [ "20:29", "800000", "030420" ], + "021230" : [ "20:30", "800000", "030420" ], + "021231" : [ "20:31", "800000", "030420" ], + "021232" : [ "20:32", "800000", "030420" ], + "021233" : [ "20:33", "800000", "030420" ], + "021234" : [ "20:34", "800000", "030420" ], + "021235" : [ "20:35", "800000", "030420" ], + "021236" : [ "20:36", "800000", "030420" ], + "021237" : [ "20:37", "800000", "030420" ], + "021238" : [ "20:38", "800000", "030420" ], + "021239" : [ "20:39", "800000", "030420" ], + "021240" : [ "20:40", "800000", "030420" ], + "021241" : [ "20:41", "800000", "030420" ], + "021242" : [ "20:42", "800000", "030420" ], + "021243" : [ "20:43", "800000", "030420" ], + "021244" : [ "20:44", "800000", "030420" ], + "021245" : [ "20:45", "800000", "030420" ], + "021246" : [ "20:46", "800000", "030420" ], + "021247" : [ "20:47", "800000", "030420" ], + "021248" : [ "20:48", "800000", "030420" ], + "021249" : [ "20:49", "800000", "030420" ], + "021250" : [ "20:50", "800000", "030420" ], + "021251" : [ "20:51", "800000", "030420" ], + "021252" : [ "20:52", "800000", "030420" ], + "021253" : [ "20:53", "800000", "030420" ], + "021254" : [ "20:54", "800000", "030420" ], + "021255" : [ "20:55", "800000", "030420" ], + "021256" : [ "20:56", "800000", "030420" ], + "021257" : [ "20:57", "800000", "030420" ], + "021258" : [ "20:58", "800000", "030420" ], + "021259" : [ "20:59", "800000", "030420" ], + "021260" : [ "21:00", "800000", "030420" ], + "021261" : [ "21:01", "800000", "030420" ], + "021262" : [ "21:02", "800000", "030420" ], + "021263" : [ "21:03", "800000", "030420" ], + "021264" : [ "21:04", "800000", "030420" ], + "021265" : [ "21:05", "800000", "030420" ], + "021266" : [ "21:06", "800000", "030420" ], + "021267" : [ "21:07", "800000", "030420" ], + "021268" : [ "21:08", "800000", "030420" ], + "021269" : [ "21:09", "800000", "030420" ], + "021270" : [ "21:10", "800000", "030420" ], + "021271" : [ "21:11", "800000", "030420" ], + "021272" : [ "21:12", "800000", "030420" ], + "021273" : [ "21:13", "800000", "030420" ], + "021274" : [ "21:14", "800000", "030420" ], + "021275" : [ "21:15", "800000", "030420" ], + "021276" : [ "21:16", "800000", "030420" ], + "021277" : [ "21:17", "800000", "030420" ], + "021278" : [ "21:18", "800000", "030420" ], + "021279" : [ "21:19", "800000", "030420" ], + "021280" : [ "21:20", "800000", "030420" ], + "021281" : [ "21:21", "800000", "030420" ], + "021282" : [ "21:22", "800000", "030420" ], + "021283" : [ "21:23", "800000", "030420" ], + "021284" : [ "21:24", "800000", "030420" ], + "021285" : [ "21:25", "800000", "030420" ], + "021286" : [ "21:26", "800000", "030420" ], + "021287" : [ "21:27", "800000", "030420" ], + "021288" : [ "21:28", "800000", "030420" ], + "021289" : [ "21:29", "800000", "030420" ], + "021290" : [ "21:30", "800000", "030420" ], + "021291" : [ "21:31", "800000", "030420" ], + "021292" : [ "21:32", "800000", "030420" ], + "021293" : [ "21:33", "800000", "030420" ], + "021294" : [ "21:34", "800000", "030420" ], + "021295" : [ "21:35", "800000", "030420" ], + "021296" : [ "21:36", "800000", "030420" ], + "021297" : [ "21:37", "800000", "030420" ], + "021298" : [ "21:38", "800000", "030420" ], + "021299" : [ "21:39", "800000", "030420" ], + "021300" : [ "21:40", "800000", "030420" ], + "021301" : [ "21:41", "800000", "030420" ], + "021302" : [ "21:42", "800000", "030420" ], + "021303" : [ "21:43", "800000", "030420" ], + "021304" : [ "21:44", "800000", "030420" ], + "021305" : [ "21:45", "800000", "030420" ], + "021306" : [ "21:46", "800000", "030420" ], + "021307" : [ "21:47", "800000", "030420" ], + "021308" : [ "21:48", "800000", "030420" ], + "021309" : [ "21:49", "800000", "030420" ], + "021310" : [ "21:50", "800000", "030420" ], + "021311" : [ "21:51", "800000", "030420" ], + "021312" : [ "21:52", "800000", "030420" ], + "021313" : [ "21:53", "800000", "030420" ], + "021314" : [ "21:54", "800000", "030420" ], + "021315" : [ "21:55", "800000", "030420" ], + "021316" : [ "21:56", "800000", "030420" ], + "021317" : [ "21:57", "800000", "030420" ], + "021318" : [ "21:58", "800000", "030420" ], + "021319" : [ "21:59", "800000", "030420" ], + "021320" : [ "22:00", "800000", "030420" ], + "021321" : [ "22:01", "800000", "030420" ], + "021322" : [ "22:02", "800000", "030420" ], + "021323" : [ "22:03", "800000", "030420" ], + "021324" : [ "22:04", "800000", "030420" ], + "021325" : [ "22:05", "800000", "030420" ], + "021326" : [ "22:06", "800000", "030420" ], + "021327" : [ "22:07", "800000", "030420" ], + "021328" : [ "22:08", "800000", "030420" ], + "021329" : [ "22:09", "800000", "030420" ], + "021330" : [ "22:10", "800000", "030420" ], + "021331" : [ "22:11", "800000", "030420" ], + "021332" : [ "22:12", "800000", "030420" ], + "021333" : [ "22:13", "800000", "030420" ], + "021334" : [ "22:14", "800000", "030420" ], + "021335" : [ "22:15", "800000", "030420" ], + "021336" : [ "22:16", "800000", "030420" ], + "021337" : [ "22:17", "800000", "030420" ], + "021338" : [ "22:18", "800000", "030420" ], + "021339" : [ "22:19", "800000", "030420" ], + "021340" : [ "22:20", "800000", "030420" ], + "021341" : [ "22:21", "800000", "030420" ], + "021342" : [ "22:22", "800000", "030420" ], + "021343" : [ "22:23", "800000", "030420" ], + "021344" : [ "22:24", "800000", "030420" ], + "021345" : [ "22:25", "800000", "030420" ], + "021346" : [ "22:26", "800000", "030420" ], + "021347" : [ "22:27", "800000", "030420" ], + "021348" : [ "22:28", "800000", "030420" ], + "021349" : [ "22:29", "800000", "030420" ], + "021350" : [ "22:30", "800000", "030420" ], + "021351" : [ "22:31", "800000", "030420" ], + "021352" : [ "22:32", "800000", "030420" ], + "021353" : [ "22:33", "800000", "030420" ], + "021354" : [ "22:34", "800000", "030420" ], + "021355" : [ "22:35", "800000", "030420" ], + "021356" : [ "22:36", "800000", "030420" ], + "021357" : [ "22:37", "800000", "030420" ], + "021358" : [ "22:38", "800000", "030420" ], + "021359" : [ "22:39", "800000", "030420" ], + "021360" : [ "22:40", "800000", "030420" ], + "021361" : [ "22:41", "800000", "030420" ], + "021362" : [ "22:42", "800000", "030420" ], + "021363" : [ "22:43", "800000", "030420" ], + "021364" : [ "22:44", "800000", "030420" ], + "021365" : [ "22:45", "800000", "030420" ], + "021366" : [ "22:46", "800000", "030420" ], + "021367" : [ "22:47", "800000", "030420" ], + "021368" : [ "22:48", "800000", "030420" ], + "021369" : [ "22:49", "800000", "030420" ], + "021370" : [ "22:50", "800000", "030420" ], + "021371" : [ "22:51", "800000", "030420" ], + "021372" : [ "22:52", "800000", "030420" ], + "021373" : [ "22:53", "800000", "030420" ], + "021374" : [ "22:54", "800000", "030420" ], + "021375" : [ "22:55", "800000", "030420" ], + "021376" : [ "22:56", "800000", "030420" ], + "021377" : [ "22:57", "800000", "030420" ], + "021378" : [ "22:58", "800000", "030420" ], + "021379" : [ "22:59", "800000", "030420" ], + "021380" : [ "23:00", "800000", "030420" ], + "021381" : [ "23:01", "800000", "030420" ], + "021382" : [ "23:02", "800000", "030420" ], + "021383" : [ "23:03", "800000", "030420" ], + "021384" : [ "23:04", "800000", "030420" ], + "021385" : [ "23:05", "800000", "030420" ], + "021386" : [ "23:06", "800000", "030420" ], + "021387" : [ "23:07", "800000", "030420" ], + "021388" : [ "23:08", "800000", "030420" ], + "021389" : [ "23:09", "800000", "030420" ], + "021390" : [ "23:10", "800000", "030420" ], + "021391" : [ "23:11", "800000", "030420" ], + "021392" : [ "23:12", "800000", "030420" ], + "021393" : [ "23:13", "800000", "030420" ], + "021394" : [ "23:14", "800000", "030420" ], + "021395" : [ "23:15", "800000", "030420" ], + "021396" : [ "23:16", "800000", "030420" ], + "021397" : [ "23:17", "800000", "030420" ], + "021398" : [ "23:18", "800000", "030420" ], + "021399" : [ "23:19", "800000", "030420" ], + "021400" : [ "23:20", "800000", "030420" ], + "021401" : [ "23:21", "800000", "030420" ], + "021402" : [ "23:22", "800000", "030420" ], + "021403" : [ "23:23", "800000", "030420" ], + "021404" : [ "23:24", "800000", "030420" ], + "021405" : [ "23:25", "800000", "030420" ], + "021406" : [ "23:26", "800000", "030420" ], + "021407" : [ "23:27", "800000", "030420" ], + "021408" : [ "23:28", "800000", "030420" ], + "021409" : [ "23:29", "800000", "030420" ], + "021410" : [ "23:30", "800000", "030420" ], + "021411" : [ "23:31", "800000", "030420" ], + "021412" : [ "23:32", "800000", "030420" ], + "021413" : [ "23:33", "800000", "030420" ], + "021414" : [ "23:34", "800000", "030420" ], + "021415" : [ "23:35", "800000", "030420" ], + "021416" : [ "23:36", "800000", "030420" ], + "021417" : [ "23:37", "800000", "030420" ], + "021418" : [ "23:38", "800000", "030420" ], + "021419" : [ "23:39", "800000", "030420" ], + "021420" : [ "23:40", "800000", "030420" ], + "021421" : [ "23:41", "800000", "030420" ], + "021422" : [ "23:42", "800000", "030420" ], + "021423" : [ "23:43", "800000", "030420" ], + "021424" : [ "23:44", "800000", "030420" ], + "021425" : [ "23:45", "800000", "030420" ], + "021426" : [ "23:46", "800000", "030420" ], + "021427" : [ "23:47", "800000", "030420" ], + "021428" : [ "23:48", "800000", "030420" ], + "021429" : [ "23:49", "800000", "030420" ], + "021430" : [ "23:50", "800000", "030420" ], + "021431" : [ "23:51", "800000", "030420" ], + "021432" : [ "23:52", "800000", "030420" ], + "021433" : [ "23:53", "800000", "030420" ], + "021434" : [ "23:54", "800000", "030420" ], + "021435" : [ "23:55", "800000", "030420" ], + "021436" : [ "23:56", "800000", "030420" ], + "021437" : [ "23:57", "800000", "030420" ], + "021438" : [ "23:58", "800000", "030420" ], + "021439" : [ "23:59", "800000", "030420" ] + }, + "Thursday": { + "030000" : [ "00:00", "800000", "030420" ], + "030001" : [ "00:01", "800000", "030420" ], + "030002" : [ "00:02", "800000", "030420" ], + "030003" : [ "00:03", "800000", "030420" ], + "030004" : [ "00:04", "800000", "030420" ], + "030005" : [ "00:05", "800000", "030420" ], + "030006" : [ "00:06", "800000", "030420" ], + "030007" : [ "00:07", "800000", "030420" ], + "030008" : [ "00:08", "800000", "030420" ], + "030009" : [ "00:09", "800000", "030420" ], + "030010" : [ "00:10", "800000", "030420" ], + "030011" : [ "00:11", "800000", "030420" ], + "030012" : [ "00:12", "800000", "030420" ], + "030013" : [ "00:13", "800000", "030420" ], + "030014" : [ "00:14", "800000", "030420" ], + "030015" : [ "00:15", "800000", "030420" ], + "030016" : [ "00:16", "800000", "030420" ], + "030017" : [ "00:17", "800000", "030420" ], + "030018" : [ "00:18", "800000", "030420" ], + "030019" : [ "00:19", "800000", "030420" ], + "030020" : [ "00:20", "800000", "030420" ], + "030021" : [ "00:21", "800000", "030420" ], + "030022" : [ "00:22", "800000", "030420" ], + "030023" : [ "00:23", "800000", "030420" ], + "030024" : [ "00:24", "800000", "030420" ], + "030025" : [ "00:25", "800000", "030420" ], + "030026" : [ "00:26", "800000", "030420" ], + "030027" : [ "00:27", "800000", "030420" ], + "030028" : [ "00:28", "800000", "030420" ], + "030029" : [ "00:29", "800000", "030420" ], + "030030" : [ "00:30", "800000", "030420" ], + "030031" : [ "00:31", "800000", "030420" ], + "030032" : [ "00:32", "800000", "030420" ], + "030033" : [ "00:33", "800000", "030420" ], + "030034" : [ "00:34", "800000", "030420" ], + "030035" : [ "00:35", "800000", "030420" ], + "030036" : [ "00:36", "800000", "030420" ], + "030037" : [ "00:37", "800000", "030420" ], + "030038" : [ "00:38", "800000", "030420" ], + "030039" : [ "00:39", "800000", "030420" ], + "030040" : [ "00:40", "800000", "030420" ], + "030041" : [ "00:41", "800000", "030420" ], + "030042" : [ "00:42", "800000", "030420" ], + "030043" : [ "00:43", "800000", "030420" ], + "030044" : [ "00:44", "800000", "030420" ], + "030045" : [ "00:45", "800000", "030420" ], + "030046" : [ "00:46", "800000", "030420" ], + "030047" : [ "00:47", "800000", "030420" ], + "030048" : [ "00:48", "800000", "030420" ], + "030049" : [ "00:49", "800000", "030420" ], + "030050" : [ "00:50", "800000", "030420" ], + "030051" : [ "00:51", "800000", "030420" ], + "030052" : [ "00:52", "800000", "030420" ], + "030053" : [ "00:53", "800000", "030420" ], + "030054" : [ "00:54", "800000", "030420" ], + "030055" : [ "00:55", "800000", "030420" ], + "030056" : [ "00:56", "800000", "030420" ], + "030057" : [ "00:57", "800000", "030420" ], + "030058" : [ "00:58", "800000", "030420" ], + "030059" : [ "00:59", "800000", "030420" ], + "030060" : [ "01:00", "800000", "030420" ], + "030061" : [ "01:01", "800000", "030420" ], + "030062" : [ "01:02", "800000", "030420" ], + "030063" : [ "01:03", "800000", "030420" ], + "030064" : [ "01:04", "800000", "030420" ], + "030065" : [ "01:05", "800000", "030420" ], + "030066" : [ "01:06", "800000", "030420" ], + "030067" : [ "01:07", "800000", "030420" ], + "030068" : [ "01:08", "800000", "030420" ], + "030069" : [ "01:09", "800000", "030420" ], + "030070" : [ "01:10", "800000", "030420" ], + "030071" : [ "01:11", "800000", "030420" ], + "030072" : [ "01:12", "800000", "030420" ], + "030073" : [ "01:13", "800000", "030420" ], + "030074" : [ "01:14", "800000", "030420" ], + "030075" : [ "01:15", "800000", "030420" ], + "030076" : [ "01:16", "800000", "030420" ], + "030077" : [ "01:17", "800000", "030420" ], + "030078" : [ "01:18", "800000", "030420" ], + "030079" : [ "01:19", "800000", "030420" ], + "030080" : [ "01:20", "800000", "030420" ], + "030081" : [ "01:21", "800000", "030420" ], + "030082" : [ "01:22", "800000", "030420" ], + "030083" : [ "01:23", "800000", "030420" ], + "030084" : [ "01:24", "800000", "030420" ], + "030085" : [ "01:25", "800000", "030420" ], + "030086" : [ "01:26", "800000", "030420" ], + "030087" : [ "01:27", "800000", "030420" ], + "030088" : [ "01:28", "800000", "030420" ], + "030089" : [ "01:29", "800000", "030420" ], + "030090" : [ "01:30", "800000", "030420" ], + "030091" : [ "01:31", "800000", "030420" ], + "030092" : [ "01:32", "800000", "030420" ], + "030093" : [ "01:33", "800000", "030420" ], + "030094" : [ "01:34", "800000", "030420" ], + "030095" : [ "01:35", "800000", "030420" ], + "030096" : [ "01:36", "800000", "030420" ], + "030097" : [ "01:37", "800000", "030420" ], + "030098" : [ "01:38", "800000", "030420" ], + "030099" : [ "01:39", "800000", "030420" ], + "030100" : [ "01:40", "800000", "030420" ], + "030101" : [ "01:41", "800000", "030420" ], + "030102" : [ "01:42", "800000", "030420" ], + "030103" : [ "01:43", "800000", "030420" ], + "030104" : [ "01:44", "800000", "030420" ], + "030105" : [ "01:45", "800000", "030420" ], + "030106" : [ "01:46", "800000", "030420" ], + "030107" : [ "01:47", "800000", "030420" ], + "030108" : [ "01:48", "800000", "030420" ], + "030109" : [ "01:49", "800000", "030420" ], + "030110" : [ "01:50", "800000", "030420" ], + "030111" : [ "01:51", "800000", "030420" ], + "030112" : [ "01:52", "800000", "030420" ], + "030113" : [ "01:53", "800000", "030420" ], + "030114" : [ "01:54", "800000", "030420" ], + "030115" : [ "01:55", "800000", "030420" ], + "030116" : [ "01:56", "800000", "030420" ], + "030117" : [ "01:57", "800000", "030420" ], + "030118" : [ "01:58", "800000", "030420" ], + "030119" : [ "01:59", "800000", "030420" ], + "030120" : [ "02:00", "800000", "030420" ], + "030121" : [ "02:01", "800000", "030420" ], + "030122" : [ "02:02", "800000", "030420" ], + "030123" : [ "02:03", "800000", "030420" ], + "030124" : [ "02:04", "800000", "030420" ], + "030125" : [ "02:05", "800000", "030420" ], + "030126" : [ "02:06", "800000", "030420" ], + "030127" : [ "02:07", "800000", "030420" ], + "030128" : [ "02:08", "800000", "030420" ], + "030129" : [ "02:09", "800000", "030420" ], + "030130" : [ "02:10", "800000", "030420" ], + "030131" : [ "02:11", "800000", "030420" ], + "030132" : [ "02:12", "800000", "030420" ], + "030133" : [ "02:13", "800000", "030420" ], + "030134" : [ "02:14", "800000", "030420" ], + "030135" : [ "02:15", "800000", "030420" ], + "030136" : [ "02:16", "800000", "030420" ], + "030137" : [ "02:17", "800000", "030420" ], + "030138" : [ "02:18", "800000", "030420" ], + "030139" : [ "02:19", "800000", "030420" ], + "030140" : [ "02:20", "800000", "030420" ], + "030141" : [ "02:21", "800000", "030420" ], + "030142" : [ "02:22", "800000", "030420" ], + "030143" : [ "02:23", "800000", "030420" ], + "030144" : [ "02:24", "800000", "030420" ], + "030145" : [ "02:25", "800000", "030420" ], + "030146" : [ "02:26", "800000", "030420" ], + "030147" : [ "02:27", "800000", "030420" ], + "030148" : [ "02:28", "800000", "030420" ], + "030149" : [ "02:29", "800000", "030420" ], + "030150" : [ "02:30", "800000", "030420" ], + "030151" : [ "02:31", "800000", "030420" ], + "030152" : [ "02:32", "800000", "030420" ], + "030153" : [ "02:33", "800000", "030420" ], + "030154" : [ "02:34", "800000", "030420" ], + "030155" : [ "02:35", "800000", "030420" ], + "030156" : [ "02:36", "800000", "030420" ], + "030157" : [ "02:37", "800000", "030420" ], + "030158" : [ "02:38", "800000", "030420" ], + "030159" : [ "02:39", "800000", "030420" ], + "030160" : [ "02:40", "800000", "030420" ], + "030161" : [ "02:41", "800000", "030420" ], + "030162" : [ "02:42", "800000", "030420" ], + "030163" : [ "02:43", "800000", "030420" ], + "030164" : [ "02:44", "800000", "030420" ], + "030165" : [ "02:45", "800000", "030420" ], + "030166" : [ "02:46", "800000", "030420" ], + "030167" : [ "02:47", "800000", "030420" ], + "030168" : [ "02:48", "800000", "030420" ], + "030169" : [ "02:49", "800000", "030420" ], + "030170" : [ "02:50", "800000", "030420" ], + "030171" : [ "02:51", "800000", "030420" ], + "030172" : [ "02:52", "800000", "030420" ], + "030173" : [ "02:53", "800000", "030420" ], + "030174" : [ "02:54", "800000", "030420" ], + "030175" : [ "02:55", "800000", "030420" ], + "030176" : [ "02:56", "800000", "030420" ], + "030177" : [ "02:57", "800000", "030420" ], + "030178" : [ "02:58", "800000", "030420" ], + "030179" : [ "02:59", "800000", "030420" ], + "030180" : [ "03:00", "800000", "030420" ], + "030181" : [ "03:01", "800000", "030420" ], + "030182" : [ "03:02", "800000", "030420" ], + "030183" : [ "03:03", "800000", "030420" ], + "030184" : [ "03:04", "800000", "030420" ], + "030185" : [ "03:05", "800000", "030420" ], + "030186" : [ "03:06", "800000", "030420" ], + "030187" : [ "03:07", "800000", "030420" ], + "030188" : [ "03:08", "800000", "030420" ], + "030189" : [ "03:09", "800000", "030420" ], + "030190" : [ "03:10", "800000", "030420" ], + "030191" : [ "03:11", "800000", "030420" ], + "030192" : [ "03:12", "800000", "030420" ], + "030193" : [ "03:13", "800000", "030420" ], + "030194" : [ "03:14", "800000", "030420" ], + "030195" : [ "03:15", "800000", "030420" ], + "030196" : [ "03:16", "800000", "030420" ], + "030197" : [ "03:17", "800000", "030420" ], + "030198" : [ "03:18", "800000", "030420" ], + "030199" : [ "03:19", "800000", "030420" ], + "030200" : [ "03:20", "800000", "030420" ], + "030201" : [ "03:21", "800000", "030420" ], + "030202" : [ "03:22", "800000", "030420" ], + "030203" : [ "03:23", "800000", "030420" ], + "030204" : [ "03:24", "800000", "030420" ], + "030205" : [ "03:25", "800000", "030420" ], + "030206" : [ "03:26", "800000", "030420" ], + "030207" : [ "03:27", "800000", "030420" ], + "030208" : [ "03:28", "800000", "030420" ], + "030209" : [ "03:29", "800000", "030420" ], + "030210" : [ "03:30", "800000", "030420" ], + "030211" : [ "03:31", "800000", "030420" ], + "030212" : [ "03:32", "800000", "030420" ], + "030213" : [ "03:33", "800000", "030420" ], + "030214" : [ "03:34", "800000", "030420" ], + "030215" : [ "03:35", "800000", "030420" ], + "030216" : [ "03:36", "800000", "030420" ], + "030217" : [ "03:37", "800000", "030420" ], + "030218" : [ "03:38", "800000", "030420" ], + "030219" : [ "03:39", "800000", "030420" ], + "030220" : [ "03:40", "800000", "030420" ], + "030221" : [ "03:41", "800000", "030420" ], + "030222" : [ "03:42", "800000", "030420" ], + "030223" : [ "03:43", "800000", "030420" ], + "030224" : [ "03:44", "800000", "030420" ], + "030225" : [ "03:45", "800000", "030420" ], + "030226" : [ "03:46", "800000", "030420" ], + "030227" : [ "03:47", "800000", "030420" ], + "030228" : [ "03:48", "800000", "030420" ], + "030229" : [ "03:49", "800000", "030420" ], + "030230" : [ "03:50", "800000", "030420" ], + "030231" : [ "03:51", "800000", "030420" ], + "030232" : [ "03:52", "800000", "030420" ], + "030233" : [ "03:53", "800000", "030420" ], + "030234" : [ "03:54", "800000", "030420" ], + "030235" : [ "03:55", "800000", "030420" ], + "030236" : [ "03:56", "800000", "030420" ], + "030237" : [ "03:57", "800000", "030420" ], + "030238" : [ "03:58", "800000", "030420" ], + "030239" : [ "03:59", "800000", "030420" ], + "030240" : [ "04:00", "800000", "030420" ], + "030241" : [ "04:01", "800000", "030420" ], + "030242" : [ "04:02", "800000", "030420" ], + "030243" : [ "04:03", "800000", "030420" ], + "030244" : [ "04:04", "800000", "030420" ], + "030245" : [ "04:05", "800000", "030420" ], + "030246" : [ "04:06", "800000", "030420" ], + "030247" : [ "04:07", "800000", "030420" ], + "030248" : [ "04:08", "800000", "030420" ], + "030249" : [ "04:09", "800000", "030420" ], + "030250" : [ "04:10", "800000", "030420" ], + "030251" : [ "04:11", "800000", "030420" ], + "030252" : [ "04:12", "800000", "030420" ], + "030253" : [ "04:13", "800000", "030420" ], + "030254" : [ "04:14", "800000", "030420" ], + "030255" : [ "04:15", "800000", "030420" ], + "030256" : [ "04:16", "800000", "030420" ], + "030257" : [ "04:17", "800000", "030420" ], + "030258" : [ "04:18", "800000", "030420" ], + "030259" : [ "04:19", "800000", "030420" ], + "030260" : [ "04:20", "800000", "030420" ], + "030261" : [ "04:21", "800000", "030420" ], + "030262" : [ "04:22", "800000", "030420" ], + "030263" : [ "04:23", "800000", "030420" ], + "030264" : [ "04:24", "800000", "030420" ], + "030265" : [ "04:25", "800000", "030420" ], + "030266" : [ "04:26", "800000", "030420" ], + "030267" : [ "04:27", "800000", "030420" ], + "030268" : [ "04:28", "800000", "030420" ], + "030269" : [ "04:29", "800000", "030420" ], + "030270" : [ "04:30", "800000", "030420" ], + "030271" : [ "04:31", "800000", "030420" ], + "030272" : [ "04:32", "800000", "030420" ], + "030273" : [ "04:33", "800000", "030420" ], + "030274" : [ "04:34", "800000", "030420" ], + "030275" : [ "04:35", "800000", "030420" ], + "030276" : [ "04:36", "800000", "030420" ], + "030277" : [ "04:37", "800000", "030420" ], + "030278" : [ "04:38", "800000", "030420" ], + "030279" : [ "04:39", "800000", "030420" ], + "030280" : [ "04:40", "800000", "030420" ], + "030281" : [ "04:41", "800000", "030420" ], + "030282" : [ "04:42", "800000", "030420" ], + "030283" : [ "04:43", "800000", "030420" ], + "030284" : [ "04:44", "800000", "030420" ], + "030285" : [ "04:45", "800000", "030420" ], + "030286" : [ "04:46", "800000", "030420" ], + "030287" : [ "04:47", "800000", "030420" ], + "030288" : [ "04:48", "800000", "030420" ], + "030289" : [ "04:49", "800000", "030420" ], + "030290" : [ "04:50", "800000", "030420" ], + "030291" : [ "04:51", "800000", "030420" ], + "030292" : [ "04:52", "800000", "030420" ], + "030293" : [ "04:53", "800000", "030420" ], + "030294" : [ "04:54", "800000", "030420" ], + "030295" : [ "04:55", "800000", "030420" ], + "030296" : [ "04:56", "800000", "030420" ], + "030297" : [ "04:57", "800000", "030420" ], + "030298" : [ "04:58", "800000", "030420" ], + "030299" : [ "04:59", "800000", "030420" ], + "030300" : [ "05:00", "800000", "030420" ], + "030301" : [ "05:01", "800000", "030420" ], + "030302" : [ "05:02", "800000", "030420" ], + "030303" : [ "05:03", "800000", "030420" ], + "030304" : [ "05:04", "800000", "030420" ], + "030305" : [ "05:05", "800000", "030420" ], + "030306" : [ "05:06", "800000", "030420" ], + "030307" : [ "05:07", "800000", "030420" ], + "030308" : [ "05:08", "800000", "030420" ], + "030309" : [ "05:09", "800000", "030420" ], + "030310" : [ "05:10", "800000", "030420" ], + "030311" : [ "05:11", "800000", "030420" ], + "030312" : [ "05:12", "800000", "030420" ], + "030313" : [ "05:13", "800000", "030420" ], + "030314" : [ "05:14", "800000", "030420" ], + "030315" : [ "05:15", "800000", "030420" ], + "030316" : [ "05:16", "800000", "030420" ], + "030317" : [ "05:17", "800000", "030420" ], + "030318" : [ "05:18", "800000", "030420" ], + "030319" : [ "05:19", "800000", "030420" ], + "030320" : [ "05:20", "800000", "030420" ], + "030321" : [ "05:21", "800000", "030420" ], + "030322" : [ "05:22", "800000", "030420" ], + "030323" : [ "05:23", "800000", "030420" ], + "030324" : [ "05:24", "800000", "030420" ], + "030325" : [ "05:25", "800000", "030420" ], + "030326" : [ "05:26", "800000", "030420" ], + "030327" : [ "05:27", "800000", "030420" ], + "030328" : [ "05:28", "800000", "030420" ], + "030329" : [ "05:29", "800000", "030420" ], + "030330" : [ "05:30", "800000", "030420" ], + "030331" : [ "05:31", "800000", "030420" ], + "030332" : [ "05:32", "800000", "030420" ], + "030333" : [ "05:33", "800000", "030420" ], + "030334" : [ "05:34", "800000", "030420" ], + "030335" : [ "05:35", "800000", "030420" ], + "030336" : [ "05:36", "800000", "030420" ], + "030337" : [ "05:37", "800000", "030420" ], + "030338" : [ "05:38", "800000", "030420" ], + "030339" : [ "05:39", "800000", "030420" ], + "030340" : [ "05:40", "800000", "030420" ], + "030341" : [ "05:41", "800000", "030420" ], + "030342" : [ "05:42", "800000", "030420" ], + "030343" : [ "05:43", "800000", "030420" ], + "030344" : [ "05:44", "800000", "030420" ], + "030345" : [ "05:45", "800000", "030420" ], + "030346" : [ "05:46", "800000", "030420" ], + "030347" : [ "05:47", "800000", "030420" ], + "030348" : [ "05:48", "800000", "030420" ], + "030349" : [ "05:49", "800000", "030420" ], + "030350" : [ "05:50", "800000", "030420" ], + "030351" : [ "05:51", "800000", "030420" ], + "030352" : [ "05:52", "800000", "030420" ], + "030353" : [ "05:53", "800000", "030420" ], + "030354" : [ "05:54", "800000", "030420" ], + "030355" : [ "05:55", "800000", "030420" ], + "030356" : [ "05:56", "800000", "030420" ], + "030357" : [ "05:57", "800000", "030420" ], + "030358" : [ "05:58", "800000", "030420" ], + "030359" : [ "05:59", "800000", "030420" ], + "030360" : [ "06:00", "800000", "030420" ], + "030361" : [ "06:01", "800000", "030420" ], + "030362" : [ "06:02", "800000", "030420" ], + "030363" : [ "06:03", "800000", "030420" ], + "030364" : [ "06:04", "800000", "030420" ], + "030365" : [ "06:05", "800000", "030420" ], + "030366" : [ "06:06", "800000", "030420" ], + "030367" : [ "06:07", "800000", "030420" ], + "030368" : [ "06:08", "800000", "030420" ], + "030369" : [ "06:09", "800000", "030420" ], + "030370" : [ "06:10", "800000", "030420" ], + "030371" : [ "06:11", "800000", "030420" ], + "030372" : [ "06:12", "800000", "030420" ], + "030373" : [ "06:13", "800000", "030420" ], + "030374" : [ "06:14", "800000", "030420" ], + "030375" : [ "06:15", "800000", "030420" ], + "030376" : [ "06:16", "800000", "030420" ], + "030377" : [ "06:17", "800000", "030420" ], + "030378" : [ "06:18", "800000", "030420" ], + "030379" : [ "06:19", "800000", "030420" ], + "030380" : [ "06:20", "800000", "030420" ], + "030381" : [ "06:21", "800000", "030420" ], + "030382" : [ "06:22", "800000", "030420" ], + "030383" : [ "06:23", "800000", "030420" ], + "030384" : [ "06:24", "800000", "030420" ], + "030385" : [ "06:25", "800000", "030420" ], + "030386" : [ "06:26", "800000", "030420" ], + "030387" : [ "06:27", "800000", "030420" ], + "030388" : [ "06:28", "800000", "030420" ], + "030389" : [ "06:29", "800000", "030420" ], + "030390" : [ "06:30", "800000", "030420" ], + "030391" : [ "06:31", "800000", "030420" ], + "030392" : [ "06:32", "800000", "030420" ], + "030393" : [ "06:33", "800000", "030420" ], + "030394" : [ "06:34", "800000", "030420" ], + "030395" : [ "06:35", "800000", "030420" ], + "030396" : [ "06:36", "800000", "030420" ], + "030397" : [ "06:37", "800000", "030420" ], + "030398" : [ "06:38", "800000", "030420" ], + "030399" : [ "06:39", "800000", "030420" ], + "030400" : [ "06:40", "800000", "030420" ], + "030401" : [ "06:41", "800000", "030420" ], + "030402" : [ "06:42", "800000", "030420" ], + "030403" : [ "06:43", "800000", "030420" ], + "030404" : [ "06:44", "800000", "030420" ], + "030405" : [ "06:45", "800000", "030420" ], + "030406" : [ "06:46", "800000", "030420" ], + "030407" : [ "06:47", "800000", "030420" ], + "030408" : [ "06:48", "800000", "030420" ], + "030409" : [ "06:49", "800000", "030420" ], + "030410" : [ "06:50", "800000", "030420" ], + "030411" : [ "06:51", "800000", "030420" ], + "030412" : [ "06:52", "800000", "030420" ], + "030413" : [ "06:53", "800000", "030420" ], + "030414" : [ "06:54", "800000", "030420" ], + "030415" : [ "06:55", "800000", "030420" ], + "030416" : [ "06:56", "800000", "030420" ], + "030417" : [ "06:57", "800000", "030420" ], + "030418" : [ "06:58", "800000", "030420" ], + "030419" : [ "06:59", "800000", "030420" ], + "030420" : [ "07:00", "350000", "030480" ], + "030421" : [ "07:01", "350000", "030481" ], + "030422" : [ "07:02", "350000", "030482" ], + "030423" : [ "07:03", "350000", "030483" ], + "030424" : [ "07:04", "350000", "030484" ], + "030425" : [ "07:05", "350000", "030485" ], + "030426" : [ "07:06", "350000", "030486" ], + "030427" : [ "07:07", "350000", "030487" ], + "030428" : [ "07:08", "350000", "030488" ], + "030429" : [ "07:09", "350000", "030489" ], + "030430" : [ "07:10", "350000", "030490" ], + "030431" : [ "07:11", "350000", "030491" ], + "030432" : [ "07:12", "350000", "030492" ], + "030433" : [ "07:13", "350000", "030493" ], + "030434" : [ "07:14", "350000", "030494" ], + "030435" : [ "07:15", "350000", "030495" ], + "030436" : [ "07:16", "350000", "030496" ], + "030437" : [ "07:17", "350000", "030497" ], + "030438" : [ "07:18", "350000", "030498" ], + "030439" : [ "07:19", "350000", "030499" ], + "030440" : [ "07:20", "350000", "030500" ], + "030441" : [ "07:21", "350000", "030501" ], + "030442" : [ "07:22", "350000", "030502" ], + "030443" : [ "07:23", "350000", "030503" ], + "030444" : [ "07:24", "350000", "030504" ], + "030445" : [ "07:25", "350000", "030505" ], + "030446" : [ "07:26", "350000", "030506" ], + "030447" : [ "07:27", "350000", "030507" ], + "030448" : [ "07:28", "350000", "030508" ], + "030449" : [ "07:29", "350000", "030509" ], + "030450" : [ "07:30", "350000", "030510" ], + "030451" : [ "07:31", "350000", "030511" ], + "030452" : [ "07:32", "350000", "030512" ], + "030453" : [ "07:33", "350000", "030513" ], + "030454" : [ "07:34", "350000", "030514" ], + "030455" : [ "07:35", "350000", "030515" ], + "030456" : [ "07:36", "350000", "030516" ], + "030457" : [ "07:37", "350000", "030517" ], + "030458" : [ "07:38", "350000", "030518" ], + "030459" : [ "07:39", "350000", "030519" ], + "030460" : [ "07:40", "350000", "030520" ], + "030461" : [ "07:41", "350000", "030521" ], + "030462" : [ "07:42", "350000", "030522" ], + "030463" : [ "07:43", "350000", "030523" ], + "030464" : [ "07:44", "350000", "030524" ], + "030465" : [ "07:45", "350000", "030525" ], + "030466" : [ "07:46", "350000", "030526" ], + "030467" : [ "07:47", "350000", "030527" ], + "030468" : [ "07:48", "350000", "030528" ], + "030469" : [ "07:49", "350000", "030529" ], + "030470" : [ "07:50", "350000", "030530" ], + "030471" : [ "07:51", "350000", "030531" ], + "030472" : [ "07:52", "350000", "030532" ], + "030473" : [ "07:53", "350000", "030533" ], + "030474" : [ "07:54", "350000", "030534" ], + "030475" : [ "07:55", "350000", "030535" ], + "030476" : [ "07:56", "350000", "030536" ], + "030477" : [ "07:57", "350000", "030537" ], + "030478" : [ "07:58", "350000", "030538" ], + "030479" : [ "07:59", "350000", "030539" ], + "030480" : [ "08:00", "350000", "030540" ], + "030481" : [ "08:01", "350000", "030541" ], + "030482" : [ "08:02", "350000", "030542" ], + "030483" : [ "08:03", "350000", "030543" ], + "030484" : [ "08:04", "350000", "030544" ], + "030485" : [ "08:05", "350000", "030545" ], + "030486" : [ "08:06", "350000", "030546" ], + "030487" : [ "08:07", "350000", "030547" ], + "030488" : [ "08:08", "350000", "030548" ], + "030489" : [ "08:09", "350000", "030549" ], + "030490" : [ "08:10", "350000", "030550" ], + "030491" : [ "08:11", "350000", "030551" ], + "030492" : [ "08:12", "350000", "030552" ], + "030493" : [ "08:13", "350000", "030553" ], + "030494" : [ "08:14", "350000", "030554" ], + "030495" : [ "08:15", "350000", "030555" ], + "030496" : [ "08:16", "350000", "030556" ], + "030497" : [ "08:17", "350000", "030557" ], + "030498" : [ "08:18", "350000", "030558" ], + "030499" : [ "08:19", "350000", "030559" ], + "030500" : [ "08:20", "350000", "030560" ], + "030501" : [ "08:21", "350000", "030561" ], + "030502" : [ "08:22", "350000", "030562" ], + "030503" : [ "08:23", "350000", "030563" ], + "030504" : [ "08:24", "350000", "030564" ], + "030505" : [ "08:25", "350000", "030565" ], + "030506" : [ "08:26", "350000", "030566" ], + "030507" : [ "08:27", "350000", "030567" ], + "030508" : [ "08:28", "350000", "030568" ], + "030509" : [ "08:29", "350000", "030569" ], + "030510" : [ "08:30", "350000", "030570" ], + "030511" : [ "08:31", "350000", "030571" ], + "030512" : [ "08:32", "350000", "030572" ], + "030513" : [ "08:33", "350000", "030573" ], + "030514" : [ "08:34", "350000", "030574" ], + "030515" : [ "08:35", "350000", "030575" ], + "030516" : [ "08:36", "350000", "030576" ], + "030517" : [ "08:37", "350000", "030577" ], + "030518" : [ "08:38", "350000", "030578" ], + "030519" : [ "08:39", "350000", "030579" ], + "030520" : [ "08:40", "350000", "030580" ], + "030521" : [ "08:41", "350000", "030581" ], + "030522" : [ "08:42", "350000", "030582" ], + "030523" : [ "08:43", "350000", "030583" ], + "030524" : [ "08:44", "350000", "030584" ], + "030525" : [ "08:45", "350000", "030585" ], + "030526" : [ "08:46", "350000", "030586" ], + "030527" : [ "08:47", "350000", "030587" ], + "030528" : [ "08:48", "350000", "030588" ], + "030529" : [ "08:49", "350000", "030589" ], + "030530" : [ "08:50", "350000", "030590" ], + "030531" : [ "08:51", "350000", "030591" ], + "030532" : [ "08:52", "350000", "030592" ], + "030533" : [ "08:53", "350000", "030593" ], + "030534" : [ "08:54", "350000", "030594" ], + "030535" : [ "08:55", "350000", "030595" ], + "030536" : [ "08:56", "350000", "030596" ], + "030537" : [ "08:57", "350000", "030597" ], + "030538" : [ "08:58", "350000", "030598" ], + "030539" : [ "08:59", "350000", "030599" ], + "030540" : [ "09:00", "350000", "030600" ], + "030541" : [ "09:01", "350000", "030601" ], + "030542" : [ "09:02", "350000", "030602" ], + "030543" : [ "09:03", "350000", "030603" ], + "030544" : [ "09:04", "350000", "030604" ], + "030545" : [ "09:05", "350000", "030605" ], + "030546" : [ "09:06", "350000", "030606" ], + "030547" : [ "09:07", "350000", "030607" ], + "030548" : [ "09:08", "350000", "030608" ], + "030549" : [ "09:09", "350000", "030609" ], + "030550" : [ "09:10", "350000", "030610" ], + "030551" : [ "09:11", "350000", "030611" ], + "030552" : [ "09:12", "350000", "030612" ], + "030553" : [ "09:13", "350000", "030613" ], + "030554" : [ "09:14", "350000", "030614" ], + "030555" : [ "09:15", "350000", "030615" ], + "030556" : [ "09:16", "350000", "030616" ], + "030557" : [ "09:17", "350000", "030617" ], + "030558" : [ "09:18", "350000", "030618" ], + "030559" : [ "09:19", "350000", "030619" ], + "030560" : [ "09:20", "350000", "030620" ], + "030561" : [ "09:21", "350000", "030621" ], + "030562" : [ "09:22", "350000", "030622" ], + "030563" : [ "09:23", "350000", "030623" ], + "030564" : [ "09:24", "350000", "030624" ], + "030565" : [ "09:25", "350000", "030625" ], + "030566" : [ "09:26", "350000", "030626" ], + "030567" : [ "09:27", "350000", "030627" ], + "030568" : [ "09:28", "350000", "030628" ], + "030569" : [ "09:29", "350000", "030629" ], + "030570" : [ "09:30", "350000", "030630" ], + "030571" : [ "09:31", "350000", "030631" ], + "030572" : [ "09:32", "350000", "030632" ], + "030573" : [ "09:33", "350000", "030633" ], + "030574" : [ "09:34", "350000", "030634" ], + "030575" : [ "09:35", "350000", "030635" ], + "030576" : [ "09:36", "350000", "030636" ], + "030577" : [ "09:37", "350000", "030637" ], + "030578" : [ "09:38", "350000", "030638" ], + "030579" : [ "09:39", "350000", "030639" ], + "030580" : [ "09:40", "350000", "030640" ], + "030581" : [ "09:41", "350000", "030641" ], + "030582" : [ "09:42", "350000", "030642" ], + "030583" : [ "09:43", "350000", "030643" ], + "030584" : [ "09:44", "350000", "030644" ], + "030585" : [ "09:45", "350000", "030645" ], + "030586" : [ "09:46", "350000", "030646" ], + "030587" : [ "09:47", "350000", "030647" ], + "030588" : [ "09:48", "350000", "030648" ], + "030589" : [ "09:49", "350000", "030649" ], + "030590" : [ "09:50", "350000", "030650" ], + "030591" : [ "09:51", "350000", "030651" ], + "030592" : [ "09:52", "350000", "030652" ], + "030593" : [ "09:53", "350000", "030653" ], + "030594" : [ "09:54", "350000", "030654" ], + "030595" : [ "09:55", "350000", "030655" ], + "030596" : [ "09:56", "350000", "030656" ], + "030597" : [ "09:57", "350000", "030657" ], + "030598" : [ "09:58", "350000", "030658" ], + "030599" : [ "09:59", "350000", "030659" ], + "030600" : [ "10:00", "350000", "030660" ], + "030601" : [ "10:01", "350000", "030661" ], + "030602" : [ "10:02", "350000", "030662" ], + "030603" : [ "10:03", "350000", "030663" ], + "030604" : [ "10:04", "350000", "030664" ], + "030605" : [ "10:05", "350000", "030665" ], + "030606" : [ "10:06", "350000", "030666" ], + "030607" : [ "10:07", "350000", "030667" ], + "030608" : [ "10:08", "350000", "030668" ], + "030609" : [ "10:09", "350000", "030669" ], + "030610" : [ "10:10", "350000", "030670" ], + "030611" : [ "10:11", "350000", "030671" ], + "030612" : [ "10:12", "350000", "030672" ], + "030613" : [ "10:13", "350000", "030673" ], + "030614" : [ "10:14", "350000", "030674" ], + "030615" : [ "10:15", "350000", "030675" ], + "030616" : [ "10:16", "350000", "030676" ], + "030617" : [ "10:17", "350000", "030677" ], + "030618" : [ "10:18", "350000", "030678" ], + "030619" : [ "10:19", "350000", "030679" ], + "030620" : [ "10:20", "350000", "030680" ], + "030621" : [ "10:21", "350000", "030681" ], + "030622" : [ "10:22", "350000", "030682" ], + "030623" : [ "10:23", "350000", "030683" ], + "030624" : [ "10:24", "350000", "030684" ], + "030625" : [ "10:25", "350000", "030685" ], + "030626" : [ "10:26", "350000", "030686" ], + "030627" : [ "10:27", "350000", "030687" ], + "030628" : [ "10:28", "350000", "030688" ], + "030629" : [ "10:29", "350000", "030689" ], + "030630" : [ "10:30", "350000", "030690" ], + "030631" : [ "10:31", "350000", "030691" ], + "030632" : [ "10:32", "350000", "030692" ], + "030633" : [ "10:33", "350000", "030693" ], + "030634" : [ "10:34", "350000", "030694" ], + "030635" : [ "10:35", "350000", "030695" ], + "030636" : [ "10:36", "350000", "030696" ], + "030637" : [ "10:37", "350000", "030697" ], + "030638" : [ "10:38", "350000", "030698" ], + "030639" : [ "10:39", "350000", "030699" ], + "030640" : [ "10:40", "350000", "030700" ], + "030641" : [ "10:41", "350000", "030701" ], + "030642" : [ "10:42", "350000", "030702" ], + "030643" : [ "10:43", "350000", "030703" ], + "030644" : [ "10:44", "350000", "030704" ], + "030645" : [ "10:45", "350000", "030705" ], + "030646" : [ "10:46", "350000", "030706" ], + "030647" : [ "10:47", "350000", "030707" ], + "030648" : [ "10:48", "350000", "030708" ], + "030649" : [ "10:49", "350000", "030709" ], + "030650" : [ "10:50", "350000", "030710" ], + "030651" : [ "10:51", "350000", "030711" ], + "030652" : [ "10:52", "350000", "030712" ], + "030653" : [ "10:53", "350000", "030713" ], + "030654" : [ "10:54", "350000", "030714" ], + "030655" : [ "10:55", "350000", "030715" ], + "030656" : [ "10:56", "350000", "030716" ], + "030657" : [ "10:57", "350000", "030717" ], + "030658" : [ "10:58", "350000", "030718" ], + "030659" : [ "10:59", "350000", "030719" ], + "030660" : [ "11:00", "350000", "030720" ], + "030661" : [ "11:01", "350000", "030721" ], + "030662" : [ "11:02", "350000", "030722" ], + "030663" : [ "11:03", "350000", "030723" ], + "030664" : [ "11:04", "350000", "030724" ], + "030665" : [ "11:05", "350000", "030725" ], + "030666" : [ "11:06", "350000", "030726" ], + "030667" : [ "11:07", "350000", "030727" ], + "030668" : [ "11:08", "350000", "030728" ], + "030669" : [ "11:09", "350000", "030729" ], + "030670" : [ "11:10", "350000", "030730" ], + "030671" : [ "11:11", "350000", "030731" ], + "030672" : [ "11:12", "350000", "030732" ], + "030673" : [ "11:13", "350000", "030733" ], + "030674" : [ "11:14", "350000", "030734" ], + "030675" : [ "11:15", "350000", "030735" ], + "030676" : [ "11:16", "350000", "030736" ], + "030677" : [ "11:17", "350000", "030737" ], + "030678" : [ "11:18", "350000", "030738" ], + "030679" : [ "11:19", "350000", "030739" ], + "030680" : [ "11:20", "350000", "030740" ], + "030681" : [ "11:21", "350000", "030741" ], + "030682" : [ "11:22", "350000", "030742" ], + "030683" : [ "11:23", "350000", "030743" ], + "030684" : [ "11:24", "350000", "030744" ], + "030685" : [ "11:25", "350000", "030745" ], + "030686" : [ "11:26", "350000", "030746" ], + "030687" : [ "11:27", "350000", "030747" ], + "030688" : [ "11:28", "350000", "030748" ], + "030689" : [ "11:29", "350000", "030749" ], + "030690" : [ "11:30", "350000", "030750" ], + "030691" : [ "11:31", "350000", "030751" ], + "030692" : [ "11:32", "350000", "030752" ], + "030693" : [ "11:33", "350000", "030753" ], + "030694" : [ "11:34", "350000", "030754" ], + "030695" : [ "11:35", "350000", "030755" ], + "030696" : [ "11:36", "350000", "030756" ], + "030697" : [ "11:37", "350000", "030757" ], + "030698" : [ "11:38", "350000", "030758" ], + "030699" : [ "11:39", "350000", "030759" ], + "030700" : [ "11:40", "350000", "030760" ], + "030701" : [ "11:41", "350000", "030761" ], + "030702" : [ "11:42", "350000", "030762" ], + "030703" : [ "11:43", "350000", "030763" ], + "030704" : [ "11:44", "350000", "030764" ], + "030705" : [ "11:45", "350000", "030765" ], + "030706" : [ "11:46", "350000", "030766" ], + "030707" : [ "11:47", "350000", "030767" ], + "030708" : [ "11:48", "350000", "030768" ], + "030709" : [ "11:49", "350000", "030769" ], + "030710" : [ "11:50", "350000", "030770" ], + "030711" : [ "11:51", "350000", "030771" ], + "030712" : [ "11:52", "350000", "030772" ], + "030713" : [ "11:53", "350000", "030773" ], + "030714" : [ "11:54", "350000", "030774" ], + "030715" : [ "11:55", "350000", "030775" ], + "030716" : [ "11:56", "350000", "030776" ], + "030717" : [ "11:57", "350000", "030777" ], + "030718" : [ "11:58", "350000", "030778" ], + "030719" : [ "11:59", "350000", "030779" ], + "030720" : [ "12:00", "350000", "030780" ], + "030721" : [ "12:01", "350000", "030781" ], + "030722" : [ "12:02", "350000", "030782" ], + "030723" : [ "12:03", "350000", "030783" ], + "030724" : [ "12:04", "350000", "030784" ], + "030725" : [ "12:05", "350000", "030785" ], + "030726" : [ "12:06", "350000", "030786" ], + "030727" : [ "12:07", "350000", "030787" ], + "030728" : [ "12:08", "350000", "030788" ], + "030729" : [ "12:09", "350000", "030789" ], + "030730" : [ "12:10", "350000", "030790" ], + "030731" : [ "12:11", "350000", "030791" ], + "030732" : [ "12:12", "350000", "030792" ], + "030733" : [ "12:13", "350000", "030793" ], + "030734" : [ "12:14", "350000", "030794" ], + "030735" : [ "12:15", "350000", "030795" ], + "030736" : [ "12:16", "350000", "030796" ], + "030737" : [ "12:17", "350000", "030797" ], + "030738" : [ "12:18", "350000", "030798" ], + "030739" : [ "12:19", "350000", "030799" ], + "030740" : [ "12:20", "350000", "030800" ], + "030741" : [ "12:21", "350000", "030801" ], + "030742" : [ "12:22", "350000", "030802" ], + "030743" : [ "12:23", "350000", "030803" ], + "030744" : [ "12:24", "350000", "030804" ], + "030745" : [ "12:25", "350000", "030805" ], + "030746" : [ "12:26", "350000", "030806" ], + "030747" : [ "12:27", "350000", "030807" ], + "030748" : [ "12:28", "350000", "030808" ], + "030749" : [ "12:29", "350000", "030809" ], + "030750" : [ "12:30", "350000", "030810" ], + "030751" : [ "12:31", "350000", "030811" ], + "030752" : [ "12:32", "350000", "030812" ], + "030753" : [ "12:33", "350000", "030813" ], + "030754" : [ "12:34", "350000", "030814" ], + "030755" : [ "12:35", "350000", "030815" ], + "030756" : [ "12:36", "350000", "030816" ], + "030757" : [ "12:37", "350000", "030817" ], + "030758" : [ "12:38", "350000", "030818" ], + "030759" : [ "12:39", "350000", "030819" ], + "030760" : [ "12:40", "350000", "030820" ], + "030761" : [ "12:41", "350000", "030821" ], + "030762" : [ "12:42", "350000", "030822" ], + "030763" : [ "12:43", "350000", "030823" ], + "030764" : [ "12:44", "350000", "030824" ], + "030765" : [ "12:45", "350000", "030825" ], + "030766" : [ "12:46", "350000", "030826" ], + "030767" : [ "12:47", "350000", "030827" ], + "030768" : [ "12:48", "350000", "030828" ], + "030769" : [ "12:49", "350000", "030829" ], + "030770" : [ "12:50", "350000", "030830" ], + "030771" : [ "12:51", "350000", "030831" ], + "030772" : [ "12:52", "350000", "030832" ], + "030773" : [ "12:53", "350000", "030833" ], + "030774" : [ "12:54", "350000", "030834" ], + "030775" : [ "12:55", "350000", "030835" ], + "030776" : [ "12:56", "350000", "030836" ], + "030777" : [ "12:57", "350000", "030837" ], + "030778" : [ "12:58", "350000", "030838" ], + "030779" : [ "12:59", "350000", "030839" ], + "030780" : [ "13:00", "350000", "030840" ], + "030781" : [ "13:01", "350000", "030841" ], + "030782" : [ "13:02", "350000", "030842" ], + "030783" : [ "13:03", "350000", "030843" ], + "030784" : [ "13:04", "350000", "030844" ], + "030785" : [ "13:05", "350000", "030845" ], + "030786" : [ "13:06", "350000", "030846" ], + "030787" : [ "13:07", "350000", "030847" ], + "030788" : [ "13:08", "350000", "030848" ], + "030789" : [ "13:09", "350000", "030849" ], + "030790" : [ "13:10", "350000", "030850" ], + "030791" : [ "13:11", "350000", "030851" ], + "030792" : [ "13:12", "350000", "030852" ], + "030793" : [ "13:13", "350000", "030853" ], + "030794" : [ "13:14", "350000", "030854" ], + "030795" : [ "13:15", "350000", "030855" ], + "030796" : [ "13:16", "350000", "030856" ], + "030797" : [ "13:17", "350000", "030857" ], + "030798" : [ "13:18", "350000", "030858" ], + "030799" : [ "13:19", "350000", "030859" ], + "030800" : [ "13:20", "350000", "030860" ], + "030801" : [ "13:21", "350000", "030861" ], + "030802" : [ "13:22", "350000", "030862" ], + "030803" : [ "13:23", "350000", "030863" ], + "030804" : [ "13:24", "350000", "030864" ], + "030805" : [ "13:25", "350000", "030865" ], + "030806" : [ "13:26", "350000", "030866" ], + "030807" : [ "13:27", "350000", "030867" ], + "030808" : [ "13:28", "350000", "030868" ], + "030809" : [ "13:29", "350000", "030869" ], + "030810" : [ "13:30", "350000", "030870" ], + "030811" : [ "13:31", "350000", "030871" ], + "030812" : [ "13:32", "350000", "030872" ], + "030813" : [ "13:33", "350000", "030873" ], + "030814" : [ "13:34", "350000", "030874" ], + "030815" : [ "13:35", "350000", "030875" ], + "030816" : [ "13:36", "350000", "030876" ], + "030817" : [ "13:37", "350000", "030877" ], + "030818" : [ "13:38", "350000", "030878" ], + "030819" : [ "13:39", "350000", "030879" ], + "030820" : [ "13:40", "350000", "030880" ], + "030821" : [ "13:41", "350000", "030881" ], + "030822" : [ "13:42", "350000", "030882" ], + "030823" : [ "13:43", "350000", "030883" ], + "030824" : [ "13:44", "350000", "030884" ], + "030825" : [ "13:45", "350000", "030885" ], + "030826" : [ "13:46", "350000", "030886" ], + "030827" : [ "13:47", "350000", "030887" ], + "030828" : [ "13:48", "350000", "030888" ], + "030829" : [ "13:49", "350000", "030889" ], + "030830" : [ "13:50", "350000", "030890" ], + "030831" : [ "13:51", "350000", "030891" ], + "030832" : [ "13:52", "350000", "030892" ], + "030833" : [ "13:53", "350000", "030893" ], + "030834" : [ "13:54", "350000", "030894" ], + "030835" : [ "13:55", "350000", "030895" ], + "030836" : [ "13:56", "350000", "030896" ], + "030837" : [ "13:57", "350000", "030897" ], + "030838" : [ "13:58", "350000", "030898" ], + "030839" : [ "13:59", "350000", "030899" ], + "030840" : [ "14:00", "350000", "030900" ], + "030841" : [ "14:01", "350000", "030901" ], + "030842" : [ "14:02", "350000", "030902" ], + "030843" : [ "14:03", "350000", "030903" ], + "030844" : [ "14:04", "350000", "030904" ], + "030845" : [ "14:05", "350000", "030905" ], + "030846" : [ "14:06", "350000", "030906" ], + "030847" : [ "14:07", "350000", "030907" ], + "030848" : [ "14:08", "350000", "030908" ], + "030849" : [ "14:09", "350000", "030909" ], + "030850" : [ "14:10", "350000", "030910" ], + "030851" : [ "14:11", "350000", "030911" ], + "030852" : [ "14:12", "350000", "030912" ], + "030853" : [ "14:13", "350000", "030913" ], + "030854" : [ "14:14", "350000", "030914" ], + "030855" : [ "14:15", "350000", "030915" ], + "030856" : [ "14:16", "350000", "030916" ], + "030857" : [ "14:17", "350000", "030917" ], + "030858" : [ "14:18", "350000", "030918" ], + "030859" : [ "14:19", "350000", "030919" ], + "030860" : [ "14:20", "350000", "030920" ], + "030861" : [ "14:21", "350000", "030921" ], + "030862" : [ "14:22", "350000", "030922" ], + "030863" : [ "14:23", "350000", "030923" ], + "030864" : [ "14:24", "350000", "030924" ], + "030865" : [ "14:25", "350000", "030925" ], + "030866" : [ "14:26", "350000", "030926" ], + "030867" : [ "14:27", "350000", "030927" ], + "030868" : [ "14:28", "350000", "030928" ], + "030869" : [ "14:29", "350000", "030929" ], + "030870" : [ "14:30", "350000", "030930" ], + "030871" : [ "14:31", "350000", "030931" ], + "030872" : [ "14:32", "350000", "030932" ], + "030873" : [ "14:33", "350000", "030933" ], + "030874" : [ "14:34", "350000", "030934" ], + "030875" : [ "14:35", "350000", "030935" ], + "030876" : [ "14:36", "350000", "030936" ], + "030877" : [ "14:37", "350000", "030937" ], + "030878" : [ "14:38", "350000", "030938" ], + "030879" : [ "14:39", "350000", "030939" ], + "030880" : [ "14:40", "350000", "030940" ], + "030881" : [ "14:41", "350000", "030941" ], + "030882" : [ "14:42", "350000", "030942" ], + "030883" : [ "14:43", "350000", "030943" ], + "030884" : [ "14:44", "350000", "030944" ], + "030885" : [ "14:45", "350000", "030945" ], + "030886" : [ "14:46", "350000", "030946" ], + "030887" : [ "14:47", "350000", "030947" ], + "030888" : [ "14:48", "350000", "030948" ], + "030889" : [ "14:49", "350000", "030949" ], + "030890" : [ "14:50", "350000", "030950" ], + "030891" : [ "14:51", "350000", "030951" ], + "030892" : [ "14:52", "350000", "030952" ], + "030893" : [ "14:53", "350000", "030953" ], + "030894" : [ "14:54", "350000", "030954" ], + "030895" : [ "14:55", "350000", "030955" ], + "030896" : [ "14:56", "350000", "030956" ], + "030897" : [ "14:57", "350000", "030957" ], + "030898" : [ "14:58", "350000", "030958" ], + "030899" : [ "14:59", "350000", "030959" ], + "030900" : [ "15:00", "350000", "030960" ], + "030901" : [ "15:01", "350000", "030961" ], + "030902" : [ "15:02", "350000", "030962" ], + "030903" : [ "15:03", "350000", "030963" ], + "030904" : [ "15:04", "350000", "030964" ], + "030905" : [ "15:05", "350000", "030965" ], + "030906" : [ "15:06", "350000", "030966" ], + "030907" : [ "15:07", "350000", "030967" ], + "030908" : [ "15:08", "350000", "030968" ], + "030909" : [ "15:09", "350000", "030969" ], + "030910" : [ "15:10", "350000", "030970" ], + "030911" : [ "15:11", "350000", "030971" ], + "030912" : [ "15:12", "350000", "030972" ], + "030913" : [ "15:13", "350000", "030973" ], + "030914" : [ "15:14", "350000", "030974" ], + "030915" : [ "15:15", "350000", "030975" ], + "030916" : [ "15:16", "350000", "030976" ], + "030917" : [ "15:17", "350000", "030977" ], + "030918" : [ "15:18", "350000", "030978" ], + "030919" : [ "15:19", "350000", "030979" ], + "030920" : [ "15:20", "350000", "030980" ], + "030921" : [ "15:21", "350000", "030981" ], + "030922" : [ "15:22", "350000", "030982" ], + "030923" : [ "15:23", "350000", "030983" ], + "030924" : [ "15:24", "350000", "030984" ], + "030925" : [ "15:25", "350000", "030985" ], + "030926" : [ "15:26", "350000", "030986" ], + "030927" : [ "15:27", "350000", "030987" ], + "030928" : [ "15:28", "350000", "030988" ], + "030929" : [ "15:29", "350000", "030989" ], + "030930" : [ "15:30", "350000", "030990" ], + "030931" : [ "15:31", "350000", "030991" ], + "030932" : [ "15:32", "350000", "030992" ], + "030933" : [ "15:33", "350000", "030993" ], + "030934" : [ "15:34", "350000", "030994" ], + "030935" : [ "15:35", "350000", "030995" ], + "030936" : [ "15:36", "350000", "030996" ], + "030937" : [ "15:37", "350000", "030997" ], + "030938" : [ "15:38", "350000", "030998" ], + "030939" : [ "15:39", "350000", "030999" ], + "030940" : [ "15:40", "350000", "031000" ], + "030941" : [ "15:41", "350000", "031001" ], + "030942" : [ "15:42", "350000", "031002" ], + "030943" : [ "15:43", "350000", "031003" ], + "030944" : [ "15:44", "350000", "031004" ], + "030945" : [ "15:45", "350000", "031005" ], + "030946" : [ "15:46", "350000", "031006" ], + "030947" : [ "15:47", "350000", "031007" ], + "030948" : [ "15:48", "350000", "031008" ], + "030949" : [ "15:49", "350000", "031009" ], + "030950" : [ "15:50", "350000", "031010" ], + "030951" : [ "15:51", "350000", "031011" ], + "030952" : [ "15:52", "350000", "031012" ], + "030953" : [ "15:53", "350000", "031013" ], + "030954" : [ "15:54", "350000", "031014" ], + "030955" : [ "15:55", "350000", "031015" ], + "030956" : [ "15:56", "350000", "031016" ], + "030957" : [ "15:57", "350000", "031017" ], + "030958" : [ "15:58", "350000", "031018" ], + "030959" : [ "15:59", "350000", "031019" ], + "030960" : [ "16:00", "350000", "031020" ], + "030961" : [ "16:01", "350000", "031021" ], + "030962" : [ "16:02", "350000", "031022" ], + "030963" : [ "16:03", "350000", "031023" ], + "030964" : [ "16:04", "350000", "031024" ], + "030965" : [ "16:05", "350000", "031025" ], + "030966" : [ "16:06", "350000", "031026" ], + "030967" : [ "16:07", "350000", "031027" ], + "030968" : [ "16:08", "350000", "031028" ], + "030969" : [ "16:09", "350000", "031029" ], + "030970" : [ "16:10", "350000", "031030" ], + "030971" : [ "16:11", "350000", "031031" ], + "030972" : [ "16:12", "350000", "031032" ], + "030973" : [ "16:13", "350000", "031033" ], + "030974" : [ "16:14", "350000", "031034" ], + "030975" : [ "16:15", "350000", "031035" ], + "030976" : [ "16:16", "350000", "031036" ], + "030977" : [ "16:17", "350000", "031037" ], + "030978" : [ "16:18", "350000", "031038" ], + "030979" : [ "16:19", "350000", "031039" ], + "030980" : [ "16:20", "350000", "031040" ], + "030981" : [ "16:21", "350000", "031041" ], + "030982" : [ "16:22", "350000", "031042" ], + "030983" : [ "16:23", "350000", "031043" ], + "030984" : [ "16:24", "350000", "031044" ], + "030985" : [ "16:25", "350000", "031045" ], + "030986" : [ "16:26", "350000", "031046" ], + "030987" : [ "16:27", "350000", "031047" ], + "030988" : [ "16:28", "350000", "031048" ], + "030989" : [ "16:29", "350000", "031049" ], + "030990" : [ "16:30", "350000", "031050" ], + "030991" : [ "16:31", "350000", "031051" ], + "030992" : [ "16:32", "350000", "031052" ], + "030993" : [ "16:33", "350000", "031053" ], + "030994" : [ "16:34", "350000", "031054" ], + "030995" : [ "16:35", "350000", "031055" ], + "030996" : [ "16:36", "350000", "031056" ], + "030997" : [ "16:37", "350000", "031057" ], + "030998" : [ "16:38", "350000", "031058" ], + "030999" : [ "16:39", "350000", "031059" ], + "031000" : [ "16:40", "350000", "031060" ], + "031001" : [ "16:41", "350000", "031061" ], + "031002" : [ "16:42", "350000", "031062" ], + "031003" : [ "16:43", "350000", "031063" ], + "031004" : [ "16:44", "350000", "031064" ], + "031005" : [ "16:45", "350000", "031065" ], + "031006" : [ "16:46", "350000", "031066" ], + "031007" : [ "16:47", "350000", "031067" ], + "031008" : [ "16:48", "350000", "031068" ], + "031009" : [ "16:49", "350000", "031069" ], + "031010" : [ "16:50", "350000", "031070" ], + "031011" : [ "16:51", "350000", "031071" ], + "031012" : [ "16:52", "350000", "031072" ], + "031013" : [ "16:53", "350000", "031073" ], + "031014" : [ "16:54", "350000", "031074" ], + "031015" : [ "16:55", "350000", "031075" ], + "031016" : [ "16:56", "350000", "031076" ], + "031017" : [ "16:57", "350000", "031077" ], + "031018" : [ "16:58", "350000", "031078" ], + "031019" : [ "16:59", "350000", "031079" ], + "031020" : [ "17:00", "350000", "031080" ], + "031021" : [ "17:01", "350000", "031081" ], + "031022" : [ "17:02", "350000", "031082" ], + "031023" : [ "17:03", "350000", "031083" ], + "031024" : [ "17:04", "350000", "031084" ], + "031025" : [ "17:05", "350000", "031085" ], + "031026" : [ "17:06", "350000", "031086" ], + "031027" : [ "17:07", "350000", "031087" ], + "031028" : [ "17:08", "350000", "031088" ], + "031029" : [ "17:09", "350000", "031089" ], + "031030" : [ "17:10", "350000", "031090" ], + "031031" : [ "17:11", "350000", "031091" ], + "031032" : [ "17:12", "350000", "031092" ], + "031033" : [ "17:13", "350000", "031093" ], + "031034" : [ "17:14", "350000", "031094" ], + "031035" : [ "17:15", "350000", "031095" ], + "031036" : [ "17:16", "350000", "031096" ], + "031037" : [ "17:17", "350000", "031097" ], + "031038" : [ "17:18", "350000", "031098" ], + "031039" : [ "17:19", "350000", "031099" ], + "031040" : [ "17:20", "350000", "031100" ], + "031041" : [ "17:21", "350000", "031101" ], + "031042" : [ "17:22", "350000", "031102" ], + "031043" : [ "17:23", "350000", "031103" ], + "031044" : [ "17:24", "350000", "031104" ], + "031045" : [ "17:25", "350000", "031105" ], + "031046" : [ "17:26", "350000", "031106" ], + "031047" : [ "17:27", "350000", "031107" ], + "031048" : [ "17:28", "350000", "031108" ], + "031049" : [ "17:29", "350000", "031109" ], + "031050" : [ "17:30", "350000", "031110" ], + "031051" : [ "17:31", "350000", "031111" ], + "031052" : [ "17:32", "350000", "031112" ], + "031053" : [ "17:33", "350000", "031113" ], + "031054" : [ "17:34", "350000", "031114" ], + "031055" : [ "17:35", "350000", "031115" ], + "031056" : [ "17:36", "350000", "031116" ], + "031057" : [ "17:37", "350000", "031117" ], + "031058" : [ "17:38", "350000", "031118" ], + "031059" : [ "17:39", "350000", "031119" ], + "031060" : [ "17:40", "350000", "031120" ], + "031061" : [ "17:41", "350000", "031121" ], + "031062" : [ "17:42", "350000", "031122" ], + "031063" : [ "17:43", "350000", "031123" ], + "031064" : [ "17:44", "350000", "031124" ], + "031065" : [ "17:45", "350000", "031125" ], + "031066" : [ "17:46", "350000", "031126" ], + "031067" : [ "17:47", "350000", "031127" ], + "031068" : [ "17:48", "350000", "031128" ], + "031069" : [ "17:49", "350000", "031129" ], + "031070" : [ "17:50", "350000", "031130" ], + "031071" : [ "17:51", "350000", "031131" ], + "031072" : [ "17:52", "350000", "031132" ], + "031073" : [ "17:53", "350000", "031133" ], + "031074" : [ "17:54", "350000", "031134" ], + "031075" : [ "17:55", "350000", "031135" ], + "031076" : [ "17:56", "350000", "031136" ], + "031077" : [ "17:57", "350000", "031137" ], + "031078" : [ "17:58", "350000", "031138" ], + "031079" : [ "17:59", "350000", "031139" ], + "031080" : [ "18:00", "350000", "031140" ], + "031081" : [ "18:01", "350000", "031141" ], + "031082" : [ "18:02", "350000", "031142" ], + "031083" : [ "18:03", "350000", "031143" ], + "031084" : [ "18:04", "350000", "031144" ], + "031085" : [ "18:05", "350000", "031145" ], + "031086" : [ "18:06", "350000", "031146" ], + "031087" : [ "18:07", "350000", "031147" ], + "031088" : [ "18:08", "350000", "031148" ], + "031089" : [ "18:09", "350000", "031149" ], + "031090" : [ "18:10", "350000", "031150" ], + "031091" : [ "18:11", "350000", "031151" ], + "031092" : [ "18:12", "350000", "031152" ], + "031093" : [ "18:13", "350000", "031153" ], + "031094" : [ "18:14", "350000", "031154" ], + "031095" : [ "18:15", "350000", "031155" ], + "031096" : [ "18:16", "350000", "031156" ], + "031097" : [ "18:17", "350000", "031157" ], + "031098" : [ "18:18", "350000", "031158" ], + "031099" : [ "18:19", "350000", "031159" ], + "031100" : [ "18:20", "350000", "031160" ], + "031101" : [ "18:21", "350000", "031161" ], + "031102" : [ "18:22", "350000", "031162" ], + "031103" : [ "18:23", "350000", "031163" ], + "031104" : [ "18:24", "350000", "031164" ], + "031105" : [ "18:25", "350000", "031165" ], + "031106" : [ "18:26", "350000", "031166" ], + "031107" : [ "18:27", "350000", "031167" ], + "031108" : [ "18:28", "350000", "031168" ], + "031109" : [ "18:29", "350000", "031169" ], + "031110" : [ "18:30", "350000", "031170" ], + "031111" : [ "18:31", "350000", "031171" ], + "031112" : [ "18:32", "350000", "031172" ], + "031113" : [ "18:33", "350000", "031173" ], + "031114" : [ "18:34", "350000", "031174" ], + "031115" : [ "18:35", "350000", "031175" ], + "031116" : [ "18:36", "350000", "031176" ], + "031117" : [ "18:37", "350000", "031177" ], + "031118" : [ "18:38", "350000", "031178" ], + "031119" : [ "18:39", "350000", "031179" ], + "031120" : [ "18:40", "350000", "031180" ], + "031121" : [ "18:41", "350000", "031181" ], + "031122" : [ "18:42", "350000", "031182" ], + "031123" : [ "18:43", "350000", "031183" ], + "031124" : [ "18:44", "350000", "031184" ], + "031125" : [ "18:45", "350000", "031185" ], + "031126" : [ "18:46", "350000", "031186" ], + "031127" : [ "18:47", "350000", "031187" ], + "031128" : [ "18:48", "350000", "031188" ], + "031129" : [ "18:49", "350000", "031189" ], + "031130" : [ "18:50", "350000", "031190" ], + "031131" : [ "18:51", "350000", "031191" ], + "031132" : [ "18:52", "350000", "031192" ], + "031133" : [ "18:53", "350000", "031193" ], + "031134" : [ "18:54", "350000", "031194" ], + "031135" : [ "18:55", "350000", "031195" ], + "031136" : [ "18:56", "350000", "031196" ], + "031137" : [ "18:57", "350000", "031197" ], + "031138" : [ "18:58", "350000", "031198" ], + "031139" : [ "18:59", "350000", "031199" ], + "031140" : [ "19:00", "350000", "031200" ], + "031141" : [ "19:01", "350000", "031200" ], + "031142" : [ "19:02", "350000", "031200" ], + "031143" : [ "19:03", "350000", "031200" ], + "031144" : [ "19:04", "350000", "031200" ], + "031145" : [ "19:05", "350000", "031200" ], + "031146" : [ "19:06", "350000", "031200" ], + "031147" : [ "19:07", "350000", "031200" ], + "031148" : [ "19:08", "350000", "031200" ], + "031149" : [ "19:09", "350000", "031200" ], + "031150" : [ "19:10", "350000", "031200" ], + "031151" : [ "19:11", "350000", "031200" ], + "031152" : [ "19:12", "350000", "031200" ], + "031153" : [ "19:13", "350000", "031200" ], + "031154" : [ "19:14", "350000", "031200" ], + "031155" : [ "19:15", "350000", "031200" ], + "031156" : [ "19:16", "350000", "031200" ], + "031157" : [ "19:17", "350000", "031200" ], + "031158" : [ "19:18", "350000", "031200" ], + "031159" : [ "19:19", "350000", "031200" ], + "031160" : [ "19:20", "350000", "031200" ], + "031161" : [ "19:21", "350000", "031200" ], + "031162" : [ "19:22", "350000", "031200" ], + "031163" : [ "19:23", "350000", "031200" ], + "031164" : [ "19:24", "350000", "031200" ], + "031165" : [ "19:25", "350000", "031200" ], + "031166" : [ "19:26", "350000", "031200" ], + "031167" : [ "19:27", "350000", "031200" ], + "031168" : [ "19:28", "350000", "031200" ], + "031169" : [ "19:29", "350000", "031200" ], + "031170" : [ "19:30", "350000", "031200" ], + "031171" : [ "19:31", "350000", "031200" ], + "031172" : [ "19:32", "350000", "031200" ], + "031173" : [ "19:33", "350000", "031200" ], + "031174" : [ "19:34", "350000", "031200" ], + "031175" : [ "19:35", "350000", "031200" ], + "031176" : [ "19:36", "350000", "031200" ], + "031177" : [ "19:37", "350000", "031200" ], + "031178" : [ "19:38", "350000", "031200" ], + "031179" : [ "19:39", "350000", "031200" ], + "031180" : [ "19:40", "350000", "031200" ], + "031181" : [ "19:41", "350000", "031200" ], + "031182" : [ "19:42", "350000", "031200" ], + "031183" : [ "19:43", "350000", "031200" ], + "031184" : [ "19:44", "350000", "031200" ], + "031185" : [ "19:45", "350000", "031200" ], + "031186" : [ "19:46", "350000", "031200" ], + "031187" : [ "19:47", "350000", "031200" ], + "031188" : [ "19:48", "350000", "031200" ], + "031189" : [ "19:49", "350000", "031200" ], + "031190" : [ "19:50", "350000", "031200" ], + "031191" : [ "19:51", "350000", "031200" ], + "031192" : [ "19:52", "350000", "031200" ], + "031193" : [ "19:53", "350000", "031200" ], + "031194" : [ "19:54", "350000", "031200" ], + "031195" : [ "19:55", "350000", "031200" ], + "031196" : [ "19:56", "350000", "031200" ], + "031197" : [ "19:57", "350000", "031200" ], + "031198" : [ "19:58", "350000", "031200" ], + "031199" : [ "19:59", "350000", "031200" ], + "031200" : [ "20:00", "800000", "040420" ], + "031201" : [ "20:01", "800000", "040420" ], + "031202" : [ "20:02", "800000", "040420" ], + "031203" : [ "20:03", "800000", "040420" ], + "031204" : [ "20:04", "800000", "040420" ], + "031205" : [ "20:05", "800000", "040420" ], + "031206" : [ "20:06", "800000", "040420" ], + "031207" : [ "20:07", "800000", "040420" ], + "031208" : [ "20:08", "800000", "040420" ], + "031209" : [ "20:09", "800000", "040420" ], + "031210" : [ "20:10", "800000", "040420" ], + "031211" : [ "20:11", "800000", "040420" ], + "031212" : [ "20:12", "800000", "040420" ], + "031213" : [ "20:13", "800000", "040420" ], + "031214" : [ "20:14", "800000", "040420" ], + "031215" : [ "20:15", "800000", "040420" ], + "031216" : [ "20:16", "800000", "040420" ], + "031217" : [ "20:17", "800000", "040420" ], + "031218" : [ "20:18", "800000", "040420" ], + "031219" : [ "20:19", "800000", "040420" ], + "031220" : [ "20:20", "800000", "040420" ], + "031221" : [ "20:21", "800000", "040420" ], + "031222" : [ "20:22", "800000", "040420" ], + "031223" : [ "20:23", "800000", "040420" ], + "031224" : [ "20:24", "800000", "040420" ], + "031225" : [ "20:25", "800000", "040420" ], + "031226" : [ "20:26", "800000", "040420" ], + "031227" : [ "20:27", "800000", "040420" ], + "031228" : [ "20:28", "800000", "040420" ], + "031229" : [ "20:29", "800000", "040420" ], + "031230" : [ "20:30", "800000", "040420" ], + "031231" : [ "20:31", "800000", "040420" ], + "031232" : [ "20:32", "800000", "040420" ], + "031233" : [ "20:33", "800000", "040420" ], + "031234" : [ "20:34", "800000", "040420" ], + "031235" : [ "20:35", "800000", "040420" ], + "031236" : [ "20:36", "800000", "040420" ], + "031237" : [ "20:37", "800000", "040420" ], + "031238" : [ "20:38", "800000", "040420" ], + "031239" : [ "20:39", "800000", "040420" ], + "031240" : [ "20:40", "800000", "040420" ], + "031241" : [ "20:41", "800000", "040420" ], + "031242" : [ "20:42", "800000", "040420" ], + "031243" : [ "20:43", "800000", "040420" ], + "031244" : [ "20:44", "800000", "040420" ], + "031245" : [ "20:45", "800000", "040420" ], + "031246" : [ "20:46", "800000", "040420" ], + "031247" : [ "20:47", "800000", "040420" ], + "031248" : [ "20:48", "800000", "040420" ], + "031249" : [ "20:49", "800000", "040420" ], + "031250" : [ "20:50", "800000", "040420" ], + "031251" : [ "20:51", "800000", "040420" ], + "031252" : [ "20:52", "800000", "040420" ], + "031253" : [ "20:53", "800000", "040420" ], + "031254" : [ "20:54", "800000", "040420" ], + "031255" : [ "20:55", "800000", "040420" ], + "031256" : [ "20:56", "800000", "040420" ], + "031257" : [ "20:57", "800000", "040420" ], + "031258" : [ "20:58", "800000", "040420" ], + "031259" : [ "20:59", "800000", "040420" ], + "031260" : [ "21:00", "800000", "040420" ], + "031261" : [ "21:01", "800000", "040420" ], + "031262" : [ "21:02", "800000", "040420" ], + "031263" : [ "21:03", "800000", "040420" ], + "031264" : [ "21:04", "800000", "040420" ], + "031265" : [ "21:05", "800000", "040420" ], + "031266" : [ "21:06", "800000", "040420" ], + "031267" : [ "21:07", "800000", "040420" ], + "031268" : [ "21:08", "800000", "040420" ], + "031269" : [ "21:09", "800000", "040420" ], + "031270" : [ "21:10", "800000", "040420" ], + "031271" : [ "21:11", "800000", "040420" ], + "031272" : [ "21:12", "800000", "040420" ], + "031273" : [ "21:13", "800000", "040420" ], + "031274" : [ "21:14", "800000", "040420" ], + "031275" : [ "21:15", "800000", "040420" ], + "031276" : [ "21:16", "800000", "040420" ], + "031277" : [ "21:17", "800000", "040420" ], + "031278" : [ "21:18", "800000", "040420" ], + "031279" : [ "21:19", "800000", "040420" ], + "031280" : [ "21:20", "800000", "040420" ], + "031281" : [ "21:21", "800000", "040420" ], + "031282" : [ "21:22", "800000", "040420" ], + "031283" : [ "21:23", "800000", "040420" ], + "031284" : [ "21:24", "800000", "040420" ], + "031285" : [ "21:25", "800000", "040420" ], + "031286" : [ "21:26", "800000", "040420" ], + "031287" : [ "21:27", "800000", "040420" ], + "031288" : [ "21:28", "800000", "040420" ], + "031289" : [ "21:29", "800000", "040420" ], + "031290" : [ "21:30", "800000", "040420" ], + "031291" : [ "21:31", "800000", "040420" ], + "031292" : [ "21:32", "800000", "040420" ], + "031293" : [ "21:33", "800000", "040420" ], + "031294" : [ "21:34", "800000", "040420" ], + "031295" : [ "21:35", "800000", "040420" ], + "031296" : [ "21:36", "800000", "040420" ], + "031297" : [ "21:37", "800000", "040420" ], + "031298" : [ "21:38", "800000", "040420" ], + "031299" : [ "21:39", "800000", "040420" ], + "031300" : [ "21:40", "800000", "040420" ], + "031301" : [ "21:41", "800000", "040420" ], + "031302" : [ "21:42", "800000", "040420" ], + "031303" : [ "21:43", "800000", "040420" ], + "031304" : [ "21:44", "800000", "040420" ], + "031305" : [ "21:45", "800000", "040420" ], + "031306" : [ "21:46", "800000", "040420" ], + "031307" : [ "21:47", "800000", "040420" ], + "031308" : [ "21:48", "800000", "040420" ], + "031309" : [ "21:49", "800000", "040420" ], + "031310" : [ "21:50", "800000", "040420" ], + "031311" : [ "21:51", "800000", "040420" ], + "031312" : [ "21:52", "800000", "040420" ], + "031313" : [ "21:53", "800000", "040420" ], + "031314" : [ "21:54", "800000", "040420" ], + "031315" : [ "21:55", "800000", "040420" ], + "031316" : [ "21:56", "800000", "040420" ], + "031317" : [ "21:57", "800000", "040420" ], + "031318" : [ "21:58", "800000", "040420" ], + "031319" : [ "21:59", "800000", "040420" ], + "031320" : [ "22:00", "800000", "040420" ], + "031321" : [ "22:01", "800000", "040420" ], + "031322" : [ "22:02", "800000", "040420" ], + "031323" : [ "22:03", "800000", "040420" ], + "031324" : [ "22:04", "800000", "040420" ], + "031325" : [ "22:05", "800000", "040420" ], + "031326" : [ "22:06", "800000", "040420" ], + "031327" : [ "22:07", "800000", "040420" ], + "031328" : [ "22:08", "800000", "040420" ], + "031329" : [ "22:09", "800000", "040420" ], + "031330" : [ "22:10", "800000", "040420" ], + "031331" : [ "22:11", "800000", "040420" ], + "031332" : [ "22:12", "800000", "040420" ], + "031333" : [ "22:13", "800000", "040420" ], + "031334" : [ "22:14", "800000", "040420" ], + "031335" : [ "22:15", "800000", "040420" ], + "031336" : [ "22:16", "800000", "040420" ], + "031337" : [ "22:17", "800000", "040420" ], + "031338" : [ "22:18", "800000", "040420" ], + "031339" : [ "22:19", "800000", "040420" ], + "031340" : [ "22:20", "800000", "040420" ], + "031341" : [ "22:21", "800000", "040420" ], + "031342" : [ "22:22", "800000", "040420" ], + "031343" : [ "22:23", "800000", "040420" ], + "031344" : [ "22:24", "800000", "040420" ], + "031345" : [ "22:25", "800000", "040420" ], + "031346" : [ "22:26", "800000", "040420" ], + "031347" : [ "22:27", "800000", "040420" ], + "031348" : [ "22:28", "800000", "040420" ], + "031349" : [ "22:29", "800000", "040420" ], + "031350" : [ "22:30", "800000", "040420" ], + "031351" : [ "22:31", "800000", "040420" ], + "031352" : [ "22:32", "800000", "040420" ], + "031353" : [ "22:33", "800000", "040420" ], + "031354" : [ "22:34", "800000", "040420" ], + "031355" : [ "22:35", "800000", "040420" ], + "031356" : [ "22:36", "800000", "040420" ], + "031357" : [ "22:37", "800000", "040420" ], + "031358" : [ "22:38", "800000", "040420" ], + "031359" : [ "22:39", "800000", "040420" ], + "031360" : [ "22:40", "800000", "040420" ], + "031361" : [ "22:41", "800000", "040420" ], + "031362" : [ "22:42", "800000", "040420" ], + "031363" : [ "22:43", "800000", "040420" ], + "031364" : [ "22:44", "800000", "040420" ], + "031365" : [ "22:45", "800000", "040420" ], + "031366" : [ "22:46", "800000", "040420" ], + "031367" : [ "22:47", "800000", "040420" ], + "031368" : [ "22:48", "800000", "040420" ], + "031369" : [ "22:49", "800000", "040420" ], + "031370" : [ "22:50", "800000", "040420" ], + "031371" : [ "22:51", "800000", "040420" ], + "031372" : [ "22:52", "800000", "040420" ], + "031373" : [ "22:53", "800000", "040420" ], + "031374" : [ "22:54", "800000", "040420" ], + "031375" : [ "22:55", "800000", "040420" ], + "031376" : [ "22:56", "800000", "040420" ], + "031377" : [ "22:57", "800000", "040420" ], + "031378" : [ "22:58", "800000", "040420" ], + "031379" : [ "22:59", "800000", "040420" ], + "031380" : [ "23:00", "800000", "040420" ], + "031381" : [ "23:01", "800000", "040420" ], + "031382" : [ "23:02", "800000", "040420" ], + "031383" : [ "23:03", "800000", "040420" ], + "031384" : [ "23:04", "800000", "040420" ], + "031385" : [ "23:05", "800000", "040420" ], + "031386" : [ "23:06", "800000", "040420" ], + "031387" : [ "23:07", "800000", "040420" ], + "031388" : [ "23:08", "800000", "040420" ], + "031389" : [ "23:09", "800000", "040420" ], + "031390" : [ "23:10", "800000", "040420" ], + "031391" : [ "23:11", "800000", "040420" ], + "031392" : [ "23:12", "800000", "040420" ], + "031393" : [ "23:13", "800000", "040420" ], + "031394" : [ "23:14", "800000", "040420" ], + "031395" : [ "23:15", "800000", "040420" ], + "031396" : [ "23:16", "800000", "040420" ], + "031397" : [ "23:17", "800000", "040420" ], + "031398" : [ "23:18", "800000", "040420" ], + "031399" : [ "23:19", "800000", "040420" ], + "031400" : [ "23:20", "800000", "040420" ], + "031401" : [ "23:21", "800000", "040420" ], + "031402" : [ "23:22", "800000", "040420" ], + "031403" : [ "23:23", "800000", "040420" ], + "031404" : [ "23:24", "800000", "040420" ], + "031405" : [ "23:25", "800000", "040420" ], + "031406" : [ "23:26", "800000", "040420" ], + "031407" : [ "23:27", "800000", "040420" ], + "031408" : [ "23:28", "800000", "040420" ], + "031409" : [ "23:29", "800000", "040420" ], + "031410" : [ "23:30", "800000", "040420" ], + "031411" : [ "23:31", "800000", "040420" ], + "031412" : [ "23:32", "800000", "040420" ], + "031413" : [ "23:33", "800000", "040420" ], + "031414" : [ "23:34", "800000", "040420" ], + "031415" : [ "23:35", "800000", "040420" ], + "031416" : [ "23:36", "800000", "040420" ], + "031417" : [ "23:37", "800000", "040420" ], + "031418" : [ "23:38", "800000", "040420" ], + "031419" : [ "23:39", "800000", "040420" ], + "031420" : [ "23:40", "800000", "040420" ], + "031421" : [ "23:41", "800000", "040420" ], + "031422" : [ "23:42", "800000", "040420" ], + "031423" : [ "23:43", "800000", "040420" ], + "031424" : [ "23:44", "800000", "040420" ], + "031425" : [ "23:45", "800000", "040420" ], + "031426" : [ "23:46", "800000", "040420" ], + "031427" : [ "23:47", "800000", "040420" ], + "031428" : [ "23:48", "800000", "040420" ], + "031429" : [ "23:49", "800000", "040420" ], + "031430" : [ "23:50", "800000", "040420" ], + "031431" : [ "23:51", "800000", "040420" ], + "031432" : [ "23:52", "800000", "040420" ], + "031433" : [ "23:53", "800000", "040420" ], + "031434" : [ "23:54", "800000", "040420" ], + "031435" : [ "23:55", "800000", "040420" ], + "031436" : [ "23:56", "800000", "040420" ], + "031437" : [ "23:57", "800000", "040420" ], + "031438" : [ "23:58", "800000", "040420" ], + "031439" : [ "23:59", "800000", "040420" ] + }, + "Friday": { + "040000" : [ "00:00", "800000", "040420" ], + "040001" : [ "00:01", "800000", "040420" ], + "040002" : [ "00:02", "800000", "040420" ], + "040003" : [ "00:03", "800000", "040420" ], + "040004" : [ "00:04", "800000", "040420" ], + "040005" : [ "00:05", "800000", "040420" ], + "040006" : [ "00:06", "800000", "040420" ], + "040007" : [ "00:07", "800000", "040420" ], + "040008" : [ "00:08", "800000", "040420" ], + "040009" : [ "00:09", "800000", "040420" ], + "040010" : [ "00:10", "800000", "040420" ], + "040011" : [ "00:11", "800000", "040420" ], + "040012" : [ "00:12", "800000", "040420" ], + "040013" : [ "00:13", "800000", "040420" ], + "040014" : [ "00:14", "800000", "040420" ], + "040015" : [ "00:15", "800000", "040420" ], + "040016" : [ "00:16", "800000", "040420" ], + "040017" : [ "00:17", "800000", "040420" ], + "040018" : [ "00:18", "800000", "040420" ], + "040019" : [ "00:19", "800000", "040420" ], + "040020" : [ "00:20", "800000", "040420" ], + "040021" : [ "00:21", "800000", "040420" ], + "040022" : [ "00:22", "800000", "040420" ], + "040023" : [ "00:23", "800000", "040420" ], + "040024" : [ "00:24", "800000", "040420" ], + "040025" : [ "00:25", "800000", "040420" ], + "040026" : [ "00:26", "800000", "040420" ], + "040027" : [ "00:27", "800000", "040420" ], + "040028" : [ "00:28", "800000", "040420" ], + "040029" : [ "00:29", "800000", "040420" ], + "040030" : [ "00:30", "800000", "040420" ], + "040031" : [ "00:31", "800000", "040420" ], + "040032" : [ "00:32", "800000", "040420" ], + "040033" : [ "00:33", "800000", "040420" ], + "040034" : [ "00:34", "800000", "040420" ], + "040035" : [ "00:35", "800000", "040420" ], + "040036" : [ "00:36", "800000", "040420" ], + "040037" : [ "00:37", "800000", "040420" ], + "040038" : [ "00:38", "800000", "040420" ], + "040039" : [ "00:39", "800000", "040420" ], + "040040" : [ "00:40", "800000", "040420" ], + "040041" : [ "00:41", "800000", "040420" ], + "040042" : [ "00:42", "800000", "040420" ], + "040043" : [ "00:43", "800000", "040420" ], + "040044" : [ "00:44", "800000", "040420" ], + "040045" : [ "00:45", "800000", "040420" ], + "040046" : [ "00:46", "800000", "040420" ], + "040047" : [ "00:47", "800000", "040420" ], + "040048" : [ "00:48", "800000", "040420" ], + "040049" : [ "00:49", "800000", "040420" ], + "040050" : [ "00:50", "800000", "040420" ], + "040051" : [ "00:51", "800000", "040420" ], + "040052" : [ "00:52", "800000", "040420" ], + "040053" : [ "00:53", "800000", "040420" ], + "040054" : [ "00:54", "800000", "040420" ], + "040055" : [ "00:55", "800000", "040420" ], + "040056" : [ "00:56", "800000", "040420" ], + "040057" : [ "00:57", "800000", "040420" ], + "040058" : [ "00:58", "800000", "040420" ], + "040059" : [ "00:59", "800000", "040420" ], + "040060" : [ "01:00", "800000", "040420" ], + "040061" : [ "01:01", "800000", "040420" ], + "040062" : [ "01:02", "800000", "040420" ], + "040063" : [ "01:03", "800000", "040420" ], + "040064" : [ "01:04", "800000", "040420" ], + "040065" : [ "01:05", "800000", "040420" ], + "040066" : [ "01:06", "800000", "040420" ], + "040067" : [ "01:07", "800000", "040420" ], + "040068" : [ "01:08", "800000", "040420" ], + "040069" : [ "01:09", "800000", "040420" ], + "040070" : [ "01:10", "800000", "040420" ], + "040071" : [ "01:11", "800000", "040420" ], + "040072" : [ "01:12", "800000", "040420" ], + "040073" : [ "01:13", "800000", "040420" ], + "040074" : [ "01:14", "800000", "040420" ], + "040075" : [ "01:15", "800000", "040420" ], + "040076" : [ "01:16", "800000", "040420" ], + "040077" : [ "01:17", "800000", "040420" ], + "040078" : [ "01:18", "800000", "040420" ], + "040079" : [ "01:19", "800000", "040420" ], + "040080" : [ "01:20", "800000", "040420" ], + "040081" : [ "01:21", "800000", "040420" ], + "040082" : [ "01:22", "800000", "040420" ], + "040083" : [ "01:23", "800000", "040420" ], + "040084" : [ "01:24", "800000", "040420" ], + "040085" : [ "01:25", "800000", "040420" ], + "040086" : [ "01:26", "800000", "040420" ], + "040087" : [ "01:27", "800000", "040420" ], + "040088" : [ "01:28", "800000", "040420" ], + "040089" : [ "01:29", "800000", "040420" ], + "040090" : [ "01:30", "800000", "040420" ], + "040091" : [ "01:31", "800000", "040420" ], + "040092" : [ "01:32", "800000", "040420" ], + "040093" : [ "01:33", "800000", "040420" ], + "040094" : [ "01:34", "800000", "040420" ], + "040095" : [ "01:35", "800000", "040420" ], + "040096" : [ "01:36", "800000", "040420" ], + "040097" : [ "01:37", "800000", "040420" ], + "040098" : [ "01:38", "800000", "040420" ], + "040099" : [ "01:39", "800000", "040420" ], + "040100" : [ "01:40", "800000", "040420" ], + "040101" : [ "01:41", "800000", "040420" ], + "040102" : [ "01:42", "800000", "040420" ], + "040103" : [ "01:43", "800000", "040420" ], + "040104" : [ "01:44", "800000", "040420" ], + "040105" : [ "01:45", "800000", "040420" ], + "040106" : [ "01:46", "800000", "040420" ], + "040107" : [ "01:47", "800000", "040420" ], + "040108" : [ "01:48", "800000", "040420" ], + "040109" : [ "01:49", "800000", "040420" ], + "040110" : [ "01:50", "800000", "040420" ], + "040111" : [ "01:51", "800000", "040420" ], + "040112" : [ "01:52", "800000", "040420" ], + "040113" : [ "01:53", "800000", "040420" ], + "040114" : [ "01:54", "800000", "040420" ], + "040115" : [ "01:55", "800000", "040420" ], + "040116" : [ "01:56", "800000", "040420" ], + "040117" : [ "01:57", "800000", "040420" ], + "040118" : [ "01:58", "800000", "040420" ], + "040119" : [ "01:59", "800000", "040420" ], + "040120" : [ "02:00", "800000", "040420" ], + "040121" : [ "02:01", "800000", "040420" ], + "040122" : [ "02:02", "800000", "040420" ], + "040123" : [ "02:03", "800000", "040420" ], + "040124" : [ "02:04", "800000", "040420" ], + "040125" : [ "02:05", "800000", "040420" ], + "040126" : [ "02:06", "800000", "040420" ], + "040127" : [ "02:07", "800000", "040420" ], + "040128" : [ "02:08", "800000", "040420" ], + "040129" : [ "02:09", "800000", "040420" ], + "040130" : [ "02:10", "800000", "040420" ], + "040131" : [ "02:11", "800000", "040420" ], + "040132" : [ "02:12", "800000", "040420" ], + "040133" : [ "02:13", "800000", "040420" ], + "040134" : [ "02:14", "800000", "040420" ], + "040135" : [ "02:15", "800000", "040420" ], + "040136" : [ "02:16", "800000", "040420" ], + "040137" : [ "02:17", "800000", "040420" ], + "040138" : [ "02:18", "800000", "040420" ], + "040139" : [ "02:19", "800000", "040420" ], + "040140" : [ "02:20", "800000", "040420" ], + "040141" : [ "02:21", "800000", "040420" ], + "040142" : [ "02:22", "800000", "040420" ], + "040143" : [ "02:23", "800000", "040420" ], + "040144" : [ "02:24", "800000", "040420" ], + "040145" : [ "02:25", "800000", "040420" ], + "040146" : [ "02:26", "800000", "040420" ], + "040147" : [ "02:27", "800000", "040420" ], + "040148" : [ "02:28", "800000", "040420" ], + "040149" : [ "02:29", "800000", "040420" ], + "040150" : [ "02:30", "800000", "040420" ], + "040151" : [ "02:31", "800000", "040420" ], + "040152" : [ "02:32", "800000", "040420" ], + "040153" : [ "02:33", "800000", "040420" ], + "040154" : [ "02:34", "800000", "040420" ], + "040155" : [ "02:35", "800000", "040420" ], + "040156" : [ "02:36", "800000", "040420" ], + "040157" : [ "02:37", "800000", "040420" ], + "040158" : [ "02:38", "800000", "040420" ], + "040159" : [ "02:39", "800000", "040420" ], + "040160" : [ "02:40", "800000", "040420" ], + "040161" : [ "02:41", "800000", "040420" ], + "040162" : [ "02:42", "800000", "040420" ], + "040163" : [ "02:43", "800000", "040420" ], + "040164" : [ "02:44", "800000", "040420" ], + "040165" : [ "02:45", "800000", "040420" ], + "040166" : [ "02:46", "800000", "040420" ], + "040167" : [ "02:47", "800000", "040420" ], + "040168" : [ "02:48", "800000", "040420" ], + "040169" : [ "02:49", "800000", "040420" ], + "040170" : [ "02:50", "800000", "040420" ], + "040171" : [ "02:51", "800000", "040420" ], + "040172" : [ "02:52", "800000", "040420" ], + "040173" : [ "02:53", "800000", "040420" ], + "040174" : [ "02:54", "800000", "040420" ], + "040175" : [ "02:55", "800000", "040420" ], + "040176" : [ "02:56", "800000", "040420" ], + "040177" : [ "02:57", "800000", "040420" ], + "040178" : [ "02:58", "800000", "040420" ], + "040179" : [ "02:59", "800000", "040420" ], + "040180" : [ "03:00", "800000", "040420" ], + "040181" : [ "03:01", "800000", "040420" ], + "040182" : [ "03:02", "800000", "040420" ], + "040183" : [ "03:03", "800000", "040420" ], + "040184" : [ "03:04", "800000", "040420" ], + "040185" : [ "03:05", "800000", "040420" ], + "040186" : [ "03:06", "800000", "040420" ], + "040187" : [ "03:07", "800000", "040420" ], + "040188" : [ "03:08", "800000", "040420" ], + "040189" : [ "03:09", "800000", "040420" ], + "040190" : [ "03:10", "800000", "040420" ], + "040191" : [ "03:11", "800000", "040420" ], + "040192" : [ "03:12", "800000", "040420" ], + "040193" : [ "03:13", "800000", "040420" ], + "040194" : [ "03:14", "800000", "040420" ], + "040195" : [ "03:15", "800000", "040420" ], + "040196" : [ "03:16", "800000", "040420" ], + "040197" : [ "03:17", "800000", "040420" ], + "040198" : [ "03:18", "800000", "040420" ], + "040199" : [ "03:19", "800000", "040420" ], + "040200" : [ "03:20", "800000", "040420" ], + "040201" : [ "03:21", "800000", "040420" ], + "040202" : [ "03:22", "800000", "040420" ], + "040203" : [ "03:23", "800000", "040420" ], + "040204" : [ "03:24", "800000", "040420" ], + "040205" : [ "03:25", "800000", "040420" ], + "040206" : [ "03:26", "800000", "040420" ], + "040207" : [ "03:27", "800000", "040420" ], + "040208" : [ "03:28", "800000", "040420" ], + "040209" : [ "03:29", "800000", "040420" ], + "040210" : [ "03:30", "800000", "040420" ], + "040211" : [ "03:31", "800000", "040420" ], + "040212" : [ "03:32", "800000", "040420" ], + "040213" : [ "03:33", "800000", "040420" ], + "040214" : [ "03:34", "800000", "040420" ], + "040215" : [ "03:35", "800000", "040420" ], + "040216" : [ "03:36", "800000", "040420" ], + "040217" : [ "03:37", "800000", "040420" ], + "040218" : [ "03:38", "800000", "040420" ], + "040219" : [ "03:39", "800000", "040420" ], + "040220" : [ "03:40", "800000", "040420" ], + "040221" : [ "03:41", "800000", "040420" ], + "040222" : [ "03:42", "800000", "040420" ], + "040223" : [ "03:43", "800000", "040420" ], + "040224" : [ "03:44", "800000", "040420" ], + "040225" : [ "03:45", "800000", "040420" ], + "040226" : [ "03:46", "800000", "040420" ], + "040227" : [ "03:47", "800000", "040420" ], + "040228" : [ "03:48", "800000", "040420" ], + "040229" : [ "03:49", "800000", "040420" ], + "040230" : [ "03:50", "800000", "040420" ], + "040231" : [ "03:51", "800000", "040420" ], + "040232" : [ "03:52", "800000", "040420" ], + "040233" : [ "03:53", "800000", "040420" ], + "040234" : [ "03:54", "800000", "040420" ], + "040235" : [ "03:55", "800000", "040420" ], + "040236" : [ "03:56", "800000", "040420" ], + "040237" : [ "03:57", "800000", "040420" ], + "040238" : [ "03:58", "800000", "040420" ], + "040239" : [ "03:59", "800000", "040420" ], + "040240" : [ "04:00", "800000", "040420" ], + "040241" : [ "04:01", "800000", "040420" ], + "040242" : [ "04:02", "800000", "040420" ], + "040243" : [ "04:03", "800000", "040420" ], + "040244" : [ "04:04", "800000", "040420" ], + "040245" : [ "04:05", "800000", "040420" ], + "040246" : [ "04:06", "800000", "040420" ], + "040247" : [ "04:07", "800000", "040420" ], + "040248" : [ "04:08", "800000", "040420" ], + "040249" : [ "04:09", "800000", "040420" ], + "040250" : [ "04:10", "800000", "040420" ], + "040251" : [ "04:11", "800000", "040420" ], + "040252" : [ "04:12", "800000", "040420" ], + "040253" : [ "04:13", "800000", "040420" ], + "040254" : [ "04:14", "800000", "040420" ], + "040255" : [ "04:15", "800000", "040420" ], + "040256" : [ "04:16", "800000", "040420" ], + "040257" : [ "04:17", "800000", "040420" ], + "040258" : [ "04:18", "800000", "040420" ], + "040259" : [ "04:19", "800000", "040420" ], + "040260" : [ "04:20", "800000", "040420" ], + "040261" : [ "04:21", "800000", "040420" ], + "040262" : [ "04:22", "800000", "040420" ], + "040263" : [ "04:23", "800000", "040420" ], + "040264" : [ "04:24", "800000", "040420" ], + "040265" : [ "04:25", "800000", "040420" ], + "040266" : [ "04:26", "800000", "040420" ], + "040267" : [ "04:27", "800000", "040420" ], + "040268" : [ "04:28", "800000", "040420" ], + "040269" : [ "04:29", "800000", "040420" ], + "040270" : [ "04:30", "800000", "040420" ], + "040271" : [ "04:31", "800000", "040420" ], + "040272" : [ "04:32", "800000", "040420" ], + "040273" : [ "04:33", "800000", "040420" ], + "040274" : [ "04:34", "800000", "040420" ], + "040275" : [ "04:35", "800000", "040420" ], + "040276" : [ "04:36", "800000", "040420" ], + "040277" : [ "04:37", "800000", "040420" ], + "040278" : [ "04:38", "800000", "040420" ], + "040279" : [ "04:39", "800000", "040420" ], + "040280" : [ "04:40", "800000", "040420" ], + "040281" : [ "04:41", "800000", "040420" ], + "040282" : [ "04:42", "800000", "040420" ], + "040283" : [ "04:43", "800000", "040420" ], + "040284" : [ "04:44", "800000", "040420" ], + "040285" : [ "04:45", "800000", "040420" ], + "040286" : [ "04:46", "800000", "040420" ], + "040287" : [ "04:47", "800000", "040420" ], + "040288" : [ "04:48", "800000", "040420" ], + "040289" : [ "04:49", "800000", "040420" ], + "040290" : [ "04:50", "800000", "040420" ], + "040291" : [ "04:51", "800000", "040420" ], + "040292" : [ "04:52", "800000", "040420" ], + "040293" : [ "04:53", "800000", "040420" ], + "040294" : [ "04:54", "800000", "040420" ], + "040295" : [ "04:55", "800000", "040420" ], + "040296" : [ "04:56", "800000", "040420" ], + "040297" : [ "04:57", "800000", "040420" ], + "040298" : [ "04:58", "800000", "040420" ], + "040299" : [ "04:59", "800000", "040420" ], + "040300" : [ "05:00", "800000", "040420" ], + "040301" : [ "05:01", "800000", "040420" ], + "040302" : [ "05:02", "800000", "040420" ], + "040303" : [ "05:03", "800000", "040420" ], + "040304" : [ "05:04", "800000", "040420" ], + "040305" : [ "05:05", "800000", "040420" ], + "040306" : [ "05:06", "800000", "040420" ], + "040307" : [ "05:07", "800000", "040420" ], + "040308" : [ "05:08", "800000", "040420" ], + "040309" : [ "05:09", "800000", "040420" ], + "040310" : [ "05:10", "800000", "040420" ], + "040311" : [ "05:11", "800000", "040420" ], + "040312" : [ "05:12", "800000", "040420" ], + "040313" : [ "05:13", "800000", "040420" ], + "040314" : [ "05:14", "800000", "040420" ], + "040315" : [ "05:15", "800000", "040420" ], + "040316" : [ "05:16", "800000", "040420" ], + "040317" : [ "05:17", "800000", "040420" ], + "040318" : [ "05:18", "800000", "040420" ], + "040319" : [ "05:19", "800000", "040420" ], + "040320" : [ "05:20", "800000", "040420" ], + "040321" : [ "05:21", "800000", "040420" ], + "040322" : [ "05:22", "800000", "040420" ], + "040323" : [ "05:23", "800000", "040420" ], + "040324" : [ "05:24", "800000", "040420" ], + "040325" : [ "05:25", "800000", "040420" ], + "040326" : [ "05:26", "800000", "040420" ], + "040327" : [ "05:27", "800000", "040420" ], + "040328" : [ "05:28", "800000", "040420" ], + "040329" : [ "05:29", "800000", "040420" ], + "040330" : [ "05:30", "800000", "040420" ], + "040331" : [ "05:31", "800000", "040420" ], + "040332" : [ "05:32", "800000", "040420" ], + "040333" : [ "05:33", "800000", "040420" ], + "040334" : [ "05:34", "800000", "040420" ], + "040335" : [ "05:35", "800000", "040420" ], + "040336" : [ "05:36", "800000", "040420" ], + "040337" : [ "05:37", "800000", "040420" ], + "040338" : [ "05:38", "800000", "040420" ], + "040339" : [ "05:39", "800000", "040420" ], + "040340" : [ "05:40", "800000", "040420" ], + "040341" : [ "05:41", "800000", "040420" ], + "040342" : [ "05:42", "800000", "040420" ], + "040343" : [ "05:43", "800000", "040420" ], + "040344" : [ "05:44", "800000", "040420" ], + "040345" : [ "05:45", "800000", "040420" ], + "040346" : [ "05:46", "800000", "040420" ], + "040347" : [ "05:47", "800000", "040420" ], + "040348" : [ "05:48", "800000", "040420" ], + "040349" : [ "05:49", "800000", "040420" ], + "040350" : [ "05:50", "800000", "040420" ], + "040351" : [ "05:51", "800000", "040420" ], + "040352" : [ "05:52", "800000", "040420" ], + "040353" : [ "05:53", "800000", "040420" ], + "040354" : [ "05:54", "800000", "040420" ], + "040355" : [ "05:55", "800000", "040420" ], + "040356" : [ "05:56", "800000", "040420" ], + "040357" : [ "05:57", "800000", "040420" ], + "040358" : [ "05:58", "800000", "040420" ], + "040359" : [ "05:59", "800000", "040420" ], + "040360" : [ "06:00", "800000", "040420" ], + "040361" : [ "06:01", "800000", "040420" ], + "040362" : [ "06:02", "800000", "040420" ], + "040363" : [ "06:03", "800000", "040420" ], + "040364" : [ "06:04", "800000", "040420" ], + "040365" : [ "06:05", "800000", "040420" ], + "040366" : [ "06:06", "800000", "040420" ], + "040367" : [ "06:07", "800000", "040420" ], + "040368" : [ "06:08", "800000", "040420" ], + "040369" : [ "06:09", "800000", "040420" ], + "040370" : [ "06:10", "800000", "040420" ], + "040371" : [ "06:11", "800000", "040420" ], + "040372" : [ "06:12", "800000", "040420" ], + "040373" : [ "06:13", "800000", "040420" ], + "040374" : [ "06:14", "800000", "040420" ], + "040375" : [ "06:15", "800000", "040420" ], + "040376" : [ "06:16", "800000", "040420" ], + "040377" : [ "06:17", "800000", "040420" ], + "040378" : [ "06:18", "800000", "040420" ], + "040379" : [ "06:19", "800000", "040420" ], + "040380" : [ "06:20", "800000", "040420" ], + "040381" : [ "06:21", "800000", "040420" ], + "040382" : [ "06:22", "800000", "040420" ], + "040383" : [ "06:23", "800000", "040420" ], + "040384" : [ "06:24", "800000", "040420" ], + "040385" : [ "06:25", "800000", "040420" ], + "040386" : [ "06:26", "800000", "040420" ], + "040387" : [ "06:27", "800000", "040420" ], + "040388" : [ "06:28", "800000", "040420" ], + "040389" : [ "06:29", "800000", "040420" ], + "040390" : [ "06:30", "800000", "040420" ], + "040391" : [ "06:31", "800000", "040420" ], + "040392" : [ "06:32", "800000", "040420" ], + "040393" : [ "06:33", "800000", "040420" ], + "040394" : [ "06:34", "800000", "040420" ], + "040395" : [ "06:35", "800000", "040420" ], + "040396" : [ "06:36", "800000", "040420" ], + "040397" : [ "06:37", "800000", "040420" ], + "040398" : [ "06:38", "800000", "040420" ], + "040399" : [ "06:39", "800000", "040420" ], + "040400" : [ "06:40", "800000", "040420" ], + "040401" : [ "06:41", "800000", "040420" ], + "040402" : [ "06:42", "800000", "040420" ], + "040403" : [ "06:43", "800000", "040420" ], + "040404" : [ "06:44", "800000", "040420" ], + "040405" : [ "06:45", "800000", "040420" ], + "040406" : [ "06:46", "800000", "040420" ], + "040407" : [ "06:47", "800000", "040420" ], + "040408" : [ "06:48", "800000", "040420" ], + "040409" : [ "06:49", "800000", "040420" ], + "040410" : [ "06:50", "800000", "040420" ], + "040411" : [ "06:51", "800000", "040420" ], + "040412" : [ "06:52", "800000", "040420" ], + "040413" : [ "06:53", "800000", "040420" ], + "040414" : [ "06:54", "800000", "040420" ], + "040415" : [ "06:55", "800000", "040420" ], + "040416" : [ "06:56", "800000", "040420" ], + "040417" : [ "06:57", "800000", "040420" ], + "040418" : [ "06:58", "800000", "040420" ], + "040419" : [ "06:59", "800000", "040420" ], + "040420" : [ "07:00", "350000", "040480" ], + "040421" : [ "07:01", "350000", "040481" ], + "040422" : [ "07:02", "350000", "040482" ], + "040423" : [ "07:03", "350000", "040483" ], + "040424" : [ "07:04", "350000", "040484" ], + "040425" : [ "07:05", "350000", "040485" ], + "040426" : [ "07:06", "350000", "040486" ], + "040427" : [ "07:07", "350000", "040487" ], + "040428" : [ "07:08", "350000", "040488" ], + "040429" : [ "07:09", "350000", "040489" ], + "040430" : [ "07:10", "350000", "040490" ], + "040431" : [ "07:11", "350000", "040491" ], + "040432" : [ "07:12", "350000", "040492" ], + "040433" : [ "07:13", "350000", "040493" ], + "040434" : [ "07:14", "350000", "040494" ], + "040435" : [ "07:15", "350000", "040495" ], + "040436" : [ "07:16", "350000", "040496" ], + "040437" : [ "07:17", "350000", "040497" ], + "040438" : [ "07:18", "350000", "040498" ], + "040439" : [ "07:19", "350000", "040499" ], + "040440" : [ "07:20", "350000", "040500" ], + "040441" : [ "07:21", "350000", "040501" ], + "040442" : [ "07:22", "350000", "040502" ], + "040443" : [ "07:23", "350000", "040503" ], + "040444" : [ "07:24", "350000", "040504" ], + "040445" : [ "07:25", "350000", "040505" ], + "040446" : [ "07:26", "350000", "040506" ], + "040447" : [ "07:27", "350000", "040507" ], + "040448" : [ "07:28", "350000", "040508" ], + "040449" : [ "07:29", "350000", "040509" ], + "040450" : [ "07:30", "350000", "040510" ], + "040451" : [ "07:31", "350000", "040511" ], + "040452" : [ "07:32", "350000", "040512" ], + "040453" : [ "07:33", "350000", "040513" ], + "040454" : [ "07:34", "350000", "040514" ], + "040455" : [ "07:35", "350000", "040515" ], + "040456" : [ "07:36", "350000", "040516" ], + "040457" : [ "07:37", "350000", "040517" ], + "040458" : [ "07:38", "350000", "040518" ], + "040459" : [ "07:39", "350000", "040519" ], + "040460" : [ "07:40", "350000", "040520" ], + "040461" : [ "07:41", "350000", "040521" ], + "040462" : [ "07:42", "350000", "040522" ], + "040463" : [ "07:43", "350000", "040523" ], + "040464" : [ "07:44", "350000", "040524" ], + "040465" : [ "07:45", "350000", "040525" ], + "040466" : [ "07:46", "350000", "040526" ], + "040467" : [ "07:47", "350000", "040527" ], + "040468" : [ "07:48", "350000", "040528" ], + "040469" : [ "07:49", "350000", "040529" ], + "040470" : [ "07:50", "350000", "040530" ], + "040471" : [ "07:51", "350000", "040531" ], + "040472" : [ "07:52", "350000", "040532" ], + "040473" : [ "07:53", "350000", "040533" ], + "040474" : [ "07:54", "350000", "040534" ], + "040475" : [ "07:55", "350000", "040535" ], + "040476" : [ "07:56", "350000", "040536" ], + "040477" : [ "07:57", "350000", "040537" ], + "040478" : [ "07:58", "350000", "040538" ], + "040479" : [ "07:59", "350000", "040539" ], + "040480" : [ "08:00", "350000", "040540" ], + "040481" : [ "08:01", "350000", "040541" ], + "040482" : [ "08:02", "350000", "040542" ], + "040483" : [ "08:03", "350000", "040543" ], + "040484" : [ "08:04", "350000", "040544" ], + "040485" : [ "08:05", "350000", "040545" ], + "040486" : [ "08:06", "350000", "040546" ], + "040487" : [ "08:07", "350000", "040547" ], + "040488" : [ "08:08", "350000", "040548" ], + "040489" : [ "08:09", "350000", "040549" ], + "040490" : [ "08:10", "350000", "040550" ], + "040491" : [ "08:11", "350000", "040551" ], + "040492" : [ "08:12", "350000", "040552" ], + "040493" : [ "08:13", "350000", "040553" ], + "040494" : [ "08:14", "350000", "040554" ], + "040495" : [ "08:15", "350000", "040555" ], + "040496" : [ "08:16", "350000", "040556" ], + "040497" : [ "08:17", "350000", "040557" ], + "040498" : [ "08:18", "350000", "040558" ], + "040499" : [ "08:19", "350000", "040559" ], + "040500" : [ "08:20", "350000", "040560" ], + "040501" : [ "08:21", "350000", "040561" ], + "040502" : [ "08:22", "350000", "040562" ], + "040503" : [ "08:23", "350000", "040563" ], + "040504" : [ "08:24", "350000", "040564" ], + "040505" : [ "08:25", "350000", "040565" ], + "040506" : [ "08:26", "350000", "040566" ], + "040507" : [ "08:27", "350000", "040567" ], + "040508" : [ "08:28", "350000", "040568" ], + "040509" : [ "08:29", "350000", "040569" ], + "040510" : [ "08:30", "350000", "040570" ], + "040511" : [ "08:31", "350000", "040571" ], + "040512" : [ "08:32", "350000", "040572" ], + "040513" : [ "08:33", "350000", "040573" ], + "040514" : [ "08:34", "350000", "040574" ], + "040515" : [ "08:35", "350000", "040575" ], + "040516" : [ "08:36", "350000", "040576" ], + "040517" : [ "08:37", "350000", "040577" ], + "040518" : [ "08:38", "350000", "040578" ], + "040519" : [ "08:39", "350000", "040579" ], + "040520" : [ "08:40", "350000", "040580" ], + "040521" : [ "08:41", "350000", "040581" ], + "040522" : [ "08:42", "350000", "040582" ], + "040523" : [ "08:43", "350000", "040583" ], + "040524" : [ "08:44", "350000", "040584" ], + "040525" : [ "08:45", "350000", "040585" ], + "040526" : [ "08:46", "350000", "040586" ], + "040527" : [ "08:47", "350000", "040587" ], + "040528" : [ "08:48", "350000", "040588" ], + "040529" : [ "08:49", "350000", "040589" ], + "040530" : [ "08:50", "350000", "040590" ], + "040531" : [ "08:51", "350000", "040591" ], + "040532" : [ "08:52", "350000", "040592" ], + "040533" : [ "08:53", "350000", "040593" ], + "040534" : [ "08:54", "350000", "040594" ], + "040535" : [ "08:55", "350000", "040595" ], + "040536" : [ "08:56", "350000", "040596" ], + "040537" : [ "08:57", "350000", "040597" ], + "040538" : [ "08:58", "350000", "040598" ], + "040539" : [ "08:59", "350000", "040599" ], + "040540" : [ "09:00", "350000", "040600" ], + "040541" : [ "09:01", "350000", "040601" ], + "040542" : [ "09:02", "350000", "040602" ], + "040543" : [ "09:03", "350000", "040603" ], + "040544" : [ "09:04", "350000", "040604" ], + "040545" : [ "09:05", "350000", "040605" ], + "040546" : [ "09:06", "350000", "040606" ], + "040547" : [ "09:07", "350000", "040607" ], + "040548" : [ "09:08", "350000", "040608" ], + "040549" : [ "09:09", "350000", "040609" ], + "040550" : [ "09:10", "350000", "040610" ], + "040551" : [ "09:11", "350000", "040611" ], + "040552" : [ "09:12", "350000", "040612" ], + "040553" : [ "09:13", "350000", "040613" ], + "040554" : [ "09:14", "350000", "040614" ], + "040555" : [ "09:15", "350000", "040615" ], + "040556" : [ "09:16", "350000", "040616" ], + "040557" : [ "09:17", "350000", "040617" ], + "040558" : [ "09:18", "350000", "040618" ], + "040559" : [ "09:19", "350000", "040619" ], + "040560" : [ "09:20", "350000", "040620" ], + "040561" : [ "09:21", "350000", "040621" ], + "040562" : [ "09:22", "350000", "040622" ], + "040563" : [ "09:23", "350000", "040623" ], + "040564" : [ "09:24", "350000", "040624" ], + "040565" : [ "09:25", "350000", "040625" ], + "040566" : [ "09:26", "350000", "040626" ], + "040567" : [ "09:27", "350000", "040627" ], + "040568" : [ "09:28", "350000", "040628" ], + "040569" : [ "09:29", "350000", "040629" ], + "040570" : [ "09:30", "350000", "040630" ], + "040571" : [ "09:31", "350000", "040631" ], + "040572" : [ "09:32", "350000", "040632" ], + "040573" : [ "09:33", "350000", "040633" ], + "040574" : [ "09:34", "350000", "040634" ], + "040575" : [ "09:35", "350000", "040635" ], + "040576" : [ "09:36", "350000", "040636" ], + "040577" : [ "09:37", "350000", "040637" ], + "040578" : [ "09:38", "350000", "040638" ], + "040579" : [ "09:39", "350000", "040639" ], + "040580" : [ "09:40", "350000", "040640" ], + "040581" : [ "09:41", "350000", "040641" ], + "040582" : [ "09:42", "350000", "040642" ], + "040583" : [ "09:43", "350000", "040643" ], + "040584" : [ "09:44", "350000", "040644" ], + "040585" : [ "09:45", "350000", "040645" ], + "040586" : [ "09:46", "350000", "040646" ], + "040587" : [ "09:47", "350000", "040647" ], + "040588" : [ "09:48", "350000", "040648" ], + "040589" : [ "09:49", "350000", "040649" ], + "040590" : [ "09:50", "350000", "040650" ], + "040591" : [ "09:51", "350000", "040651" ], + "040592" : [ "09:52", "350000", "040652" ], + "040593" : [ "09:53", "350000", "040653" ], + "040594" : [ "09:54", "350000", "040654" ], + "040595" : [ "09:55", "350000", "040655" ], + "040596" : [ "09:56", "350000", "040656" ], + "040597" : [ "09:57", "350000", "040657" ], + "040598" : [ "09:58", "350000", "040658" ], + "040599" : [ "09:59", "350000", "040659" ], + "040600" : [ "10:00", "350000", "040660" ], + "040601" : [ "10:01", "350000", "040661" ], + "040602" : [ "10:02", "350000", "040662" ], + "040603" : [ "10:03", "350000", "040663" ], + "040604" : [ "10:04", "350000", "040664" ], + "040605" : [ "10:05", "350000", "040665" ], + "040606" : [ "10:06", "350000", "040666" ], + "040607" : [ "10:07", "350000", "040667" ], + "040608" : [ "10:08", "350000", "040668" ], + "040609" : [ "10:09", "350000", "040669" ], + "040610" : [ "10:10", "350000", "040670" ], + "040611" : [ "10:11", "350000", "040671" ], + "040612" : [ "10:12", "350000", "040672" ], + "040613" : [ "10:13", "350000", "040673" ], + "040614" : [ "10:14", "350000", "040674" ], + "040615" : [ "10:15", "350000", "040675" ], + "040616" : [ "10:16", "350000", "040676" ], + "040617" : [ "10:17", "350000", "040677" ], + "040618" : [ "10:18", "350000", "040678" ], + "040619" : [ "10:19", "350000", "040679" ], + "040620" : [ "10:20", "350000", "040680" ], + "040621" : [ "10:21", "350000", "040681" ], + "040622" : [ "10:22", "350000", "040682" ], + "040623" : [ "10:23", "350000", "040683" ], + "040624" : [ "10:24", "350000", "040684" ], + "040625" : [ "10:25", "350000", "040685" ], + "040626" : [ "10:26", "350000", "040686" ], + "040627" : [ "10:27", "350000", "040687" ], + "040628" : [ "10:28", "350000", "040688" ], + "040629" : [ "10:29", "350000", "040689" ], + "040630" : [ "10:30", "350000", "040690" ], + "040631" : [ "10:31", "350000", "040691" ], + "040632" : [ "10:32", "350000", "040692" ], + "040633" : [ "10:33", "350000", "040693" ], + "040634" : [ "10:34", "350000", "040694" ], + "040635" : [ "10:35", "350000", "040695" ], + "040636" : [ "10:36", "350000", "040696" ], + "040637" : [ "10:37", "350000", "040697" ], + "040638" : [ "10:38", "350000", "040698" ], + "040639" : [ "10:39", "350000", "040699" ], + "040640" : [ "10:40", "350000", "040700" ], + "040641" : [ "10:41", "350000", "040701" ], + "040642" : [ "10:42", "350000", "040702" ], + "040643" : [ "10:43", "350000", "040703" ], + "040644" : [ "10:44", "350000", "040704" ], + "040645" : [ "10:45", "350000", "040705" ], + "040646" : [ "10:46", "350000", "040706" ], + "040647" : [ "10:47", "350000", "040707" ], + "040648" : [ "10:48", "350000", "040708" ], + "040649" : [ "10:49", "350000", "040709" ], + "040650" : [ "10:50", "350000", "040710" ], + "040651" : [ "10:51", "350000", "040711" ], + "040652" : [ "10:52", "350000", "040712" ], + "040653" : [ "10:53", "350000", "040713" ], + "040654" : [ "10:54", "350000", "040714" ], + "040655" : [ "10:55", "350000", "040715" ], + "040656" : [ "10:56", "350000", "040716" ], + "040657" : [ "10:57", "350000", "040717" ], + "040658" : [ "10:58", "350000", "040718" ], + "040659" : [ "10:59", "350000", "040719" ], + "040660" : [ "11:00", "350000", "040720" ], + "040661" : [ "11:01", "350000", "040721" ], + "040662" : [ "11:02", "350000", "040722" ], + "040663" : [ "11:03", "350000", "040723" ], + "040664" : [ "11:04", "350000", "040724" ], + "040665" : [ "11:05", "350000", "040725" ], + "040666" : [ "11:06", "350000", "040726" ], + "040667" : [ "11:07", "350000", "040727" ], + "040668" : [ "11:08", "350000", "040728" ], + "040669" : [ "11:09", "350000", "040729" ], + "040670" : [ "11:10", "350000", "040730" ], + "040671" : [ "11:11", "350000", "040731" ], + "040672" : [ "11:12", "350000", "040732" ], + "040673" : [ "11:13", "350000", "040733" ], + "040674" : [ "11:14", "350000", "040734" ], + "040675" : [ "11:15", "350000", "040735" ], + "040676" : [ "11:16", "350000", "040736" ], + "040677" : [ "11:17", "350000", "040737" ], + "040678" : [ "11:18", "350000", "040738" ], + "040679" : [ "11:19", "350000", "040739" ], + "040680" : [ "11:20", "350000", "040740" ], + "040681" : [ "11:21", "350000", "040741" ], + "040682" : [ "11:22", "350000", "040742" ], + "040683" : [ "11:23", "350000", "040743" ], + "040684" : [ "11:24", "350000", "040744" ], + "040685" : [ "11:25", "350000", "040745" ], + "040686" : [ "11:26", "350000", "040746" ], + "040687" : [ "11:27", "350000", "040747" ], + "040688" : [ "11:28", "350000", "040748" ], + "040689" : [ "11:29", "350000", "040749" ], + "040690" : [ "11:30", "350000", "040750" ], + "040691" : [ "11:31", "350000", "040751" ], + "040692" : [ "11:32", "350000", "040752" ], + "040693" : [ "11:33", "350000", "040753" ], + "040694" : [ "11:34", "350000", "040754" ], + "040695" : [ "11:35", "350000", "040755" ], + "040696" : [ "11:36", "350000", "040756" ], + "040697" : [ "11:37", "350000", "040757" ], + "040698" : [ "11:38", "350000", "040758" ], + "040699" : [ "11:39", "350000", "040759" ], + "040700" : [ "11:40", "350000", "040760" ], + "040701" : [ "11:41", "350000", "040761" ], + "040702" : [ "11:42", "350000", "040762" ], + "040703" : [ "11:43", "350000", "040763" ], + "040704" : [ "11:44", "350000", "040764" ], + "040705" : [ "11:45", "350000", "040765" ], + "040706" : [ "11:46", "350000", "040766" ], + "040707" : [ "11:47", "350000", "040767" ], + "040708" : [ "11:48", "350000", "040768" ], + "040709" : [ "11:49", "350000", "040769" ], + "040710" : [ "11:50", "350000", "040770" ], + "040711" : [ "11:51", "350000", "040771" ], + "040712" : [ "11:52", "350000", "040772" ], + "040713" : [ "11:53", "350000", "040773" ], + "040714" : [ "11:54", "350000", "040774" ], + "040715" : [ "11:55", "350000", "040775" ], + "040716" : [ "11:56", "350000", "040776" ], + "040717" : [ "11:57", "350000", "040777" ], + "040718" : [ "11:58", "350000", "040778" ], + "040719" : [ "11:59", "350000", "040779" ], + "040720" : [ "12:00", "350000", "040780" ], + "040721" : [ "12:01", "350000", "040781" ], + "040722" : [ "12:02", "350000", "040782" ], + "040723" : [ "12:03", "350000", "040783" ], + "040724" : [ "12:04", "350000", "040784" ], + "040725" : [ "12:05", "350000", "040785" ], + "040726" : [ "12:06", "350000", "040786" ], + "040727" : [ "12:07", "350000", "040787" ], + "040728" : [ "12:08", "350000", "040788" ], + "040729" : [ "12:09", "350000", "040789" ], + "040730" : [ "12:10", "350000", "040790" ], + "040731" : [ "12:11", "350000", "040791" ], + "040732" : [ "12:12", "350000", "040792" ], + "040733" : [ "12:13", "350000", "040793" ], + "040734" : [ "12:14", "350000", "040794" ], + "040735" : [ "12:15", "350000", "040795" ], + "040736" : [ "12:16", "350000", "040796" ], + "040737" : [ "12:17", "350000", "040797" ], + "040738" : [ "12:18", "350000", "040798" ], + "040739" : [ "12:19", "350000", "040799" ], + "040740" : [ "12:20", "350000", "040800" ], + "040741" : [ "12:21", "350000", "040801" ], + "040742" : [ "12:22", "350000", "040802" ], + "040743" : [ "12:23", "350000", "040803" ], + "040744" : [ "12:24", "350000", "040804" ], + "040745" : [ "12:25", "350000", "040805" ], + "040746" : [ "12:26", "350000", "040806" ], + "040747" : [ "12:27", "350000", "040807" ], + "040748" : [ "12:28", "350000", "040808" ], + "040749" : [ "12:29", "350000", "040809" ], + "040750" : [ "12:30", "350000", "040810" ], + "040751" : [ "12:31", "350000", "040811" ], + "040752" : [ "12:32", "350000", "040812" ], + "040753" : [ "12:33", "350000", "040813" ], + "040754" : [ "12:34", "350000", "040814" ], + "040755" : [ "12:35", "350000", "040815" ], + "040756" : [ "12:36", "350000", "040816" ], + "040757" : [ "12:37", "350000", "040817" ], + "040758" : [ "12:38", "350000", "040818" ], + "040759" : [ "12:39", "350000", "040819" ], + "040760" : [ "12:40", "350000", "040820" ], + "040761" : [ "12:41", "350000", "040821" ], + "040762" : [ "12:42", "350000", "040822" ], + "040763" : [ "12:43", "350000", "040823" ], + "040764" : [ "12:44", "350000", "040824" ], + "040765" : [ "12:45", "350000", "040825" ], + "040766" : [ "12:46", "350000", "040826" ], + "040767" : [ "12:47", "350000", "040827" ], + "040768" : [ "12:48", "350000", "040828" ], + "040769" : [ "12:49", "350000", "040829" ], + "040770" : [ "12:50", "350000", "040830" ], + "040771" : [ "12:51", "350000", "040831" ], + "040772" : [ "12:52", "350000", "040832" ], + "040773" : [ "12:53", "350000", "040833" ], + "040774" : [ "12:54", "350000", "040834" ], + "040775" : [ "12:55", "350000", "040835" ], + "040776" : [ "12:56", "350000", "040836" ], + "040777" : [ "12:57", "350000", "040837" ], + "040778" : [ "12:58", "350000", "040838" ], + "040779" : [ "12:59", "350000", "040839" ], + "040780" : [ "13:00", "350000", "040840" ], + "040781" : [ "13:01", "350000", "040841" ], + "040782" : [ "13:02", "350000", "040842" ], + "040783" : [ "13:03", "350000", "040843" ], + "040784" : [ "13:04", "350000", "040844" ], + "040785" : [ "13:05", "350000", "040845" ], + "040786" : [ "13:06", "350000", "040846" ], + "040787" : [ "13:07", "350000", "040847" ], + "040788" : [ "13:08", "350000", "040848" ], + "040789" : [ "13:09", "350000", "040849" ], + "040790" : [ "13:10", "350000", "040850" ], + "040791" : [ "13:11", "350000", "040851" ], + "040792" : [ "13:12", "350000", "040852" ], + "040793" : [ "13:13", "350000", "040853" ], + "040794" : [ "13:14", "350000", "040854" ], + "040795" : [ "13:15", "350000", "040855" ], + "040796" : [ "13:16", "350000", "040856" ], + "040797" : [ "13:17", "350000", "040857" ], + "040798" : [ "13:18", "350000", "040858" ], + "040799" : [ "13:19", "350000", "040859" ], + "040800" : [ "13:20", "350000", "040860" ], + "040801" : [ "13:21", "350000", "040861" ], + "040802" : [ "13:22", "350000", "040862" ], + "040803" : [ "13:23", "350000", "040863" ], + "040804" : [ "13:24", "350000", "040864" ], + "040805" : [ "13:25", "350000", "040865" ], + "040806" : [ "13:26", "350000", "040866" ], + "040807" : [ "13:27", "350000", "040867" ], + "040808" : [ "13:28", "350000", "040868" ], + "040809" : [ "13:29", "350000", "040869" ], + "040810" : [ "13:30", "350000", "040870" ], + "040811" : [ "13:31", "350000", "040871" ], + "040812" : [ "13:32", "350000", "040872" ], + "040813" : [ "13:33", "350000", "040873" ], + "040814" : [ "13:34", "350000", "040874" ], + "040815" : [ "13:35", "350000", "040875" ], + "040816" : [ "13:36", "350000", "040876" ], + "040817" : [ "13:37", "350000", "040877" ], + "040818" : [ "13:38", "350000", "040878" ], + "040819" : [ "13:39", "350000", "040879" ], + "040820" : [ "13:40", "350000", "040880" ], + "040821" : [ "13:41", "350000", "040881" ], + "040822" : [ "13:42", "350000", "040882" ], + "040823" : [ "13:43", "350000", "040883" ], + "040824" : [ "13:44", "350000", "040884" ], + "040825" : [ "13:45", "350000", "040885" ], + "040826" : [ "13:46", "350000", "040886" ], + "040827" : [ "13:47", "350000", "040887" ], + "040828" : [ "13:48", "350000", "040888" ], + "040829" : [ "13:49", "350000", "040889" ], + "040830" : [ "13:50", "350000", "040890" ], + "040831" : [ "13:51", "350000", "040891" ], + "040832" : [ "13:52", "350000", "040892" ], + "040833" : [ "13:53", "350000", "040893" ], + "040834" : [ "13:54", "350000", "040894" ], + "040835" : [ "13:55", "350000", "040895" ], + "040836" : [ "13:56", "350000", "040896" ], + "040837" : [ "13:57", "350000", "040897" ], + "040838" : [ "13:58", "350000", "040898" ], + "040839" : [ "13:59", "350000", "040899" ], + "040840" : [ "14:00", "350000", "040900" ], + "040841" : [ "14:01", "350000", "040901" ], + "040842" : [ "14:02", "350000", "040902" ], + "040843" : [ "14:03", "350000", "040903" ], + "040844" : [ "14:04", "350000", "040904" ], + "040845" : [ "14:05", "350000", "040905" ], + "040846" : [ "14:06", "350000", "040906" ], + "040847" : [ "14:07", "350000", "040907" ], + "040848" : [ "14:08", "350000", "040908" ], + "040849" : [ "14:09", "350000", "040909" ], + "040850" : [ "14:10", "350000", "040910" ], + "040851" : [ "14:11", "350000", "040911" ], + "040852" : [ "14:12", "350000", "040912" ], + "040853" : [ "14:13", "350000", "040913" ], + "040854" : [ "14:14", "350000", "040914" ], + "040855" : [ "14:15", "350000", "040915" ], + "040856" : [ "14:16", "350000", "040916" ], + "040857" : [ "14:17", "350000", "040917" ], + "040858" : [ "14:18", "350000", "040918" ], + "040859" : [ "14:19", "350000", "040919" ], + "040860" : [ "14:20", "350000", "040920" ], + "040861" : [ "14:21", "350000", "040921" ], + "040862" : [ "14:22", "350000", "040922" ], + "040863" : [ "14:23", "350000", "040923" ], + "040864" : [ "14:24", "350000", "040924" ], + "040865" : [ "14:25", "350000", "040925" ], + "040866" : [ "14:26", "350000", "040926" ], + "040867" : [ "14:27", "350000", "040927" ], + "040868" : [ "14:28", "350000", "040928" ], + "040869" : [ "14:29", "350000", "040929" ], + "040870" : [ "14:30", "350000", "040930" ], + "040871" : [ "14:31", "350000", "040931" ], + "040872" : [ "14:32", "350000", "040932" ], + "040873" : [ "14:33", "350000", "040933" ], + "040874" : [ "14:34", "350000", "040934" ], + "040875" : [ "14:35", "350000", "040935" ], + "040876" : [ "14:36", "350000", "040936" ], + "040877" : [ "14:37", "350000", "040937" ], + "040878" : [ "14:38", "350000", "040938" ], + "040879" : [ "14:39", "350000", "040939" ], + "040880" : [ "14:40", "350000", "040940" ], + "040881" : [ "14:41", "350000", "040941" ], + "040882" : [ "14:42", "350000", "040942" ], + "040883" : [ "14:43", "350000", "040943" ], + "040884" : [ "14:44", "350000", "040944" ], + "040885" : [ "14:45", "350000", "040945" ], + "040886" : [ "14:46", "350000", "040946" ], + "040887" : [ "14:47", "350000", "040947" ], + "040888" : [ "14:48", "350000", "040948" ], + "040889" : [ "14:49", "350000", "040949" ], + "040890" : [ "14:50", "350000", "040950" ], + "040891" : [ "14:51", "350000", "040951" ], + "040892" : [ "14:52", "350000", "040952" ], + "040893" : [ "14:53", "350000", "040953" ], + "040894" : [ "14:54", "350000", "040954" ], + "040895" : [ "14:55", "350000", "040955" ], + "040896" : [ "14:56", "350000", "040956" ], + "040897" : [ "14:57", "350000", "040957" ], + "040898" : [ "14:58", "350000", "040958" ], + "040899" : [ "14:59", "350000", "040959" ], + "040900" : [ "15:00", "350000", "040960" ], + "040901" : [ "15:01", "350000", "040961" ], + "040902" : [ "15:02", "350000", "040962" ], + "040903" : [ "15:03", "350000", "040963" ], + "040904" : [ "15:04", "350000", "040964" ], + "040905" : [ "15:05", "350000", "040965" ], + "040906" : [ "15:06", "350000", "040966" ], + "040907" : [ "15:07", "350000", "040967" ], + "040908" : [ "15:08", "350000", "040968" ], + "040909" : [ "15:09", "350000", "040969" ], + "040910" : [ "15:10", "350000", "040970" ], + "040911" : [ "15:11", "350000", "040971" ], + "040912" : [ "15:12", "350000", "040972" ], + "040913" : [ "15:13", "350000", "040973" ], + "040914" : [ "15:14", "350000", "040974" ], + "040915" : [ "15:15", "350000", "040975" ], + "040916" : [ "15:16", "350000", "040976" ], + "040917" : [ "15:17", "350000", "040977" ], + "040918" : [ "15:18", "350000", "040978" ], + "040919" : [ "15:19", "350000", "040979" ], + "040920" : [ "15:20", "350000", "040980" ], + "040921" : [ "15:21", "350000", "040981" ], + "040922" : [ "15:22", "350000", "040982" ], + "040923" : [ "15:23", "350000", "040983" ], + "040924" : [ "15:24", "350000", "040984" ], + "040925" : [ "15:25", "350000", "040985" ], + "040926" : [ "15:26", "350000", "040986" ], + "040927" : [ "15:27", "350000", "040987" ], + "040928" : [ "15:28", "350000", "040988" ], + "040929" : [ "15:29", "350000", "040989" ], + "040930" : [ "15:30", "350000", "040990" ], + "040931" : [ "15:31", "350000", "040991" ], + "040932" : [ "15:32", "350000", "040992" ], + "040933" : [ "15:33", "350000", "040993" ], + "040934" : [ "15:34", "350000", "040994" ], + "040935" : [ "15:35", "350000", "040995" ], + "040936" : [ "15:36", "350000", "040996" ], + "040937" : [ "15:37", "350000", "040997" ], + "040938" : [ "15:38", "350000", "040998" ], + "040939" : [ "15:39", "350000", "040999" ], + "040940" : [ "15:40", "350000", "041000" ], + "040941" : [ "15:41", "350000", "041001" ], + "040942" : [ "15:42", "350000", "041002" ], + "040943" : [ "15:43", "350000", "041003" ], + "040944" : [ "15:44", "350000", "041004" ], + "040945" : [ "15:45", "350000", "041005" ], + "040946" : [ "15:46", "350000", "041006" ], + "040947" : [ "15:47", "350000", "041007" ], + "040948" : [ "15:48", "350000", "041008" ], + "040949" : [ "15:49", "350000", "041009" ], + "040950" : [ "15:50", "350000", "041010" ], + "040951" : [ "15:51", "350000", "041011" ], + "040952" : [ "15:52", "350000", "041012" ], + "040953" : [ "15:53", "350000", "041013" ], + "040954" : [ "15:54", "350000", "041014" ], + "040955" : [ "15:55", "350000", "041015" ], + "040956" : [ "15:56", "350000", "041016" ], + "040957" : [ "15:57", "350000", "041017" ], + "040958" : [ "15:58", "350000", "041018" ], + "040959" : [ "15:59", "350000", "041019" ], + "040960" : [ "16:00", "350000", "041020" ], + "040961" : [ "16:01", "350000", "041021" ], + "040962" : [ "16:02", "350000", "041022" ], + "040963" : [ "16:03", "350000", "041023" ], + "040964" : [ "16:04", "350000", "041024" ], + "040965" : [ "16:05", "350000", "041025" ], + "040966" : [ "16:06", "350000", "041026" ], + "040967" : [ "16:07", "350000", "041027" ], + "040968" : [ "16:08", "350000", "041028" ], + "040969" : [ "16:09", "350000", "041029" ], + "040970" : [ "16:10", "350000", "041030" ], + "040971" : [ "16:11", "350000", "041031" ], + "040972" : [ "16:12", "350000", "041032" ], + "040973" : [ "16:13", "350000", "041033" ], + "040974" : [ "16:14", "350000", "041034" ], + "040975" : [ "16:15", "350000", "041035" ], + "040976" : [ "16:16", "350000", "041036" ], + "040977" : [ "16:17", "350000", "041037" ], + "040978" : [ "16:18", "350000", "041038" ], + "040979" : [ "16:19", "350000", "041039" ], + "040980" : [ "16:20", "350000", "041040" ], + "040981" : [ "16:21", "350000", "041041" ], + "040982" : [ "16:22", "350000", "041042" ], + "040983" : [ "16:23", "350000", "041043" ], + "040984" : [ "16:24", "350000", "041044" ], + "040985" : [ "16:25", "350000", "041045" ], + "040986" : [ "16:26", "350000", "041046" ], + "040987" : [ "16:27", "350000", "041047" ], + "040988" : [ "16:28", "350000", "041048" ], + "040989" : [ "16:29", "350000", "041049" ], + "040990" : [ "16:30", "350000", "041050" ], + "040991" : [ "16:31", "350000", "041051" ], + "040992" : [ "16:32", "350000", "041052" ], + "040993" : [ "16:33", "350000", "041053" ], + "040994" : [ "16:34", "350000", "041054" ], + "040995" : [ "16:35", "350000", "041055" ], + "040996" : [ "16:36", "350000", "041056" ], + "040997" : [ "16:37", "350000", "041057" ], + "040998" : [ "16:38", "350000", "041058" ], + "040999" : [ "16:39", "350000", "041059" ], + "041000" : [ "16:40", "350000", "041060" ], + "041001" : [ "16:41", "350000", "041061" ], + "041002" : [ "16:42", "350000", "041062" ], + "041003" : [ "16:43", "350000", "041063" ], + "041004" : [ "16:44", "350000", "041064" ], + "041005" : [ "16:45", "350000", "041065" ], + "041006" : [ "16:46", "350000", "041066" ], + "041007" : [ "16:47", "350000", "041067" ], + "041008" : [ "16:48", "350000", "041068" ], + "041009" : [ "16:49", "350000", "041069" ], + "041010" : [ "16:50", "350000", "041070" ], + "041011" : [ "16:51", "350000", "041071" ], + "041012" : [ "16:52", "350000", "041072" ], + "041013" : [ "16:53", "350000", "041073" ], + "041014" : [ "16:54", "350000", "041074" ], + "041015" : [ "16:55", "350000", "041075" ], + "041016" : [ "16:56", "350000", "041076" ], + "041017" : [ "16:57", "350000", "041077" ], + "041018" : [ "16:58", "350000", "041078" ], + "041019" : [ "16:59", "350000", "041079" ], + "041020" : [ "17:00", "350000", "041080" ], + "041021" : [ "17:01", "350000", "041081" ], + "041022" : [ "17:02", "350000", "041082" ], + "041023" : [ "17:03", "350000", "041083" ], + "041024" : [ "17:04", "350000", "041084" ], + "041025" : [ "17:05", "350000", "041085" ], + "041026" : [ "17:06", "350000", "041086" ], + "041027" : [ "17:07", "350000", "041087" ], + "041028" : [ "17:08", "350000", "041088" ], + "041029" : [ "17:09", "350000", "041089" ], + "041030" : [ "17:10", "350000", "041090" ], + "041031" : [ "17:11", "350000", "041091" ], + "041032" : [ "17:12", "350000", "041092" ], + "041033" : [ "17:13", "350000", "041093" ], + "041034" : [ "17:14", "350000", "041094" ], + "041035" : [ "17:15", "350000", "041095" ], + "041036" : [ "17:16", "350000", "041096" ], + "041037" : [ "17:17", "350000", "041097" ], + "041038" : [ "17:18", "350000", "041098" ], + "041039" : [ "17:19", "350000", "041099" ], + "041040" : [ "17:20", "350000", "041100" ], + "041041" : [ "17:21", "350000", "041101" ], + "041042" : [ "17:22", "350000", "041102" ], + "041043" : [ "17:23", "350000", "041103" ], + "041044" : [ "17:24", "350000", "041104" ], + "041045" : [ "17:25", "350000", "041105" ], + "041046" : [ "17:26", "350000", "041106" ], + "041047" : [ "17:27", "350000", "041107" ], + "041048" : [ "17:28", "350000", "041108" ], + "041049" : [ "17:29", "350000", "041109" ], + "041050" : [ "17:30", "350000", "041110" ], + "041051" : [ "17:31", "350000", "041111" ], + "041052" : [ "17:32", "350000", "041112" ], + "041053" : [ "17:33", "350000", "041113" ], + "041054" : [ "17:34", "350000", "041114" ], + "041055" : [ "17:35", "350000", "041115" ], + "041056" : [ "17:36", "350000", "041116" ], + "041057" : [ "17:37", "350000", "041117" ], + "041058" : [ "17:38", "350000", "041118" ], + "041059" : [ "17:39", "350000", "041119" ], + "041060" : [ "17:40", "350000", "041120" ], + "041061" : [ "17:41", "350000", "041121" ], + "041062" : [ "17:42", "350000", "041122" ], + "041063" : [ "17:43", "350000", "041123" ], + "041064" : [ "17:44", "350000", "041124" ], + "041065" : [ "17:45", "350000", "041125" ], + "041066" : [ "17:46", "350000", "041126" ], + "041067" : [ "17:47", "350000", "041127" ], + "041068" : [ "17:48", "350000", "041128" ], + "041069" : [ "17:49", "350000", "041129" ], + "041070" : [ "17:50", "350000", "041130" ], + "041071" : [ "17:51", "350000", "041131" ], + "041072" : [ "17:52", "350000", "041132" ], + "041073" : [ "17:53", "350000", "041133" ], + "041074" : [ "17:54", "350000", "041134" ], + "041075" : [ "17:55", "350000", "041135" ], + "041076" : [ "17:56", "350000", "041136" ], + "041077" : [ "17:57", "350000", "041137" ], + "041078" : [ "17:58", "350000", "041138" ], + "041079" : [ "17:59", "350000", "041139" ], + "041080" : [ "18:00", "350000", "041140" ], + "041081" : [ "18:01", "350000", "041141" ], + "041082" : [ "18:02", "350000", "041142" ], + "041083" : [ "18:03", "350000", "041143" ], + "041084" : [ "18:04", "350000", "041144" ], + "041085" : [ "18:05", "350000", "041145" ], + "041086" : [ "18:06", "350000", "041146" ], + "041087" : [ "18:07", "350000", "041147" ], + "041088" : [ "18:08", "350000", "041148" ], + "041089" : [ "18:09", "350000", "041149" ], + "041090" : [ "18:10", "350000", "041150" ], + "041091" : [ "18:11", "350000", "041151" ], + "041092" : [ "18:12", "350000", "041152" ], + "041093" : [ "18:13", "350000", "041153" ], + "041094" : [ "18:14", "350000", "041154" ], + "041095" : [ "18:15", "350000", "041155" ], + "041096" : [ "18:16", "350000", "041156" ], + "041097" : [ "18:17", "350000", "041157" ], + "041098" : [ "18:18", "350000", "041158" ], + "041099" : [ "18:19", "350000", "041159" ], + "041100" : [ "18:20", "350000", "041160" ], + "041101" : [ "18:21", "350000", "041161" ], + "041102" : [ "18:22", "350000", "041162" ], + "041103" : [ "18:23", "350000", "041163" ], + "041104" : [ "18:24", "350000", "041164" ], + "041105" : [ "18:25", "350000", "041165" ], + "041106" : [ "18:26", "350000", "041166" ], + "041107" : [ "18:27", "350000", "041167" ], + "041108" : [ "18:28", "350000", "041168" ], + "041109" : [ "18:29", "350000", "041169" ], + "041110" : [ "18:30", "350000", "041170" ], + "041111" : [ "18:31", "350000", "041171" ], + "041112" : [ "18:32", "350000", "041172" ], + "041113" : [ "18:33", "350000", "041173" ], + "041114" : [ "18:34", "350000", "041174" ], + "041115" : [ "18:35", "350000", "041175" ], + "041116" : [ "18:36", "350000", "041176" ], + "041117" : [ "18:37", "350000", "041177" ], + "041118" : [ "18:38", "350000", "041178" ], + "041119" : [ "18:39", "350000", "041179" ], + "041120" : [ "18:40", "350000", "041180" ], + "041121" : [ "18:41", "350000", "041181" ], + "041122" : [ "18:42", "350000", "041182" ], + "041123" : [ "18:43", "350000", "041183" ], + "041124" : [ "18:44", "350000", "041184" ], + "041125" : [ "18:45", "350000", "041185" ], + "041126" : [ "18:46", "350000", "041186" ], + "041127" : [ "18:47", "350000", "041187" ], + "041128" : [ "18:48", "350000", "041188" ], + "041129" : [ "18:49", "350000", "041189" ], + "041130" : [ "18:50", "350000", "041190" ], + "041131" : [ "18:51", "350000", "041191" ], + "041132" : [ "18:52", "350000", "041192" ], + "041133" : [ "18:53", "350000", "041193" ], + "041134" : [ "18:54", "350000", "041194" ], + "041135" : [ "18:55", "350000", "041195" ], + "041136" : [ "18:56", "350000", "041196" ], + "041137" : [ "18:57", "350000", "041197" ], + "041138" : [ "18:58", "350000", "041198" ], + "041139" : [ "18:59", "350000", "041199" ], + "041140" : [ "19:00", "350000", "041200" ], + "041141" : [ "19:01", "350000", "041200" ], + "041142" : [ "19:02", "350000", "041200" ], + "041143" : [ "19:03", "350000", "041200" ], + "041144" : [ "19:04", "350000", "041200" ], + "041145" : [ "19:05", "350000", "041200" ], + "041146" : [ "19:06", "350000", "041200" ], + "041147" : [ "19:07", "350000", "041200" ], + "041148" : [ "19:08", "350000", "041200" ], + "041149" : [ "19:09", "350000", "041200" ], + "041150" : [ "19:10", "350000", "041200" ], + "041151" : [ "19:11", "350000", "041200" ], + "041152" : [ "19:12", "350000", "041200" ], + "041153" : [ "19:13", "350000", "041200" ], + "041154" : [ "19:14", "350000", "041200" ], + "041155" : [ "19:15", "350000", "041200" ], + "041156" : [ "19:16", "350000", "041200" ], + "041157" : [ "19:17", "350000", "041200" ], + "041158" : [ "19:18", "350000", "041200" ], + "041159" : [ "19:19", "350000", "041200" ], + "041160" : [ "19:20", "350000", "041200" ], + "041161" : [ "19:21", "350000", "041200" ], + "041162" : [ "19:22", "350000", "041200" ], + "041163" : [ "19:23", "350000", "041200" ], + "041164" : [ "19:24", "350000", "041200" ], + "041165" : [ "19:25", "350000", "041200" ], + "041166" : [ "19:26", "350000", "041200" ], + "041167" : [ "19:27", "350000", "041200" ], + "041168" : [ "19:28", "350000", "041200" ], + "041169" : [ "19:29", "350000", "041200" ], + "041170" : [ "19:30", "350000", "041200" ], + "041171" : [ "19:31", "350000", "041200" ], + "041172" : [ "19:32", "350000", "041200" ], + "041173" : [ "19:33", "350000", "041200" ], + "041174" : [ "19:34", "350000", "041200" ], + "041175" : [ "19:35", "350000", "041200" ], + "041176" : [ "19:36", "350000", "041200" ], + "041177" : [ "19:37", "350000", "041200" ], + "041178" : [ "19:38", "350000", "041200" ], + "041179" : [ "19:39", "350000", "041200" ], + "041180" : [ "19:40", "350000", "041200" ], + "041181" : [ "19:41", "350000", "041200" ], + "041182" : [ "19:42", "350000", "041200" ], + "041183" : [ "19:43", "350000", "041200" ], + "041184" : [ "19:44", "350000", "041200" ], + "041185" : [ "19:45", "350000", "041200" ], + "041186" : [ "19:46", "350000", "041200" ], + "041187" : [ "19:47", "350000", "041200" ], + "041188" : [ "19:48", "350000", "041200" ], + "041189" : [ "19:49", "350000", "041200" ], + "041190" : [ "19:50", "350000", "041200" ], + "041191" : [ "19:51", "350000", "041200" ], + "041192" : [ "19:52", "350000", "041200" ], + "041193" : [ "19:53", "350000", "041200" ], + "041194" : [ "19:54", "350000", "041200" ], + "041195" : [ "19:55", "350000", "041200" ], + "041196" : [ "19:56", "350000", "041200" ], + "041197" : [ "19:57", "350000", "041200" ], + "041198" : [ "19:58", "350000", "041200" ], + "041199" : [ "19:59", "350000", "041200" ], + "041200" : [ "20:00", "800000", "050420" ], + "041201" : [ "20:01", "800000", "050420" ], + "041202" : [ "20:02", "800000", "050420" ], + "041203" : [ "20:03", "800000", "050420" ], + "041204" : [ "20:04", "800000", "050420" ], + "041205" : [ "20:05", "800000", "050420" ], + "041206" : [ "20:06", "800000", "050420" ], + "041207" : [ "20:07", "800000", "050420" ], + "041208" : [ "20:08", "800000", "050420" ], + "041209" : [ "20:09", "800000", "050420" ], + "041210" : [ "20:10", "800000", "050420" ], + "041211" : [ "20:11", "800000", "050420" ], + "041212" : [ "20:12", "800000", "050420" ], + "041213" : [ "20:13", "800000", "050420" ], + "041214" : [ "20:14", "800000", "050420" ], + "041215" : [ "20:15", "800000", "050420" ], + "041216" : [ "20:16", "800000", "050420" ], + "041217" : [ "20:17", "800000", "050420" ], + "041218" : [ "20:18", "800000", "050420" ], + "041219" : [ "20:19", "800000", "050420" ], + "041220" : [ "20:20", "800000", "050420" ], + "041221" : [ "20:21", "800000", "050420" ], + "041222" : [ "20:22", "800000", "050420" ], + "041223" : [ "20:23", "800000", "050420" ], + "041224" : [ "20:24", "800000", "050420" ], + "041225" : [ "20:25", "800000", "050420" ], + "041226" : [ "20:26", "800000", "050420" ], + "041227" : [ "20:27", "800000", "050420" ], + "041228" : [ "20:28", "800000", "050420" ], + "041229" : [ "20:29", "800000", "050420" ], + "041230" : [ "20:30", "800000", "050420" ], + "041231" : [ "20:31", "800000", "050420" ], + "041232" : [ "20:32", "800000", "050420" ], + "041233" : [ "20:33", "800000", "050420" ], + "041234" : [ "20:34", "800000", "050420" ], + "041235" : [ "20:35", "800000", "050420" ], + "041236" : [ "20:36", "800000", "050420" ], + "041237" : [ "20:37", "800000", "050420" ], + "041238" : [ "20:38", "800000", "050420" ], + "041239" : [ "20:39", "800000", "050420" ], + "041240" : [ "20:40", "800000", "050420" ], + "041241" : [ "20:41", "800000", "050420" ], + "041242" : [ "20:42", "800000", "050420" ], + "041243" : [ "20:43", "800000", "050420" ], + "041244" : [ "20:44", "800000", "050420" ], + "041245" : [ "20:45", "800000", "050420" ], + "041246" : [ "20:46", "800000", "050420" ], + "041247" : [ "20:47", "800000", "050420" ], + "041248" : [ "20:48", "800000", "050420" ], + "041249" : [ "20:49", "800000", "050420" ], + "041250" : [ "20:50", "800000", "050420" ], + "041251" : [ "20:51", "800000", "050420" ], + "041252" : [ "20:52", "800000", "050420" ], + "041253" : [ "20:53", "800000", "050420" ], + "041254" : [ "20:54", "800000", "050420" ], + "041255" : [ "20:55", "800000", "050420" ], + "041256" : [ "20:56", "800000", "050420" ], + "041257" : [ "20:57", "800000", "050420" ], + "041258" : [ "20:58", "800000", "050420" ], + "041259" : [ "20:59", "800000", "050420" ], + "041260" : [ "21:00", "800000", "050420" ], + "041261" : [ "21:01", "800000", "050420" ], + "041262" : [ "21:02", "800000", "050420" ], + "041263" : [ "21:03", "800000", "050420" ], + "041264" : [ "21:04", "800000", "050420" ], + "041265" : [ "21:05", "800000", "050420" ], + "041266" : [ "21:06", "800000", "050420" ], + "041267" : [ "21:07", "800000", "050420" ], + "041268" : [ "21:08", "800000", "050420" ], + "041269" : [ "21:09", "800000", "050420" ], + "041270" : [ "21:10", "800000", "050420" ], + "041271" : [ "21:11", "800000", "050420" ], + "041272" : [ "21:12", "800000", "050420" ], + "041273" : [ "21:13", "800000", "050420" ], + "041274" : [ "21:14", "800000", "050420" ], + "041275" : [ "21:15", "800000", "050420" ], + "041276" : [ "21:16", "800000", "050420" ], + "041277" : [ "21:17", "800000", "050420" ], + "041278" : [ "21:18", "800000", "050420" ], + "041279" : [ "21:19", "800000", "050420" ], + "041280" : [ "21:20", "800000", "050420" ], + "041281" : [ "21:21", "800000", "050420" ], + "041282" : [ "21:22", "800000", "050420" ], + "041283" : [ "21:23", "800000", "050420" ], + "041284" : [ "21:24", "800000", "050420" ], + "041285" : [ "21:25", "800000", "050420" ], + "041286" : [ "21:26", "800000", "050420" ], + "041287" : [ "21:27", "800000", "050420" ], + "041288" : [ "21:28", "800000", "050420" ], + "041289" : [ "21:29", "800000", "050420" ], + "041290" : [ "21:30", "800000", "050420" ], + "041291" : [ "21:31", "800000", "050420" ], + "041292" : [ "21:32", "800000", "050420" ], + "041293" : [ "21:33", "800000", "050420" ], + "041294" : [ "21:34", "800000", "050420" ], + "041295" : [ "21:35", "800000", "050420" ], + "041296" : [ "21:36", "800000", "050420" ], + "041297" : [ "21:37", "800000", "050420" ], + "041298" : [ "21:38", "800000", "050420" ], + "041299" : [ "21:39", "800000", "050420" ], + "041300" : [ "21:40", "800000", "050420" ], + "041301" : [ "21:41", "800000", "050420" ], + "041302" : [ "21:42", "800000", "050420" ], + "041303" : [ "21:43", "800000", "050420" ], + "041304" : [ "21:44", "800000", "050420" ], + "041305" : [ "21:45", "800000", "050420" ], + "041306" : [ "21:46", "800000", "050420" ], + "041307" : [ "21:47", "800000", "050420" ], + "041308" : [ "21:48", "800000", "050420" ], + "041309" : [ "21:49", "800000", "050420" ], + "041310" : [ "21:50", "800000", "050420" ], + "041311" : [ "21:51", "800000", "050420" ], + "041312" : [ "21:52", "800000", "050420" ], + "041313" : [ "21:53", "800000", "050420" ], + "041314" : [ "21:54", "800000", "050420" ], + "041315" : [ "21:55", "800000", "050420" ], + "041316" : [ "21:56", "800000", "050420" ], + "041317" : [ "21:57", "800000", "050420" ], + "041318" : [ "21:58", "800000", "050420" ], + "041319" : [ "21:59", "800000", "050420" ], + "041320" : [ "22:00", "800000", "050420" ], + "041321" : [ "22:01", "800000", "050420" ], + "041322" : [ "22:02", "800000", "050420" ], + "041323" : [ "22:03", "800000", "050420" ], + "041324" : [ "22:04", "800000", "050420" ], + "041325" : [ "22:05", "800000", "050420" ], + "041326" : [ "22:06", "800000", "050420" ], + "041327" : [ "22:07", "800000", "050420" ], + "041328" : [ "22:08", "800000", "050420" ], + "041329" : [ "22:09", "800000", "050420" ], + "041330" : [ "22:10", "800000", "050420" ], + "041331" : [ "22:11", "800000", "050420" ], + "041332" : [ "22:12", "800000", "050420" ], + "041333" : [ "22:13", "800000", "050420" ], + "041334" : [ "22:14", "800000", "050420" ], + "041335" : [ "22:15", "800000", "050420" ], + "041336" : [ "22:16", "800000", "050420" ], + "041337" : [ "22:17", "800000", "050420" ], + "041338" : [ "22:18", "800000", "050420" ], + "041339" : [ "22:19", "800000", "050420" ], + "041340" : [ "22:20", "800000", "050420" ], + "041341" : [ "22:21", "800000", "050420" ], + "041342" : [ "22:22", "800000", "050420" ], + "041343" : [ "22:23", "800000", "050420" ], + "041344" : [ "22:24", "800000", "050420" ], + "041345" : [ "22:25", "800000", "050420" ], + "041346" : [ "22:26", "800000", "050420" ], + "041347" : [ "22:27", "800000", "050420" ], + "041348" : [ "22:28", "800000", "050420" ], + "041349" : [ "22:29", "800000", "050420" ], + "041350" : [ "22:30", "800000", "050420" ], + "041351" : [ "22:31", "800000", "050420" ], + "041352" : [ "22:32", "800000", "050420" ], + "041353" : [ "22:33", "800000", "050420" ], + "041354" : [ "22:34", "800000", "050420" ], + "041355" : [ "22:35", "800000", "050420" ], + "041356" : [ "22:36", "800000", "050420" ], + "041357" : [ "22:37", "800000", "050420" ], + "041358" : [ "22:38", "800000", "050420" ], + "041359" : [ "22:39", "800000", "050420" ], + "041360" : [ "22:40", "800000", "050420" ], + "041361" : [ "22:41", "800000", "050420" ], + "041362" : [ "22:42", "800000", "050420" ], + "041363" : [ "22:43", "800000", "050420" ], + "041364" : [ "22:44", "800000", "050420" ], + "041365" : [ "22:45", "800000", "050420" ], + "041366" : [ "22:46", "800000", "050420" ], + "041367" : [ "22:47", "800000", "050420" ], + "041368" : [ "22:48", "800000", "050420" ], + "041369" : [ "22:49", "800000", "050420" ], + "041370" : [ "22:50", "800000", "050420" ], + "041371" : [ "22:51", "800000", "050420" ], + "041372" : [ "22:52", "800000", "050420" ], + "041373" : [ "22:53", "800000", "050420" ], + "041374" : [ "22:54", "800000", "050420" ], + "041375" : [ "22:55", "800000", "050420" ], + "041376" : [ "22:56", "800000", "050420" ], + "041377" : [ "22:57", "800000", "050420" ], + "041378" : [ "22:58", "800000", "050420" ], + "041379" : [ "22:59", "800000", "050420" ], + "041380" : [ "23:00", "800000", "050420" ], + "041381" : [ "23:01", "800000", "050420" ], + "041382" : [ "23:02", "800000", "050420" ], + "041383" : [ "23:03", "800000", "050420" ], + "041384" : [ "23:04", "800000", "050420" ], + "041385" : [ "23:05", "800000", "050420" ], + "041386" : [ "23:06", "800000", "050420" ], + "041387" : [ "23:07", "800000", "050420" ], + "041388" : [ "23:08", "800000", "050420" ], + "041389" : [ "23:09", "800000", "050420" ], + "041390" : [ "23:10", "800000", "050420" ], + "041391" : [ "23:11", "800000", "050420" ], + "041392" : [ "23:12", "800000", "050420" ], + "041393" : [ "23:13", "800000", "050420" ], + "041394" : [ "23:14", "800000", "050420" ], + "041395" : [ "23:15", "800000", "050420" ], + "041396" : [ "23:16", "800000", "050420" ], + "041397" : [ "23:17", "800000", "050420" ], + "041398" : [ "23:18", "800000", "050420" ], + "041399" : [ "23:19", "800000", "050420" ], + "041400" : [ "23:20", "800000", "050420" ], + "041401" : [ "23:21", "800000", "050420" ], + "041402" : [ "23:22", "800000", "050420" ], + "041403" : [ "23:23", "800000", "050420" ], + "041404" : [ "23:24", "800000", "050420" ], + "041405" : [ "23:25", "800000", "050420" ], + "041406" : [ "23:26", "800000", "050420" ], + "041407" : [ "23:27", "800000", "050420" ], + "041408" : [ "23:28", "800000", "050420" ], + "041409" : [ "23:29", "800000", "050420" ], + "041410" : [ "23:30", "800000", "050420" ], + "041411" : [ "23:31", "800000", "050420" ], + "041412" : [ "23:32", "800000", "050420" ], + "041413" : [ "23:33", "800000", "050420" ], + "041414" : [ "23:34", "800000", "050420" ], + "041415" : [ "23:35", "800000", "050420" ], + "041416" : [ "23:36", "800000", "050420" ], + "041417" : [ "23:37", "800000", "050420" ], + "041418" : [ "23:38", "800000", "050420" ], + "041419" : [ "23:39", "800000", "050420" ], + "041420" : [ "23:40", "800000", "050420" ], + "041421" : [ "23:41", "800000", "050420" ], + "041422" : [ "23:42", "800000", "050420" ], + "041423" : [ "23:43", "800000", "050420" ], + "041424" : [ "23:44", "800000", "050420" ], + "041425" : [ "23:45", "800000", "050420" ], + "041426" : [ "23:46", "800000", "050420" ], + "041427" : [ "23:47", "800000", "050420" ], + "041428" : [ "23:48", "800000", "050420" ], + "041429" : [ "23:49", "800000", "050420" ], + "041430" : [ "23:50", "800000", "050420" ], + "041431" : [ "23:51", "800000", "050420" ], + "041432" : [ "23:52", "800000", "050420" ], + "041433" : [ "23:53", "800000", "050420" ], + "041434" : [ "23:54", "800000", "050420" ], + "041435" : [ "23:55", "800000", "050420" ], + "041436" : [ "23:56", "800000", "050420" ], + "041437" : [ "23:57", "800000", "050420" ], + "041438" : [ "23:58", "800000", "050420" ], + "041439" : [ "23:59", "800000", "050420" ] + }, + "Saturday": { + "050000" : [ "00:00", "800000", "050420" ], + "050001" : [ "00:01", "800000", "050420" ], + "050002" : [ "00:02", "800000", "050420" ], + "050003" : [ "00:03", "800000", "050420" ], + "050004" : [ "00:04", "800000", "050420" ], + "050005" : [ "00:05", "800000", "050420" ], + "050006" : [ "00:06", "800000", "050420" ], + "050007" : [ "00:07", "800000", "050420" ], + "050008" : [ "00:08", "800000", "050420" ], + "050009" : [ "00:09", "800000", "050420" ], + "050010" : [ "00:10", "800000", "050420" ], + "050011" : [ "00:11", "800000", "050420" ], + "050012" : [ "00:12", "800000", "050420" ], + "050013" : [ "00:13", "800000", "050420" ], + "050014" : [ "00:14", "800000", "050420" ], + "050015" : [ "00:15", "800000", "050420" ], + "050016" : [ "00:16", "800000", "050420" ], + "050017" : [ "00:17", "800000", "050420" ], + "050018" : [ "00:18", "800000", "050420" ], + "050019" : [ "00:19", "800000", "050420" ], + "050020" : [ "00:20", "800000", "050420" ], + "050021" : [ "00:21", "800000", "050420" ], + "050022" : [ "00:22", "800000", "050420" ], + "050023" : [ "00:23", "800000", "050420" ], + "050024" : [ "00:24", "800000", "050420" ], + "050025" : [ "00:25", "800000", "050420" ], + "050026" : [ "00:26", "800000", "050420" ], + "050027" : [ "00:27", "800000", "050420" ], + "050028" : [ "00:28", "800000", "050420" ], + "050029" : [ "00:29", "800000", "050420" ], + "050030" : [ "00:30", "800000", "050420" ], + "050031" : [ "00:31", "800000", "050420" ], + "050032" : [ "00:32", "800000", "050420" ], + "050033" : [ "00:33", "800000", "050420" ], + "050034" : [ "00:34", "800000", "050420" ], + "050035" : [ "00:35", "800000", "050420" ], + "050036" : [ "00:36", "800000", "050420" ], + "050037" : [ "00:37", "800000", "050420" ], + "050038" : [ "00:38", "800000", "050420" ], + "050039" : [ "00:39", "800000", "050420" ], + "050040" : [ "00:40", "800000", "050420" ], + "050041" : [ "00:41", "800000", "050420" ], + "050042" : [ "00:42", "800000", "050420" ], + "050043" : [ "00:43", "800000", "050420" ], + "050044" : [ "00:44", "800000", "050420" ], + "050045" : [ "00:45", "800000", "050420" ], + "050046" : [ "00:46", "800000", "050420" ], + "050047" : [ "00:47", "800000", "050420" ], + "050048" : [ "00:48", "800000", "050420" ], + "050049" : [ "00:49", "800000", "050420" ], + "050050" : [ "00:50", "800000", "050420" ], + "050051" : [ "00:51", "800000", "050420" ], + "050052" : [ "00:52", "800000", "050420" ], + "050053" : [ "00:53", "800000", "050420" ], + "050054" : [ "00:54", "800000", "050420" ], + "050055" : [ "00:55", "800000", "050420" ], + "050056" : [ "00:56", "800000", "050420" ], + "050057" : [ "00:57", "800000", "050420" ], + "050058" : [ "00:58", "800000", "050420" ], + "050059" : [ "00:59", "800000", "050420" ], + "050060" : [ "01:00", "800000", "050420" ], + "050061" : [ "01:01", "800000", "050420" ], + "050062" : [ "01:02", "800000", "050420" ], + "050063" : [ "01:03", "800000", "050420" ], + "050064" : [ "01:04", "800000", "050420" ], + "050065" : [ "01:05", "800000", "050420" ], + "050066" : [ "01:06", "800000", "050420" ], + "050067" : [ "01:07", "800000", "050420" ], + "050068" : [ "01:08", "800000", "050420" ], + "050069" : [ "01:09", "800000", "050420" ], + "050070" : [ "01:10", "800000", "050420" ], + "050071" : [ "01:11", "800000", "050420" ], + "050072" : [ "01:12", "800000", "050420" ], + "050073" : [ "01:13", "800000", "050420" ], + "050074" : [ "01:14", "800000", "050420" ], + "050075" : [ "01:15", "800000", "050420" ], + "050076" : [ "01:16", "800000", "050420" ], + "050077" : [ "01:17", "800000", "050420" ], + "050078" : [ "01:18", "800000", "050420" ], + "050079" : [ "01:19", "800000", "050420" ], + "050080" : [ "01:20", "800000", "050420" ], + "050081" : [ "01:21", "800000", "050420" ], + "050082" : [ "01:22", "800000", "050420" ], + "050083" : [ "01:23", "800000", "050420" ], + "050084" : [ "01:24", "800000", "050420" ], + "050085" : [ "01:25", "800000", "050420" ], + "050086" : [ "01:26", "800000", "050420" ], + "050087" : [ "01:27", "800000", "050420" ], + "050088" : [ "01:28", "800000", "050420" ], + "050089" : [ "01:29", "800000", "050420" ], + "050090" : [ "01:30", "800000", "050420" ], + "050091" : [ "01:31", "800000", "050420" ], + "050092" : [ "01:32", "800000", "050420" ], + "050093" : [ "01:33", "800000", "050420" ], + "050094" : [ "01:34", "800000", "050420" ], + "050095" : [ "01:35", "800000", "050420" ], + "050096" : [ "01:36", "800000", "050420" ], + "050097" : [ "01:37", "800000", "050420" ], + "050098" : [ "01:38", "800000", "050420" ], + "050099" : [ "01:39", "800000", "050420" ], + "050100" : [ "01:40", "800000", "050420" ], + "050101" : [ "01:41", "800000", "050420" ], + "050102" : [ "01:42", "800000", "050420" ], + "050103" : [ "01:43", "800000", "050420" ], + "050104" : [ "01:44", "800000", "050420" ], + "050105" : [ "01:45", "800000", "050420" ], + "050106" : [ "01:46", "800000", "050420" ], + "050107" : [ "01:47", "800000", "050420" ], + "050108" : [ "01:48", "800000", "050420" ], + "050109" : [ "01:49", "800000", "050420" ], + "050110" : [ "01:50", "800000", "050420" ], + "050111" : [ "01:51", "800000", "050420" ], + "050112" : [ "01:52", "800000", "050420" ], + "050113" : [ "01:53", "800000", "050420" ], + "050114" : [ "01:54", "800000", "050420" ], + "050115" : [ "01:55", "800000", "050420" ], + "050116" : [ "01:56", "800000", "050420" ], + "050117" : [ "01:57", "800000", "050420" ], + "050118" : [ "01:58", "800000", "050420" ], + "050119" : [ "01:59", "800000", "050420" ], + "050120" : [ "02:00", "800000", "050420" ], + "050121" : [ "02:01", "800000", "050420" ], + "050122" : [ "02:02", "800000", "050420" ], + "050123" : [ "02:03", "800000", "050420" ], + "050124" : [ "02:04", "800000", "050420" ], + "050125" : [ "02:05", "800000", "050420" ], + "050126" : [ "02:06", "800000", "050420" ], + "050127" : [ "02:07", "800000", "050420" ], + "050128" : [ "02:08", "800000", "050420" ], + "050129" : [ "02:09", "800000", "050420" ], + "050130" : [ "02:10", "800000", "050420" ], + "050131" : [ "02:11", "800000", "050420" ], + "050132" : [ "02:12", "800000", "050420" ], + "050133" : [ "02:13", "800000", "050420" ], + "050134" : [ "02:14", "800000", "050420" ], + "050135" : [ "02:15", "800000", "050420" ], + "050136" : [ "02:16", "800000", "050420" ], + "050137" : [ "02:17", "800000", "050420" ], + "050138" : [ "02:18", "800000", "050420" ], + "050139" : [ "02:19", "800000", "050420" ], + "050140" : [ "02:20", "800000", "050420" ], + "050141" : [ "02:21", "800000", "050420" ], + "050142" : [ "02:22", "800000", "050420" ], + "050143" : [ "02:23", "800000", "050420" ], + "050144" : [ "02:24", "800000", "050420" ], + "050145" : [ "02:25", "800000", "050420" ], + "050146" : [ "02:26", "800000", "050420" ], + "050147" : [ "02:27", "800000", "050420" ], + "050148" : [ "02:28", "800000", "050420" ], + "050149" : [ "02:29", "800000", "050420" ], + "050150" : [ "02:30", "800000", "050420" ], + "050151" : [ "02:31", "800000", "050420" ], + "050152" : [ "02:32", "800000", "050420" ], + "050153" : [ "02:33", "800000", "050420" ], + "050154" : [ "02:34", "800000", "050420" ], + "050155" : [ "02:35", "800000", "050420" ], + "050156" : [ "02:36", "800000", "050420" ], + "050157" : [ "02:37", "800000", "050420" ], + "050158" : [ "02:38", "800000", "050420" ], + "050159" : [ "02:39", "800000", "050420" ], + "050160" : [ "02:40", "800000", "050420" ], + "050161" : [ "02:41", "800000", "050420" ], + "050162" : [ "02:42", "800000", "050420" ], + "050163" : [ "02:43", "800000", "050420" ], + "050164" : [ "02:44", "800000", "050420" ], + "050165" : [ "02:45", "800000", "050420" ], + "050166" : [ "02:46", "800000", "050420" ], + "050167" : [ "02:47", "800000", "050420" ], + "050168" : [ "02:48", "800000", "050420" ], + "050169" : [ "02:49", "800000", "050420" ], + "050170" : [ "02:50", "800000", "050420" ], + "050171" : [ "02:51", "800000", "050420" ], + "050172" : [ "02:52", "800000", "050420" ], + "050173" : [ "02:53", "800000", "050420" ], + "050174" : [ "02:54", "800000", "050420" ], + "050175" : [ "02:55", "800000", "050420" ], + "050176" : [ "02:56", "800000", "050420" ], + "050177" : [ "02:57", "800000", "050420" ], + "050178" : [ "02:58", "800000", "050420" ], + "050179" : [ "02:59", "800000", "050420" ], + "050180" : [ "03:00", "800000", "050420" ], + "050181" : [ "03:01", "800000", "050420" ], + "050182" : [ "03:02", "800000", "050420" ], + "050183" : [ "03:03", "800000", "050420" ], + "050184" : [ "03:04", "800000", "050420" ], + "050185" : [ "03:05", "800000", "050420" ], + "050186" : [ "03:06", "800000", "050420" ], + "050187" : [ "03:07", "800000", "050420" ], + "050188" : [ "03:08", "800000", "050420" ], + "050189" : [ "03:09", "800000", "050420" ], + "050190" : [ "03:10", "800000", "050420" ], + "050191" : [ "03:11", "800000", "050420" ], + "050192" : [ "03:12", "800000", "050420" ], + "050193" : [ "03:13", "800000", "050420" ], + "050194" : [ "03:14", "800000", "050420" ], + "050195" : [ "03:15", "800000", "050420" ], + "050196" : [ "03:16", "800000", "050420" ], + "050197" : [ "03:17", "800000", "050420" ], + "050198" : [ "03:18", "800000", "050420" ], + "050199" : [ "03:19", "800000", "050420" ], + "050200" : [ "03:20", "800000", "050420" ], + "050201" : [ "03:21", "800000", "050420" ], + "050202" : [ "03:22", "800000", "050420" ], + "050203" : [ "03:23", "800000", "050420" ], + "050204" : [ "03:24", "800000", "050420" ], + "050205" : [ "03:25", "800000", "050420" ], + "050206" : [ "03:26", "800000", "050420" ], + "050207" : [ "03:27", "800000", "050420" ], + "050208" : [ "03:28", "800000", "050420" ], + "050209" : [ "03:29", "800000", "050420" ], + "050210" : [ "03:30", "800000", "050420" ], + "050211" : [ "03:31", "800000", "050420" ], + "050212" : [ "03:32", "800000", "050420" ], + "050213" : [ "03:33", "800000", "050420" ], + "050214" : [ "03:34", "800000", "050420" ], + "050215" : [ "03:35", "800000", "050420" ], + "050216" : [ "03:36", "800000", "050420" ], + "050217" : [ "03:37", "800000", "050420" ], + "050218" : [ "03:38", "800000", "050420" ], + "050219" : [ "03:39", "800000", "050420" ], + "050220" : [ "03:40", "800000", "050420" ], + "050221" : [ "03:41", "800000", "050420" ], + "050222" : [ "03:42", "800000", "050420" ], + "050223" : [ "03:43", "800000", "050420" ], + "050224" : [ "03:44", "800000", "050420" ], + "050225" : [ "03:45", "800000", "050420" ], + "050226" : [ "03:46", "800000", "050420" ], + "050227" : [ "03:47", "800000", "050420" ], + "050228" : [ "03:48", "800000", "050420" ], + "050229" : [ "03:49", "800000", "050420" ], + "050230" : [ "03:50", "800000", "050420" ], + "050231" : [ "03:51", "800000", "050420" ], + "050232" : [ "03:52", "800000", "050420" ], + "050233" : [ "03:53", "800000", "050420" ], + "050234" : [ "03:54", "800000", "050420" ], + "050235" : [ "03:55", "800000", "050420" ], + "050236" : [ "03:56", "800000", "050420" ], + "050237" : [ "03:57", "800000", "050420" ], + "050238" : [ "03:58", "800000", "050420" ], + "050239" : [ "03:59", "800000", "050420" ], + "050240" : [ "04:00", "800000", "050420" ], + "050241" : [ "04:01", "800000", "050420" ], + "050242" : [ "04:02", "800000", "050420" ], + "050243" : [ "04:03", "800000", "050420" ], + "050244" : [ "04:04", "800000", "050420" ], + "050245" : [ "04:05", "800000", "050420" ], + "050246" : [ "04:06", "800000", "050420" ], + "050247" : [ "04:07", "800000", "050420" ], + "050248" : [ "04:08", "800000", "050420" ], + "050249" : [ "04:09", "800000", "050420" ], + "050250" : [ "04:10", "800000", "050420" ], + "050251" : [ "04:11", "800000", "050420" ], + "050252" : [ "04:12", "800000", "050420" ], + "050253" : [ "04:13", "800000", "050420" ], + "050254" : [ "04:14", "800000", "050420" ], + "050255" : [ "04:15", "800000", "050420" ], + "050256" : [ "04:16", "800000", "050420" ], + "050257" : [ "04:17", "800000", "050420" ], + "050258" : [ "04:18", "800000", "050420" ], + "050259" : [ "04:19", "800000", "050420" ], + "050260" : [ "04:20", "800000", "050420" ], + "050261" : [ "04:21", "800000", "050420" ], + "050262" : [ "04:22", "800000", "050420" ], + "050263" : [ "04:23", "800000", "050420" ], + "050264" : [ "04:24", "800000", "050420" ], + "050265" : [ "04:25", "800000", "050420" ], + "050266" : [ "04:26", "800000", "050420" ], + "050267" : [ "04:27", "800000", "050420" ], + "050268" : [ "04:28", "800000", "050420" ], + "050269" : [ "04:29", "800000", "050420" ], + "050270" : [ "04:30", "800000", "050420" ], + "050271" : [ "04:31", "800000", "050420" ], + "050272" : [ "04:32", "800000", "050420" ], + "050273" : [ "04:33", "800000", "050420" ], + "050274" : [ "04:34", "800000", "050420" ], + "050275" : [ "04:35", "800000", "050420" ], + "050276" : [ "04:36", "800000", "050420" ], + "050277" : [ "04:37", "800000", "050420" ], + "050278" : [ "04:38", "800000", "050420" ], + "050279" : [ "04:39", "800000", "050420" ], + "050280" : [ "04:40", "800000", "050420" ], + "050281" : [ "04:41", "800000", "050420" ], + "050282" : [ "04:42", "800000", "050420" ], + "050283" : [ "04:43", "800000", "050420" ], + "050284" : [ "04:44", "800000", "050420" ], + "050285" : [ "04:45", "800000", "050420" ], + "050286" : [ "04:46", "800000", "050420" ], + "050287" : [ "04:47", "800000", "050420" ], + "050288" : [ "04:48", "800000", "050420" ], + "050289" : [ "04:49", "800000", "050420" ], + "050290" : [ "04:50", "800000", "050420" ], + "050291" : [ "04:51", "800000", "050420" ], + "050292" : [ "04:52", "800000", "050420" ], + "050293" : [ "04:53", "800000", "050420" ], + "050294" : [ "04:54", "800000", "050420" ], + "050295" : [ "04:55", "800000", "050420" ], + "050296" : [ "04:56", "800000", "050420" ], + "050297" : [ "04:57", "800000", "050420" ], + "050298" : [ "04:58", "800000", "050420" ], + "050299" : [ "04:59", "800000", "050420" ], + "050300" : [ "05:00", "800000", "050420" ], + "050301" : [ "05:01", "800000", "050420" ], + "050302" : [ "05:02", "800000", "050420" ], + "050303" : [ "05:03", "800000", "050420" ], + "050304" : [ "05:04", "800000", "050420" ], + "050305" : [ "05:05", "800000", "050420" ], + "050306" : [ "05:06", "800000", "050420" ], + "050307" : [ "05:07", "800000", "050420" ], + "050308" : [ "05:08", "800000", "050420" ], + "050309" : [ "05:09", "800000", "050420" ], + "050310" : [ "05:10", "800000", "050420" ], + "050311" : [ "05:11", "800000", "050420" ], + "050312" : [ "05:12", "800000", "050420" ], + "050313" : [ "05:13", "800000", "050420" ], + "050314" : [ "05:14", "800000", "050420" ], + "050315" : [ "05:15", "800000", "050420" ], + "050316" : [ "05:16", "800000", "050420" ], + "050317" : [ "05:17", "800000", "050420" ], + "050318" : [ "05:18", "800000", "050420" ], + "050319" : [ "05:19", "800000", "050420" ], + "050320" : [ "05:20", "800000", "050420" ], + "050321" : [ "05:21", "800000", "050420" ], + "050322" : [ "05:22", "800000", "050420" ], + "050323" : [ "05:23", "800000", "050420" ], + "050324" : [ "05:24", "800000", "050420" ], + "050325" : [ "05:25", "800000", "050420" ], + "050326" : [ "05:26", "800000", "050420" ], + "050327" : [ "05:27", "800000", "050420" ], + "050328" : [ "05:28", "800000", "050420" ], + "050329" : [ "05:29", "800000", "050420" ], + "050330" : [ "05:30", "800000", "050420" ], + "050331" : [ "05:31", "800000", "050420" ], + "050332" : [ "05:32", "800000", "050420" ], + "050333" : [ "05:33", "800000", "050420" ], + "050334" : [ "05:34", "800000", "050420" ], + "050335" : [ "05:35", "800000", "050420" ], + "050336" : [ "05:36", "800000", "050420" ], + "050337" : [ "05:37", "800000", "050420" ], + "050338" : [ "05:38", "800000", "050420" ], + "050339" : [ "05:39", "800000", "050420" ], + "050340" : [ "05:40", "800000", "050420" ], + "050341" : [ "05:41", "800000", "050420" ], + "050342" : [ "05:42", "800000", "050420" ], + "050343" : [ "05:43", "800000", "050420" ], + "050344" : [ "05:44", "800000", "050420" ], + "050345" : [ "05:45", "800000", "050420" ], + "050346" : [ "05:46", "800000", "050420" ], + "050347" : [ "05:47", "800000", "050420" ], + "050348" : [ "05:48", "800000", "050420" ], + "050349" : [ "05:49", "800000", "050420" ], + "050350" : [ "05:50", "800000", "050420" ], + "050351" : [ "05:51", "800000", "050420" ], + "050352" : [ "05:52", "800000", "050420" ], + "050353" : [ "05:53", "800000", "050420" ], + "050354" : [ "05:54", "800000", "050420" ], + "050355" : [ "05:55", "800000", "050420" ], + "050356" : [ "05:56", "800000", "050420" ], + "050357" : [ "05:57", "800000", "050420" ], + "050358" : [ "05:58", "800000", "050420" ], + "050359" : [ "05:59", "800000", "050420" ], + "050360" : [ "06:00", "800000", "050420" ], + "050361" : [ "06:01", "800000", "050420" ], + "050362" : [ "06:02", "800000", "050420" ], + "050363" : [ "06:03", "800000", "050420" ], + "050364" : [ "06:04", "800000", "050420" ], + "050365" : [ "06:05", "800000", "050420" ], + "050366" : [ "06:06", "800000", "050420" ], + "050367" : [ "06:07", "800000", "050420" ], + "050368" : [ "06:08", "800000", "050420" ], + "050369" : [ "06:09", "800000", "050420" ], + "050370" : [ "06:10", "800000", "050420" ], + "050371" : [ "06:11", "800000", "050420" ], + "050372" : [ "06:12", "800000", "050420" ], + "050373" : [ "06:13", "800000", "050420" ], + "050374" : [ "06:14", "800000", "050420" ], + "050375" : [ "06:15", "800000", "050420" ], + "050376" : [ "06:16", "800000", "050420" ], + "050377" : [ "06:17", "800000", "050420" ], + "050378" : [ "06:18", "800000", "050420" ], + "050379" : [ "06:19", "800000", "050420" ], + "050380" : [ "06:20", "800000", "050420" ], + "050381" : [ "06:21", "800000", "050420" ], + "050382" : [ "06:22", "800000", "050420" ], + "050383" : [ "06:23", "800000", "050420" ], + "050384" : [ "06:24", "800000", "050420" ], + "050385" : [ "06:25", "800000", "050420" ], + "050386" : [ "06:26", "800000", "050420" ], + "050387" : [ "06:27", "800000", "050420" ], + "050388" : [ "06:28", "800000", "050420" ], + "050389" : [ "06:29", "800000", "050420" ], + "050390" : [ "06:30", "800000", "050420" ], + "050391" : [ "06:31", "800000", "050420" ], + "050392" : [ "06:32", "800000", "050420" ], + "050393" : [ "06:33", "800000", "050420" ], + "050394" : [ "06:34", "800000", "050420" ], + "050395" : [ "06:35", "800000", "050420" ], + "050396" : [ "06:36", "800000", "050420" ], + "050397" : [ "06:37", "800000", "050420" ], + "050398" : [ "06:38", "800000", "050420" ], + "050399" : [ "06:39", "800000", "050420" ], + "050400" : [ "06:40", "800000", "050420" ], + "050401" : [ "06:41", "800000", "050420" ], + "050402" : [ "06:42", "800000", "050420" ], + "050403" : [ "06:43", "800000", "050420" ], + "050404" : [ "06:44", "800000", "050420" ], + "050405" : [ "06:45", "800000", "050420" ], + "050406" : [ "06:46", "800000", "050420" ], + "050407" : [ "06:47", "800000", "050420" ], + "050408" : [ "06:48", "800000", "050420" ], + "050409" : [ "06:49", "800000", "050420" ], + "050410" : [ "06:50", "800000", "050420" ], + "050411" : [ "06:51", "800000", "050420" ], + "050412" : [ "06:52", "800000", "050420" ], + "050413" : [ "06:53", "800000", "050420" ], + "050414" : [ "06:54", "800000", "050420" ], + "050415" : [ "06:55", "800000", "050420" ], + "050416" : [ "06:56", "800000", "050420" ], + "050417" : [ "06:57", "800000", "050420" ], + "050418" : [ "06:58", "800000", "050420" ], + "050419" : [ "06:59", "800000", "050420" ], + "050420" : [ "07:00", "350000", "050480" ], + "050421" : [ "07:01", "350000", "050481" ], + "050422" : [ "07:02", "350000", "050482" ], + "050423" : [ "07:03", "350000", "050483" ], + "050424" : [ "07:04", "350000", "050484" ], + "050425" : [ "07:05", "350000", "050485" ], + "050426" : [ "07:06", "350000", "050486" ], + "050427" : [ "07:07", "350000", "050487" ], + "050428" : [ "07:08", "350000", "050488" ], + "050429" : [ "07:09", "350000", "050489" ], + "050430" : [ "07:10", "350000", "050490" ], + "050431" : [ "07:11", "350000", "050491" ], + "050432" : [ "07:12", "350000", "050492" ], + "050433" : [ "07:13", "350000", "050493" ], + "050434" : [ "07:14", "350000", "050494" ], + "050435" : [ "07:15", "350000", "050495" ], + "050436" : [ "07:16", "350000", "050496" ], + "050437" : [ "07:17", "350000", "050497" ], + "050438" : [ "07:18", "350000", "050498" ], + "050439" : [ "07:19", "350000", "050499" ], + "050440" : [ "07:20", "350000", "050500" ], + "050441" : [ "07:21", "350000", "050501" ], + "050442" : [ "07:22", "350000", "050502" ], + "050443" : [ "07:23", "350000", "050503" ], + "050444" : [ "07:24", "350000", "050504" ], + "050445" : [ "07:25", "350000", "050505" ], + "050446" : [ "07:26", "350000", "050506" ], + "050447" : [ "07:27", "350000", "050507" ], + "050448" : [ "07:28", "350000", "050508" ], + "050449" : [ "07:29", "350000", "050509" ], + "050450" : [ "07:30", "350000", "050510" ], + "050451" : [ "07:31", "350000", "050511" ], + "050452" : [ "07:32", "350000", "050512" ], + "050453" : [ "07:33", "350000", "050513" ], + "050454" : [ "07:34", "350000", "050514" ], + "050455" : [ "07:35", "350000", "050515" ], + "050456" : [ "07:36", "350000", "050516" ], + "050457" : [ "07:37", "350000", "050517" ], + "050458" : [ "07:38", "350000", "050518" ], + "050459" : [ "07:39", "350000", "050519" ], + "050460" : [ "07:40", "350000", "050520" ], + "050461" : [ "07:41", "350000", "050521" ], + "050462" : [ "07:42", "350000", "050522" ], + "050463" : [ "07:43", "350000", "050523" ], + "050464" : [ "07:44", "350000", "050524" ], + "050465" : [ "07:45", "350000", "050525" ], + "050466" : [ "07:46", "350000", "050526" ], + "050467" : [ "07:47", "350000", "050527" ], + "050468" : [ "07:48", "350000", "050528" ], + "050469" : [ "07:49", "350000", "050529" ], + "050470" : [ "07:50", "350000", "050530" ], + "050471" : [ "07:51", "350000", "050531" ], + "050472" : [ "07:52", "350000", "050532" ], + "050473" : [ "07:53", "350000", "050533" ], + "050474" : [ "07:54", "350000", "050534" ], + "050475" : [ "07:55", "350000", "050535" ], + "050476" : [ "07:56", "350000", "050536" ], + "050477" : [ "07:57", "350000", "050537" ], + "050478" : [ "07:58", "350000", "050538" ], + "050479" : [ "07:59", "350000", "050539" ], + "050480" : [ "08:00", "350000", "050540" ], + "050481" : [ "08:01", "350000", "050541" ], + "050482" : [ "08:02", "350000", "050542" ], + "050483" : [ "08:03", "350000", "050543" ], + "050484" : [ "08:04", "350000", "050544" ], + "050485" : [ "08:05", "350000", "050545" ], + "050486" : [ "08:06", "350000", "050546" ], + "050487" : [ "08:07", "350000", "050547" ], + "050488" : [ "08:08", "350000", "050548" ], + "050489" : [ "08:09", "350000", "050549" ], + "050490" : [ "08:10", "350000", "050550" ], + "050491" : [ "08:11", "350000", "050551" ], + "050492" : [ "08:12", "350000", "050552" ], + "050493" : [ "08:13", "350000", "050553" ], + "050494" : [ "08:14", "350000", "050554" ], + "050495" : [ "08:15", "350000", "050555" ], + "050496" : [ "08:16", "350000", "050556" ], + "050497" : [ "08:17", "350000", "050557" ], + "050498" : [ "08:18", "350000", "050558" ], + "050499" : [ "08:19", "350000", "050559" ], + "050500" : [ "08:20", "350000", "050560" ], + "050501" : [ "08:21", "350000", "050561" ], + "050502" : [ "08:22", "350000", "050562" ], + "050503" : [ "08:23", "350000", "050563" ], + "050504" : [ "08:24", "350000", "050564" ], + "050505" : [ "08:25", "350000", "050565" ], + "050506" : [ "08:26", "350000", "050566" ], + "050507" : [ "08:27", "350000", "050567" ], + "050508" : [ "08:28", "350000", "050568" ], + "050509" : [ "08:29", "350000", "050569" ], + "050510" : [ "08:30", "350000", "050570" ], + "050511" : [ "08:31", "350000", "050571" ], + "050512" : [ "08:32", "350000", "050572" ], + "050513" : [ "08:33", "350000", "050573" ], + "050514" : [ "08:34", "350000", "050574" ], + "050515" : [ "08:35", "350000", "050575" ], + "050516" : [ "08:36", "350000", "050576" ], + "050517" : [ "08:37", "350000", "050577" ], + "050518" : [ "08:38", "350000", "050578" ], + "050519" : [ "08:39", "350000", "050579" ], + "050520" : [ "08:40", "350000", "050580" ], + "050521" : [ "08:41", "350000", "050581" ], + "050522" : [ "08:42", "350000", "050582" ], + "050523" : [ "08:43", "350000", "050583" ], + "050524" : [ "08:44", "350000", "050584" ], + "050525" : [ "08:45", "350000", "050585" ], + "050526" : [ "08:46", "350000", "050586" ], + "050527" : [ "08:47", "350000", "050587" ], + "050528" : [ "08:48", "350000", "050588" ], + "050529" : [ "08:49", "350000", "050589" ], + "050530" : [ "08:50", "350000", "050590" ], + "050531" : [ "08:51", "350000", "050591" ], + "050532" : [ "08:52", "350000", "050592" ], + "050533" : [ "08:53", "350000", "050593" ], + "050534" : [ "08:54", "350000", "050594" ], + "050535" : [ "08:55", "350000", "050595" ], + "050536" : [ "08:56", "350000", "050596" ], + "050537" : [ "08:57", "350000", "050597" ], + "050538" : [ "08:58", "350000", "050598" ], + "050539" : [ "08:59", "350000", "050599" ], + "050540" : [ "09:00", "350000", "050600" ], + "050541" : [ "09:01", "350000", "050601" ], + "050542" : [ "09:02", "350000", "050602" ], + "050543" : [ "09:03", "350000", "050603" ], + "050544" : [ "09:04", "350000", "050604" ], + "050545" : [ "09:05", "350000", "050605" ], + "050546" : [ "09:06", "350000", "050606" ], + "050547" : [ "09:07", "350000", "050607" ], + "050548" : [ "09:08", "350000", "050608" ], + "050549" : [ "09:09", "350000", "050609" ], + "050550" : [ "09:10", "350000", "050610" ], + "050551" : [ "09:11", "350000", "050611" ], + "050552" : [ "09:12", "350000", "050612" ], + "050553" : [ "09:13", "350000", "050613" ], + "050554" : [ "09:14", "350000", "050614" ], + "050555" : [ "09:15", "350000", "050615" ], + "050556" : [ "09:16", "350000", "050616" ], + "050557" : [ "09:17", "350000", "050617" ], + "050558" : [ "09:18", "350000", "050618" ], + "050559" : [ "09:19", "350000", "050619" ], + "050560" : [ "09:20", "350000", "050620" ], + "050561" : [ "09:21", "350000", "050621" ], + "050562" : [ "09:22", "350000", "050622" ], + "050563" : [ "09:23", "350000", "050623" ], + "050564" : [ "09:24", "350000", "050624" ], + "050565" : [ "09:25", "350000", "050625" ], + "050566" : [ "09:26", "350000", "050626" ], + "050567" : [ "09:27", "350000", "050627" ], + "050568" : [ "09:28", "350000", "050628" ], + "050569" : [ "09:29", "350000", "050629" ], + "050570" : [ "09:30", "350000", "050630" ], + "050571" : [ "09:31", "350000", "050631" ], + "050572" : [ "09:32", "350000", "050632" ], + "050573" : [ "09:33", "350000", "050633" ], + "050574" : [ "09:34", "350000", "050634" ], + "050575" : [ "09:35", "350000", "050635" ], + "050576" : [ "09:36", "350000", "050636" ], + "050577" : [ "09:37", "350000", "050637" ], + "050578" : [ "09:38", "350000", "050638" ], + "050579" : [ "09:39", "350000", "050639" ], + "050580" : [ "09:40", "350000", "050640" ], + "050581" : [ "09:41", "350000", "050641" ], + "050582" : [ "09:42", "350000", "050642" ], + "050583" : [ "09:43", "350000", "050643" ], + "050584" : [ "09:44", "350000", "050644" ], + "050585" : [ "09:45", "350000", "050645" ], + "050586" : [ "09:46", "350000", "050646" ], + "050587" : [ "09:47", "350000", "050647" ], + "050588" : [ "09:48", "350000", "050648" ], + "050589" : [ "09:49", "350000", "050649" ], + "050590" : [ "09:50", "350000", "050650" ], + "050591" : [ "09:51", "350000", "050651" ], + "050592" : [ "09:52", "350000", "050652" ], + "050593" : [ "09:53", "350000", "050653" ], + "050594" : [ "09:54", "350000", "050654" ], + "050595" : [ "09:55", "350000", "050655" ], + "050596" : [ "09:56", "350000", "050656" ], + "050597" : [ "09:57", "350000", "050657" ], + "050598" : [ "09:58", "350000", "050658" ], + "050599" : [ "09:59", "350000", "050659" ], + "050600" : [ "10:00", "350000", "050660" ], + "050601" : [ "10:01", "350000", "050661" ], + "050602" : [ "10:02", "350000", "050662" ], + "050603" : [ "10:03", "350000", "050663" ], + "050604" : [ "10:04", "350000", "050664" ], + "050605" : [ "10:05", "350000", "050665" ], + "050606" : [ "10:06", "350000", "050666" ], + "050607" : [ "10:07", "350000", "050667" ], + "050608" : [ "10:08", "350000", "050668" ], + "050609" : [ "10:09", "350000", "050669" ], + "050610" : [ "10:10", "350000", "050670" ], + "050611" : [ "10:11", "350000", "050671" ], + "050612" : [ "10:12", "350000", "050672" ], + "050613" : [ "10:13", "350000", "050673" ], + "050614" : [ "10:14", "350000", "050674" ], + "050615" : [ "10:15", "350000", "050675" ], + "050616" : [ "10:16", "350000", "050676" ], + "050617" : [ "10:17", "350000", "050677" ], + "050618" : [ "10:18", "350000", "050678" ], + "050619" : [ "10:19", "350000", "050679" ], + "050620" : [ "10:20", "350000", "050680" ], + "050621" : [ "10:21", "350000", "050681" ], + "050622" : [ "10:22", "350000", "050682" ], + "050623" : [ "10:23", "350000", "050683" ], + "050624" : [ "10:24", "350000", "050684" ], + "050625" : [ "10:25", "350000", "050685" ], + "050626" : [ "10:26", "350000", "050686" ], + "050627" : [ "10:27", "350000", "050687" ], + "050628" : [ "10:28", "350000", "050688" ], + "050629" : [ "10:29", "350000", "050689" ], + "050630" : [ "10:30", "350000", "050690" ], + "050631" : [ "10:31", "350000", "050691" ], + "050632" : [ "10:32", "350000", "050692" ], + "050633" : [ "10:33", "350000", "050693" ], + "050634" : [ "10:34", "350000", "050694" ], + "050635" : [ "10:35", "350000", "050695" ], + "050636" : [ "10:36", "350000", "050696" ], + "050637" : [ "10:37", "350000", "050697" ], + "050638" : [ "10:38", "350000", "050698" ], + "050639" : [ "10:39", "350000", "050699" ], + "050640" : [ "10:40", "350000", "050700" ], + "050641" : [ "10:41", "350000", "050701" ], + "050642" : [ "10:42", "350000", "050702" ], + "050643" : [ "10:43", "350000", "050703" ], + "050644" : [ "10:44", "350000", "050704" ], + "050645" : [ "10:45", "350000", "050705" ], + "050646" : [ "10:46", "350000", "050706" ], + "050647" : [ "10:47", "350000", "050707" ], + "050648" : [ "10:48", "350000", "050708" ], + "050649" : [ "10:49", "350000", "050709" ], + "050650" : [ "10:50", "350000", "050710" ], + "050651" : [ "10:51", "350000", "050711" ], + "050652" : [ "10:52", "350000", "050712" ], + "050653" : [ "10:53", "350000", "050713" ], + "050654" : [ "10:54", "350000", "050714" ], + "050655" : [ "10:55", "350000", "050715" ], + "050656" : [ "10:56", "350000", "050716" ], + "050657" : [ "10:57", "350000", "050717" ], + "050658" : [ "10:58", "350000", "050718" ], + "050659" : [ "10:59", "350000", "050719" ], + "050660" : [ "11:00", "350000", "050720" ], + "050661" : [ "11:01", "350000", "050721" ], + "050662" : [ "11:02", "350000", "050722" ], + "050663" : [ "11:03", "350000", "050723" ], + "050664" : [ "11:04", "350000", "050724" ], + "050665" : [ "11:05", "350000", "050725" ], + "050666" : [ "11:06", "350000", "050726" ], + "050667" : [ "11:07", "350000", "050727" ], + "050668" : [ "11:08", "350000", "050728" ], + "050669" : [ "11:09", "350000", "050729" ], + "050670" : [ "11:10", "350000", "050730" ], + "050671" : [ "11:11", "350000", "050731" ], + "050672" : [ "11:12", "350000", "050732" ], + "050673" : [ "11:13", "350000", "050733" ], + "050674" : [ "11:14", "350000", "050734" ], + "050675" : [ "11:15", "350000", "050735" ], + "050676" : [ "11:16", "350000", "050736" ], + "050677" : [ "11:17", "350000", "050737" ], + "050678" : [ "11:18", "350000", "050738" ], + "050679" : [ "11:19", "350000", "050739" ], + "050680" : [ "11:20", "350000", "050740" ], + "050681" : [ "11:21", "350000", "050741" ], + "050682" : [ "11:22", "350000", "050742" ], + "050683" : [ "11:23", "350000", "050743" ], + "050684" : [ "11:24", "350000", "050744" ], + "050685" : [ "11:25", "350000", "050745" ], + "050686" : [ "11:26", "350000", "050746" ], + "050687" : [ "11:27", "350000", "050747" ], + "050688" : [ "11:28", "350000", "050748" ], + "050689" : [ "11:29", "350000", "050749" ], + "050690" : [ "11:30", "350000", "050750" ], + "050691" : [ "11:31", "350000", "050751" ], + "050692" : [ "11:32", "350000", "050752" ], + "050693" : [ "11:33", "350000", "050753" ], + "050694" : [ "11:34", "350000", "050754" ], + "050695" : [ "11:35", "350000", "050755" ], + "050696" : [ "11:36", "350000", "050756" ], + "050697" : [ "11:37", "350000", "050757" ], + "050698" : [ "11:38", "350000", "050758" ], + "050699" : [ "11:39", "350000", "050759" ], + "050700" : [ "11:40", "350000", "050760" ], + "050701" : [ "11:41", "350000", "050761" ], + "050702" : [ "11:42", "350000", "050762" ], + "050703" : [ "11:43", "350000", "050763" ], + "050704" : [ "11:44", "350000", "050764" ], + "050705" : [ "11:45", "350000", "050765" ], + "050706" : [ "11:46", "350000", "050766" ], + "050707" : [ "11:47", "350000", "050767" ], + "050708" : [ "11:48", "350000", "050768" ], + "050709" : [ "11:49", "350000", "050769" ], + "050710" : [ "11:50", "350000", "050770" ], + "050711" : [ "11:51", "350000", "050771" ], + "050712" : [ "11:52", "350000", "050772" ], + "050713" : [ "11:53", "350000", "050773" ], + "050714" : [ "11:54", "350000", "050774" ], + "050715" : [ "11:55", "350000", "050775" ], + "050716" : [ "11:56", "350000", "050776" ], + "050717" : [ "11:57", "350000", "050777" ], + "050718" : [ "11:58", "350000", "050778" ], + "050719" : [ "11:59", "350000", "050779" ], + "050720" : [ "12:00", "350000", "050780" ], + "050721" : [ "12:01", "350000", "050781" ], + "050722" : [ "12:02", "350000", "050782" ], + "050723" : [ "12:03", "350000", "050783" ], + "050724" : [ "12:04", "350000", "050784" ], + "050725" : [ "12:05", "350000", "050785" ], + "050726" : [ "12:06", "350000", "050786" ], + "050727" : [ "12:07", "350000", "050787" ], + "050728" : [ "12:08", "350000", "050788" ], + "050729" : [ "12:09", "350000", "050789" ], + "050730" : [ "12:10", "350000", "050790" ], + "050731" : [ "12:11", "350000", "050791" ], + "050732" : [ "12:12", "350000", "050792" ], + "050733" : [ "12:13", "350000", "050793" ], + "050734" : [ "12:14", "350000", "050794" ], + "050735" : [ "12:15", "350000", "050795" ], + "050736" : [ "12:16", "350000", "050796" ], + "050737" : [ "12:17", "350000", "050797" ], + "050738" : [ "12:18", "350000", "050798" ], + "050739" : [ "12:19", "350000", "050799" ], + "050740" : [ "12:20", "350000", "050800" ], + "050741" : [ "12:21", "350000", "050801" ], + "050742" : [ "12:22", "350000", "050802" ], + "050743" : [ "12:23", "350000", "050803" ], + "050744" : [ "12:24", "350000", "050804" ], + "050745" : [ "12:25", "350000", "050805" ], + "050746" : [ "12:26", "350000", "050806" ], + "050747" : [ "12:27", "350000", "050807" ], + "050748" : [ "12:28", "350000", "050808" ], + "050749" : [ "12:29", "350000", "050809" ], + "050750" : [ "12:30", "350000", "050810" ], + "050751" : [ "12:31", "350000", "050811" ], + "050752" : [ "12:32", "350000", "050812" ], + "050753" : [ "12:33", "350000", "050813" ], + "050754" : [ "12:34", "350000", "050814" ], + "050755" : [ "12:35", "350000", "050815" ], + "050756" : [ "12:36", "350000", "050816" ], + "050757" : [ "12:37", "350000", "050817" ], + "050758" : [ "12:38", "350000", "050818" ], + "050759" : [ "12:39", "350000", "050819" ], + "050760" : [ "12:40", "350000", "050820" ], + "050761" : [ "12:41", "350000", "050821" ], + "050762" : [ "12:42", "350000", "050822" ], + "050763" : [ "12:43", "350000", "050823" ], + "050764" : [ "12:44", "350000", "050824" ], + "050765" : [ "12:45", "350000", "050825" ], + "050766" : [ "12:46", "350000", "050826" ], + "050767" : [ "12:47", "350000", "050827" ], + "050768" : [ "12:48", "350000", "050828" ], + "050769" : [ "12:49", "350000", "050829" ], + "050770" : [ "12:50", "350000", "050830" ], + "050771" : [ "12:51", "350000", "050831" ], + "050772" : [ "12:52", "350000", "050832" ], + "050773" : [ "12:53", "350000", "050833" ], + "050774" : [ "12:54", "350000", "050834" ], + "050775" : [ "12:55", "350000", "050835" ], + "050776" : [ "12:56", "350000", "050836" ], + "050777" : [ "12:57", "350000", "050837" ], + "050778" : [ "12:58", "350000", "050838" ], + "050779" : [ "12:59", "350000", "050839" ], + "050780" : [ "13:00", "350000", "050840" ], + "050781" : [ "13:01", "350000", "050841" ], + "050782" : [ "13:02", "350000", "050842" ], + "050783" : [ "13:03", "350000", "050843" ], + "050784" : [ "13:04", "350000", "050844" ], + "050785" : [ "13:05", "350000", "050845" ], + "050786" : [ "13:06", "350000", "050846" ], + "050787" : [ "13:07", "350000", "050847" ], + "050788" : [ "13:08", "350000", "050848" ], + "050789" : [ "13:09", "350000", "050849" ], + "050790" : [ "13:10", "350000", "050850" ], + "050791" : [ "13:11", "350000", "050851" ], + "050792" : [ "13:12", "350000", "050852" ], + "050793" : [ "13:13", "350000", "050853" ], + "050794" : [ "13:14", "350000", "050854" ], + "050795" : [ "13:15", "350000", "050855" ], + "050796" : [ "13:16", "350000", "050856" ], + "050797" : [ "13:17", "350000", "050857" ], + "050798" : [ "13:18", "350000", "050858" ], + "050799" : [ "13:19", "350000", "050859" ], + "050800" : [ "13:20", "350000", "050860" ], + "050801" : [ "13:21", "350000", "050861" ], + "050802" : [ "13:22", "350000", "050862" ], + "050803" : [ "13:23", "350000", "050863" ], + "050804" : [ "13:24", "350000", "050864" ], + "050805" : [ "13:25", "350000", "050865" ], + "050806" : [ "13:26", "350000", "050866" ], + "050807" : [ "13:27", "350000", "050867" ], + "050808" : [ "13:28", "350000", "050868" ], + "050809" : [ "13:29", "350000", "050869" ], + "050810" : [ "13:30", "350000", "050870" ], + "050811" : [ "13:31", "350000", "050871" ], + "050812" : [ "13:32", "350000", "050872" ], + "050813" : [ "13:33", "350000", "050873" ], + "050814" : [ "13:34", "350000", "050874" ], + "050815" : [ "13:35", "350000", "050875" ], + "050816" : [ "13:36", "350000", "050876" ], + "050817" : [ "13:37", "350000", "050877" ], + "050818" : [ "13:38", "350000", "050878" ], + "050819" : [ "13:39", "350000", "050879" ], + "050820" : [ "13:40", "350000", "050880" ], + "050821" : [ "13:41", "350000", "050881" ], + "050822" : [ "13:42", "350000", "050882" ], + "050823" : [ "13:43", "350000", "050883" ], + "050824" : [ "13:44", "350000", "050884" ], + "050825" : [ "13:45", "350000", "050885" ], + "050826" : [ "13:46", "350000", "050886" ], + "050827" : [ "13:47", "350000", "050887" ], + "050828" : [ "13:48", "350000", "050888" ], + "050829" : [ "13:49", "350000", "050889" ], + "050830" : [ "13:50", "350000", "050890" ], + "050831" : [ "13:51", "350000", "050891" ], + "050832" : [ "13:52", "350000", "050892" ], + "050833" : [ "13:53", "350000", "050893" ], + "050834" : [ "13:54", "350000", "050894" ], + "050835" : [ "13:55", "350000", "050895" ], + "050836" : [ "13:56", "350000", "050896" ], + "050837" : [ "13:57", "350000", "050897" ], + "050838" : [ "13:58", "350000", "050898" ], + "050839" : [ "13:59", "350000", "050899" ], + "050840" : [ "14:00", "350000", "050900" ], + "050841" : [ "14:01", "350000", "050901" ], + "050842" : [ "14:02", "350000", "050902" ], + "050843" : [ "14:03", "350000", "050903" ], + "050844" : [ "14:04", "350000", "050904" ], + "050845" : [ "14:05", "350000", "050905" ], + "050846" : [ "14:06", "350000", "050906" ], + "050847" : [ "14:07", "350000", "050907" ], + "050848" : [ "14:08", "350000", "050908" ], + "050849" : [ "14:09", "350000", "050909" ], + "050850" : [ "14:10", "350000", "050910" ], + "050851" : [ "14:11", "350000", "050911" ], + "050852" : [ "14:12", "350000", "050912" ], + "050853" : [ "14:13", "350000", "050913" ], + "050854" : [ "14:14", "350000", "050914" ], + "050855" : [ "14:15", "350000", "050915" ], + "050856" : [ "14:16", "350000", "050916" ], + "050857" : [ "14:17", "350000", "050917" ], + "050858" : [ "14:18", "350000", "050918" ], + "050859" : [ "14:19", "350000", "050919" ], + "050860" : [ "14:20", "350000", "050920" ], + "050861" : [ "14:21", "350000", "050921" ], + "050862" : [ "14:22", "350000", "050922" ], + "050863" : [ "14:23", "350000", "050923" ], + "050864" : [ "14:24", "350000", "050924" ], + "050865" : [ "14:25", "350000", "050925" ], + "050866" : [ "14:26", "350000", "050926" ], + "050867" : [ "14:27", "350000", "050927" ], + "050868" : [ "14:28", "350000", "050928" ], + "050869" : [ "14:29", "350000", "050929" ], + "050870" : [ "14:30", "350000", "050930" ], + "050871" : [ "14:31", "350000", "050931" ], + "050872" : [ "14:32", "350000", "050932" ], + "050873" : [ "14:33", "350000", "050933" ], + "050874" : [ "14:34", "350000", "050934" ], + "050875" : [ "14:35", "350000", "050935" ], + "050876" : [ "14:36", "350000", "050936" ], + "050877" : [ "14:37", "350000", "050937" ], + "050878" : [ "14:38", "350000", "050938" ], + "050879" : [ "14:39", "350000", "050939" ], + "050880" : [ "14:40", "350000", "050940" ], + "050881" : [ "14:41", "350000", "050941" ], + "050882" : [ "14:42", "350000", "050942" ], + "050883" : [ "14:43", "350000", "050943" ], + "050884" : [ "14:44", "350000", "050944" ], + "050885" : [ "14:45", "350000", "050945" ], + "050886" : [ "14:46", "350000", "050946" ], + "050887" : [ "14:47", "350000", "050947" ], + "050888" : [ "14:48", "350000", "050948" ], + "050889" : [ "14:49", "350000", "050949" ], + "050890" : [ "14:50", "350000", "050950" ], + "050891" : [ "14:51", "350000", "050951" ], + "050892" : [ "14:52", "350000", "050952" ], + "050893" : [ "14:53", "350000", "050953" ], + "050894" : [ "14:54", "350000", "050954" ], + "050895" : [ "14:55", "350000", "050955" ], + "050896" : [ "14:56", "350000", "050956" ], + "050897" : [ "14:57", "350000", "050957" ], + "050898" : [ "14:58", "350000", "050958" ], + "050899" : [ "14:59", "350000", "050959" ], + "050900" : [ "15:00", "350000", "050960" ], + "050901" : [ "15:01", "350000", "050961" ], + "050902" : [ "15:02", "350000", "050962" ], + "050903" : [ "15:03", "350000", "050963" ], + "050904" : [ "15:04", "350000", "050964" ], + "050905" : [ "15:05", "350000", "050965" ], + "050906" : [ "15:06", "350000", "050966" ], + "050907" : [ "15:07", "350000", "050967" ], + "050908" : [ "15:08", "350000", "050968" ], + "050909" : [ "15:09", "350000", "050969" ], + "050910" : [ "15:10", "350000", "050970" ], + "050911" : [ "15:11", "350000", "050971" ], + "050912" : [ "15:12", "350000", "050972" ], + "050913" : [ "15:13", "350000", "050973" ], + "050914" : [ "15:14", "350000", "050974" ], + "050915" : [ "15:15", "350000", "050975" ], + "050916" : [ "15:16", "350000", "050976" ], + "050917" : [ "15:17", "350000", "050977" ], + "050918" : [ "15:18", "350000", "050978" ], + "050919" : [ "15:19", "350000", "050979" ], + "050920" : [ "15:20", "350000", "050980" ], + "050921" : [ "15:21", "350000", "050981" ], + "050922" : [ "15:22", "350000", "050982" ], + "050923" : [ "15:23", "350000", "050983" ], + "050924" : [ "15:24", "350000", "050984" ], + "050925" : [ "15:25", "350000", "050985" ], + "050926" : [ "15:26", "350000", "050986" ], + "050927" : [ "15:27", "350000", "050987" ], + "050928" : [ "15:28", "350000", "050988" ], + "050929" : [ "15:29", "350000", "050989" ], + "050930" : [ "15:30", "350000", "050990" ], + "050931" : [ "15:31", "350000", "050991" ], + "050932" : [ "15:32", "350000", "050992" ], + "050933" : [ "15:33", "350000", "050993" ], + "050934" : [ "15:34", "350000", "050994" ], + "050935" : [ "15:35", "350000", "050995" ], + "050936" : [ "15:36", "350000", "050996" ], + "050937" : [ "15:37", "350000", "050997" ], + "050938" : [ "15:38", "350000", "050998" ], + "050939" : [ "15:39", "350000", "050999" ], + "050940" : [ "15:40", "350000", "051000" ], + "050941" : [ "15:41", "350000", "051001" ], + "050942" : [ "15:42", "350000", "051002" ], + "050943" : [ "15:43", "350000", "051003" ], + "050944" : [ "15:44", "350000", "051004" ], + "050945" : [ "15:45", "350000", "051005" ], + "050946" : [ "15:46", "350000", "051006" ], + "050947" : [ "15:47", "350000", "051007" ], + "050948" : [ "15:48", "350000", "051008" ], + "050949" : [ "15:49", "350000", "051009" ], + "050950" : [ "15:50", "350000", "051010" ], + "050951" : [ "15:51", "350000", "051011" ], + "050952" : [ "15:52", "350000", "051012" ], + "050953" : [ "15:53", "350000", "051013" ], + "050954" : [ "15:54", "350000", "051014" ], + "050955" : [ "15:55", "350000", "051015" ], + "050956" : [ "15:56", "350000", "051016" ], + "050957" : [ "15:57", "350000", "051017" ], + "050958" : [ "15:58", "350000", "051018" ], + "050959" : [ "15:59", "350000", "051019" ], + "050960" : [ "16:00", "350000", "051020" ], + "050961" : [ "16:01", "350000", "051021" ], + "050962" : [ "16:02", "350000", "051022" ], + "050963" : [ "16:03", "350000", "051023" ], + "050964" : [ "16:04", "350000", "051024" ], + "050965" : [ "16:05", "350000", "051025" ], + "050966" : [ "16:06", "350000", "051026" ], + "050967" : [ "16:07", "350000", "051027" ], + "050968" : [ "16:08", "350000", "051028" ], + "050969" : [ "16:09", "350000", "051029" ], + "050970" : [ "16:10", "350000", "051030" ], + "050971" : [ "16:11", "350000", "051031" ], + "050972" : [ "16:12", "350000", "051032" ], + "050973" : [ "16:13", "350000", "051033" ], + "050974" : [ "16:14", "350000", "051034" ], + "050975" : [ "16:15", "350000", "051035" ], + "050976" : [ "16:16", "350000", "051036" ], + "050977" : [ "16:17", "350000", "051037" ], + "050978" : [ "16:18", "350000", "051038" ], + "050979" : [ "16:19", "350000", "051039" ], + "050980" : [ "16:20", "350000", "051040" ], + "050981" : [ "16:21", "350000", "051041" ], + "050982" : [ "16:22", "350000", "051042" ], + "050983" : [ "16:23", "350000", "051043" ], + "050984" : [ "16:24", "350000", "051044" ], + "050985" : [ "16:25", "350000", "051045" ], + "050986" : [ "16:26", "350000", "051046" ], + "050987" : [ "16:27", "350000", "051047" ], + "050988" : [ "16:28", "350000", "051048" ], + "050989" : [ "16:29", "350000", "051049" ], + "050990" : [ "16:30", "350000", "051050" ], + "050991" : [ "16:31", "350000", "051051" ], + "050992" : [ "16:32", "350000", "051052" ], + "050993" : [ "16:33", "350000", "051053" ], + "050994" : [ "16:34", "350000", "051054" ], + "050995" : [ "16:35", "350000", "051055" ], + "050996" : [ "16:36", "350000", "051056" ], + "050997" : [ "16:37", "350000", "051057" ], + "050998" : [ "16:38", "350000", "051058" ], + "050999" : [ "16:39", "350000", "051059" ], + "051000" : [ "16:40", "350000", "051060" ], + "051001" : [ "16:41", "350000", "051061" ], + "051002" : [ "16:42", "350000", "051062" ], + "051003" : [ "16:43", "350000", "051063" ], + "051004" : [ "16:44", "350000", "051064" ], + "051005" : [ "16:45", "350000", "051065" ], + "051006" : [ "16:46", "350000", "051066" ], + "051007" : [ "16:47", "350000", "051067" ], + "051008" : [ "16:48", "350000", "051068" ], + "051009" : [ "16:49", "350000", "051069" ], + "051010" : [ "16:50", "350000", "051070" ], + "051011" : [ "16:51", "350000", "051071" ], + "051012" : [ "16:52", "350000", "051072" ], + "051013" : [ "16:53", "350000", "051073" ], + "051014" : [ "16:54", "350000", "051074" ], + "051015" : [ "16:55", "350000", "051075" ], + "051016" : [ "16:56", "350000", "051076" ], + "051017" : [ "16:57", "350000", "051077" ], + "051018" : [ "16:58", "350000", "051078" ], + "051019" : [ "16:59", "350000", "051079" ], + "051020" : [ "17:00", "350000", "051080" ], + "051021" : [ "17:01", "350000", "051081" ], + "051022" : [ "17:02", "350000", "051082" ], + "051023" : [ "17:03", "350000", "051083" ], + "051024" : [ "17:04", "350000", "051084" ], + "051025" : [ "17:05", "350000", "051085" ], + "051026" : [ "17:06", "350000", "051086" ], + "051027" : [ "17:07", "350000", "051087" ], + "051028" : [ "17:08", "350000", "051088" ], + "051029" : [ "17:09", "350000", "051089" ], + "051030" : [ "17:10", "350000", "051090" ], + "051031" : [ "17:11", "350000", "051091" ], + "051032" : [ "17:12", "350000", "051092" ], + "051033" : [ "17:13", "350000", "051093" ], + "051034" : [ "17:14", "350000", "051094" ], + "051035" : [ "17:15", "350000", "051095" ], + "051036" : [ "17:16", "350000", "051096" ], + "051037" : [ "17:17", "350000", "051097" ], + "051038" : [ "17:18", "350000", "051098" ], + "051039" : [ "17:19", "350000", "051099" ], + "051040" : [ "17:20", "350000", "051100" ], + "051041" : [ "17:21", "350000", "051101" ], + "051042" : [ "17:22", "350000", "051102" ], + "051043" : [ "17:23", "350000", "051103" ], + "051044" : [ "17:24", "350000", "051104" ], + "051045" : [ "17:25", "350000", "051105" ], + "051046" : [ "17:26", "350000", "051106" ], + "051047" : [ "17:27", "350000", "051107" ], + "051048" : [ "17:28", "350000", "051108" ], + "051049" : [ "17:29", "350000", "051109" ], + "051050" : [ "17:30", "350000", "051110" ], + "051051" : [ "17:31", "350000", "051111" ], + "051052" : [ "17:32", "350000", "051112" ], + "051053" : [ "17:33", "350000", "051113" ], + "051054" : [ "17:34", "350000", "051114" ], + "051055" : [ "17:35", "350000", "051115" ], + "051056" : [ "17:36", "350000", "051116" ], + "051057" : [ "17:37", "350000", "051117" ], + "051058" : [ "17:38", "350000", "051118" ], + "051059" : [ "17:39", "350000", "051119" ], + "051060" : [ "17:40", "350000", "051120" ], + "051061" : [ "17:41", "350000", "051121" ], + "051062" : [ "17:42", "350000", "051122" ], + "051063" : [ "17:43", "350000", "051123" ], + "051064" : [ "17:44", "350000", "051124" ], + "051065" : [ "17:45", "350000", "051125" ], + "051066" : [ "17:46", "350000", "051126" ], + "051067" : [ "17:47", "350000", "051127" ], + "051068" : [ "17:48", "350000", "051128" ], + "051069" : [ "17:49", "350000", "051129" ], + "051070" : [ "17:50", "350000", "051130" ], + "051071" : [ "17:51", "350000", "051131" ], + "051072" : [ "17:52", "350000", "051132" ], + "051073" : [ "17:53", "350000", "051133" ], + "051074" : [ "17:54", "350000", "051134" ], + "051075" : [ "17:55", "350000", "051135" ], + "051076" : [ "17:56", "350000", "051136" ], + "051077" : [ "17:57", "350000", "051137" ], + "051078" : [ "17:58", "350000", "051138" ], + "051079" : [ "17:59", "350000", "051139" ], + "051080" : [ "18:00", "350000", "051140" ], + "051081" : [ "18:01", "350000", "051141" ], + "051082" : [ "18:02", "350000", "051142" ], + "051083" : [ "18:03", "350000", "051143" ], + "051084" : [ "18:04", "350000", "051144" ], + "051085" : [ "18:05", "350000", "051145" ], + "051086" : [ "18:06", "350000", "051146" ], + "051087" : [ "18:07", "350000", "051147" ], + "051088" : [ "18:08", "350000", "051148" ], + "051089" : [ "18:09", "350000", "051149" ], + "051090" : [ "18:10", "350000", "051150" ], + "051091" : [ "18:11", "350000", "051151" ], + "051092" : [ "18:12", "350000", "051152" ], + "051093" : [ "18:13", "350000", "051153" ], + "051094" : [ "18:14", "350000", "051154" ], + "051095" : [ "18:15", "350000", "051155" ], + "051096" : [ "18:16", "350000", "051156" ], + "051097" : [ "18:17", "350000", "051157" ], + "051098" : [ "18:18", "350000", "051158" ], + "051099" : [ "18:19", "350000", "051159" ], + "051100" : [ "18:20", "350000", "051160" ], + "051101" : [ "18:21", "350000", "051161" ], + "051102" : [ "18:22", "350000", "051162" ], + "051103" : [ "18:23", "350000", "051163" ], + "051104" : [ "18:24", "350000", "051164" ], + "051105" : [ "18:25", "350000", "051165" ], + "051106" : [ "18:26", "350000", "051166" ], + "051107" : [ "18:27", "350000", "051167" ], + "051108" : [ "18:28", "350000", "051168" ], + "051109" : [ "18:29", "350000", "051169" ], + "051110" : [ "18:30", "350000", "051170" ], + "051111" : [ "18:31", "350000", "051171" ], + "051112" : [ "18:32", "350000", "051172" ], + "051113" : [ "18:33", "350000", "051173" ], + "051114" : [ "18:34", "350000", "051174" ], + "051115" : [ "18:35", "350000", "051175" ], + "051116" : [ "18:36", "350000", "051176" ], + "051117" : [ "18:37", "350000", "051177" ], + "051118" : [ "18:38", "350000", "051178" ], + "051119" : [ "18:39", "350000", "051179" ], + "051120" : [ "18:40", "350000", "051180" ], + "051121" : [ "18:41", "350000", "051181" ], + "051122" : [ "18:42", "350000", "051182" ], + "051123" : [ "18:43", "350000", "051183" ], + "051124" : [ "18:44", "350000", "051184" ], + "051125" : [ "18:45", "350000", "051185" ], + "051126" : [ "18:46", "350000", "051186" ], + "051127" : [ "18:47", "350000", "051187" ], + "051128" : [ "18:48", "350000", "051188" ], + "051129" : [ "18:49", "350000", "051189" ], + "051130" : [ "18:50", "350000", "051190" ], + "051131" : [ "18:51", "350000", "051191" ], + "051132" : [ "18:52", "350000", "051192" ], + "051133" : [ "18:53", "350000", "051193" ], + "051134" : [ "18:54", "350000", "051194" ], + "051135" : [ "18:55", "350000", "051195" ], + "051136" : [ "18:56", "350000", "051196" ], + "051137" : [ "18:57", "350000", "051197" ], + "051138" : [ "18:58", "350000", "051198" ], + "051139" : [ "18:59", "350000", "051199" ], + "051140" : [ "19:00", "350000", "051200" ], + "051141" : [ "19:01", "350000", "051200" ], + "051142" : [ "19:02", "350000", "051200" ], + "051143" : [ "19:03", "350000", "051200" ], + "051144" : [ "19:04", "350000", "051200" ], + "051145" : [ "19:05", "350000", "051200" ], + "051146" : [ "19:06", "350000", "051200" ], + "051147" : [ "19:07", "350000", "051200" ], + "051148" : [ "19:08", "350000", "051200" ], + "051149" : [ "19:09", "350000", "051200" ], + "051150" : [ "19:10", "350000", "051200" ], + "051151" : [ "19:11", "350000", "051200" ], + "051152" : [ "19:12", "350000", "051200" ], + "051153" : [ "19:13", "350000", "051200" ], + "051154" : [ "19:14", "350000", "051200" ], + "051155" : [ "19:15", "350000", "051200" ], + "051156" : [ "19:16", "350000", "051200" ], + "051157" : [ "19:17", "350000", "051200" ], + "051158" : [ "19:18", "350000", "051200" ], + "051159" : [ "19:19", "350000", "051200" ], + "051160" : [ "19:20", "350000", "051200" ], + "051161" : [ "19:21", "350000", "051200" ], + "051162" : [ "19:22", "350000", "051200" ], + "051163" : [ "19:23", "350000", "051200" ], + "051164" : [ "19:24", "350000", "051200" ], + "051165" : [ "19:25", "350000", "051200" ], + "051166" : [ "19:26", "350000", "051200" ], + "051167" : [ "19:27", "350000", "051200" ], + "051168" : [ "19:28", "350000", "051200" ], + "051169" : [ "19:29", "350000", "051200" ], + "051170" : [ "19:30", "350000", "051200" ], + "051171" : [ "19:31", "350000", "051200" ], + "051172" : [ "19:32", "350000", "051200" ], + "051173" : [ "19:33", "350000", "051200" ], + "051174" : [ "19:34", "350000", "051200" ], + "051175" : [ "19:35", "350000", "051200" ], + "051176" : [ "19:36", "350000", "051200" ], + "051177" : [ "19:37", "350000", "051200" ], + "051178" : [ "19:38", "350000", "051200" ], + "051179" : [ "19:39", "350000", "051200" ], + "051180" : [ "19:40", "350000", "051200" ], + "051181" : [ "19:41", "350000", "051200" ], + "051182" : [ "19:42", "350000", "051200" ], + "051183" : [ "19:43", "350000", "051200" ], + "051184" : [ "19:44", "350000", "051200" ], + "051185" : [ "19:45", "350000", "051200" ], + "051186" : [ "19:46", "350000", "051200" ], + "051187" : [ "19:47", "350000", "051200" ], + "051188" : [ "19:48", "350000", "051200" ], + "051189" : [ "19:49", "350000", "051200" ], + "051190" : [ "19:50", "350000", "051200" ], + "051191" : [ "19:51", "350000", "051200" ], + "051192" : [ "19:52", "350000", "051200" ], + "051193" : [ "19:53", "350000", "051200" ], + "051194" : [ "19:54", "350000", "051200" ], + "051195" : [ "19:55", "350000", "051200" ], + "051196" : [ "19:56", "350000", "051200" ], + "051197" : [ "19:57", "350000", "051200" ], + "051198" : [ "19:58", "350000", "051200" ], + "051199" : [ "19:59", "350000", "051200" ], + "051200" : [ "20:00", "800000", "060420" ], + "051201" : [ "20:01", "800000", "060420" ], + "051202" : [ "20:02", "800000", "060420" ], + "051203" : [ "20:03", "800000", "060420" ], + "051204" : [ "20:04", "800000", "060420" ], + "051205" : [ "20:05", "800000", "060420" ], + "051206" : [ "20:06", "800000", "060420" ], + "051207" : [ "20:07", "800000", "060420" ], + "051208" : [ "20:08", "800000", "060420" ], + "051209" : [ "20:09", "800000", "060420" ], + "051210" : [ "20:10", "800000", "060420" ], + "051211" : [ "20:11", "800000", "060420" ], + "051212" : [ "20:12", "800000", "060420" ], + "051213" : [ "20:13", "800000", "060420" ], + "051214" : [ "20:14", "800000", "060420" ], + "051215" : [ "20:15", "800000", "060420" ], + "051216" : [ "20:16", "800000", "060420" ], + "051217" : [ "20:17", "800000", "060420" ], + "051218" : [ "20:18", "800000", "060420" ], + "051219" : [ "20:19", "800000", "060420" ], + "051220" : [ "20:20", "800000", "060420" ], + "051221" : [ "20:21", "800000", "060420" ], + "051222" : [ "20:22", "800000", "060420" ], + "051223" : [ "20:23", "800000", "060420" ], + "051224" : [ "20:24", "800000", "060420" ], + "051225" : [ "20:25", "800000", "060420" ], + "051226" : [ "20:26", "800000", "060420" ], + "051227" : [ "20:27", "800000", "060420" ], + "051228" : [ "20:28", "800000", "060420" ], + "051229" : [ "20:29", "800000", "060420" ], + "051230" : [ "20:30", "800000", "060420" ], + "051231" : [ "20:31", "800000", "060420" ], + "051232" : [ "20:32", "800000", "060420" ], + "051233" : [ "20:33", "800000", "060420" ], + "051234" : [ "20:34", "800000", "060420" ], + "051235" : [ "20:35", "800000", "060420" ], + "051236" : [ "20:36", "800000", "060420" ], + "051237" : [ "20:37", "800000", "060420" ], + "051238" : [ "20:38", "800000", "060420" ], + "051239" : [ "20:39", "800000", "060420" ], + "051240" : [ "20:40", "800000", "060420" ], + "051241" : [ "20:41", "800000", "060420" ], + "051242" : [ "20:42", "800000", "060420" ], + "051243" : [ "20:43", "800000", "060420" ], + "051244" : [ "20:44", "800000", "060420" ], + "051245" : [ "20:45", "800000", "060420" ], + "051246" : [ "20:46", "800000", "060420" ], + "051247" : [ "20:47", "800000", "060420" ], + "051248" : [ "20:48", "800000", "060420" ], + "051249" : [ "20:49", "800000", "060420" ], + "051250" : [ "20:50", "800000", "060420" ], + "051251" : [ "20:51", "800000", "060420" ], + "051252" : [ "20:52", "800000", "060420" ], + "051253" : [ "20:53", "800000", "060420" ], + "051254" : [ "20:54", "800000", "060420" ], + "051255" : [ "20:55", "800000", "060420" ], + "051256" : [ "20:56", "800000", "060420" ], + "051257" : [ "20:57", "800000", "060420" ], + "051258" : [ "20:58", "800000", "060420" ], + "051259" : [ "20:59", "800000", "060420" ], + "051260" : [ "21:00", "800000", "060420" ], + "051261" : [ "21:01", "800000", "060420" ], + "051262" : [ "21:02", "800000", "060420" ], + "051263" : [ "21:03", "800000", "060420" ], + "051264" : [ "21:04", "800000", "060420" ], + "051265" : [ "21:05", "800000", "060420" ], + "051266" : [ "21:06", "800000", "060420" ], + "051267" : [ "21:07", "800000", "060420" ], + "051268" : [ "21:08", "800000", "060420" ], + "051269" : [ "21:09", "800000", "060420" ], + "051270" : [ "21:10", "800000", "060420" ], + "051271" : [ "21:11", "800000", "060420" ], + "051272" : [ "21:12", "800000", "060420" ], + "051273" : [ "21:13", "800000", "060420" ], + "051274" : [ "21:14", "800000", "060420" ], + "051275" : [ "21:15", "800000", "060420" ], + "051276" : [ "21:16", "800000", "060420" ], + "051277" : [ "21:17", "800000", "060420" ], + "051278" : [ "21:18", "800000", "060420" ], + "051279" : [ "21:19", "800000", "060420" ], + "051280" : [ "21:20", "800000", "060420" ], + "051281" : [ "21:21", "800000", "060420" ], + "051282" : [ "21:22", "800000", "060420" ], + "051283" : [ "21:23", "800000", "060420" ], + "051284" : [ "21:24", "800000", "060420" ], + "051285" : [ "21:25", "800000", "060420" ], + "051286" : [ "21:26", "800000", "060420" ], + "051287" : [ "21:27", "800000", "060420" ], + "051288" : [ "21:28", "800000", "060420" ], + "051289" : [ "21:29", "800000", "060420" ], + "051290" : [ "21:30", "800000", "060420" ], + "051291" : [ "21:31", "800000", "060420" ], + "051292" : [ "21:32", "800000", "060420" ], + "051293" : [ "21:33", "800000", "060420" ], + "051294" : [ "21:34", "800000", "060420" ], + "051295" : [ "21:35", "800000", "060420" ], + "051296" : [ "21:36", "800000", "060420" ], + "051297" : [ "21:37", "800000", "060420" ], + "051298" : [ "21:38", "800000", "060420" ], + "051299" : [ "21:39", "800000", "060420" ], + "051300" : [ "21:40", "800000", "060420" ], + "051301" : [ "21:41", "800000", "060420" ], + "051302" : [ "21:42", "800000", "060420" ], + "051303" : [ "21:43", "800000", "060420" ], + "051304" : [ "21:44", "800000", "060420" ], + "051305" : [ "21:45", "800000", "060420" ], + "051306" : [ "21:46", "800000", "060420" ], + "051307" : [ "21:47", "800000", "060420" ], + "051308" : [ "21:48", "800000", "060420" ], + "051309" : [ "21:49", "800000", "060420" ], + "051310" : [ "21:50", "800000", "060420" ], + "051311" : [ "21:51", "800000", "060420" ], + "051312" : [ "21:52", "800000", "060420" ], + "051313" : [ "21:53", "800000", "060420" ], + "051314" : [ "21:54", "800000", "060420" ], + "051315" : [ "21:55", "800000", "060420" ], + "051316" : [ "21:56", "800000", "060420" ], + "051317" : [ "21:57", "800000", "060420" ], + "051318" : [ "21:58", "800000", "060420" ], + "051319" : [ "21:59", "800000", "060420" ], + "051320" : [ "22:00", "800000", "060420" ], + "051321" : [ "22:01", "800000", "060420" ], + "051322" : [ "22:02", "800000", "060420" ], + "051323" : [ "22:03", "800000", "060420" ], + "051324" : [ "22:04", "800000", "060420" ], + "051325" : [ "22:05", "800000", "060420" ], + "051326" : [ "22:06", "800000", "060420" ], + "051327" : [ "22:07", "800000", "060420" ], + "051328" : [ "22:08", "800000", "060420" ], + "051329" : [ "22:09", "800000", "060420" ], + "051330" : [ "22:10", "800000", "060420" ], + "051331" : [ "22:11", "800000", "060420" ], + "051332" : [ "22:12", "800000", "060420" ], + "051333" : [ "22:13", "800000", "060420" ], + "051334" : [ "22:14", "800000", "060420" ], + "051335" : [ "22:15", "800000", "060420" ], + "051336" : [ "22:16", "800000", "060420" ], + "051337" : [ "22:17", "800000", "060420" ], + "051338" : [ "22:18", "800000", "060420" ], + "051339" : [ "22:19", "800000", "060420" ], + "051340" : [ "22:20", "800000", "060420" ], + "051341" : [ "22:21", "800000", "060420" ], + "051342" : [ "22:22", "800000", "060420" ], + "051343" : [ "22:23", "800000", "060420" ], + "051344" : [ "22:24", "800000", "060420" ], + "051345" : [ "22:25", "800000", "060420" ], + "051346" : [ "22:26", "800000", "060420" ], + "051347" : [ "22:27", "800000", "060420" ], + "051348" : [ "22:28", "800000", "060420" ], + "051349" : [ "22:29", "800000", "060420" ], + "051350" : [ "22:30", "800000", "060420" ], + "051351" : [ "22:31", "800000", "060420" ], + "051352" : [ "22:32", "800000", "060420" ], + "051353" : [ "22:33", "800000", "060420" ], + "051354" : [ "22:34", "800000", "060420" ], + "051355" : [ "22:35", "800000", "060420" ], + "051356" : [ "22:36", "800000", "060420" ], + "051357" : [ "22:37", "800000", "060420" ], + "051358" : [ "22:38", "800000", "060420" ], + "051359" : [ "22:39", "800000", "060420" ], + "051360" : [ "22:40", "800000", "060420" ], + "051361" : [ "22:41", "800000", "060420" ], + "051362" : [ "22:42", "800000", "060420" ], + "051363" : [ "22:43", "800000", "060420" ], + "051364" : [ "22:44", "800000", "060420" ], + "051365" : [ "22:45", "800000", "060420" ], + "051366" : [ "22:46", "800000", "060420" ], + "051367" : [ "22:47", "800000", "060420" ], + "051368" : [ "22:48", "800000", "060420" ], + "051369" : [ "22:49", "800000", "060420" ], + "051370" : [ "22:50", "800000", "060420" ], + "051371" : [ "22:51", "800000", "060420" ], + "051372" : [ "22:52", "800000", "060420" ], + "051373" : [ "22:53", "800000", "060420" ], + "051374" : [ "22:54", "800000", "060420" ], + "051375" : [ "22:55", "800000", "060420" ], + "051376" : [ "22:56", "800000", "060420" ], + "051377" : [ "22:57", "800000", "060420" ], + "051378" : [ "22:58", "800000", "060420" ], + "051379" : [ "22:59", "800000", "060420" ], + "051380" : [ "23:00", "800000", "060420" ], + "051381" : [ "23:01", "800000", "060420" ], + "051382" : [ "23:02", "800000", "060420" ], + "051383" : [ "23:03", "800000", "060420" ], + "051384" : [ "23:04", "800000", "060420" ], + "051385" : [ "23:05", "800000", "060420" ], + "051386" : [ "23:06", "800000", "060420" ], + "051387" : [ "23:07", "800000", "060420" ], + "051388" : [ "23:08", "800000", "060420" ], + "051389" : [ "23:09", "800000", "060420" ], + "051390" : [ "23:10", "800000", "060420" ], + "051391" : [ "23:11", "800000", "060420" ], + "051392" : [ "23:12", "800000", "060420" ], + "051393" : [ "23:13", "800000", "060420" ], + "051394" : [ "23:14", "800000", "060420" ], + "051395" : [ "23:15", "800000", "060420" ], + "051396" : [ "23:16", "800000", "060420" ], + "051397" : [ "23:17", "800000", "060420" ], + "051398" : [ "23:18", "800000", "060420" ], + "051399" : [ "23:19", "800000", "060420" ], + "051400" : [ "23:20", "800000", "060420" ], + "051401" : [ "23:21", "800000", "060420" ], + "051402" : [ "23:22", "800000", "060420" ], + "051403" : [ "23:23", "800000", "060420" ], + "051404" : [ "23:24", "800000", "060420" ], + "051405" : [ "23:25", "800000", "060420" ], + "051406" : [ "23:26", "800000", "060420" ], + "051407" : [ "23:27", "800000", "060420" ], + "051408" : [ "23:28", "800000", "060420" ], + "051409" : [ "23:29", "800000", "060420" ], + "051410" : [ "23:30", "800000", "060420" ], + "051411" : [ "23:31", "800000", "060420" ], + "051412" : [ "23:32", "800000", "060420" ], + "051413" : [ "23:33", "800000", "060420" ], + "051414" : [ "23:34", "800000", "060420" ], + "051415" : [ "23:35", "800000", "060420" ], + "051416" : [ "23:36", "800000", "060420" ], + "051417" : [ "23:37", "800000", "060420" ], + "051418" : [ "23:38", "800000", "060420" ], + "051419" : [ "23:39", "800000", "060420" ], + "051420" : [ "23:40", "800000", "060420" ], + "051421" : [ "23:41", "800000", "060420" ], + "051422" : [ "23:42", "800000", "060420" ], + "051423" : [ "23:43", "800000", "060420" ], + "051424" : [ "23:44", "800000", "060420" ], + "051425" : [ "23:45", "800000", "060420" ], + "051426" : [ "23:46", "800000", "060420" ], + "051427" : [ "23:47", "800000", "060420" ], + "051428" : [ "23:48", "800000", "060420" ], + "051429" : [ "23:49", "800000", "060420" ], + "051430" : [ "23:50", "800000", "060420" ], + "051431" : [ "23:51", "800000", "060420" ], + "051432" : [ "23:52", "800000", "060420" ], + "051433" : [ "23:53", "800000", "060420" ], + "051434" : [ "23:54", "800000", "060420" ], + "051435" : [ "23:55", "800000", "060420" ], + "051436" : [ "23:56", "800000", "060420" ], + "051437" : [ "23:57", "800000", "060420" ], + "051438" : [ "23:58", "800000", "060420" ], + "051439" : [ "23:59", "800000", "060420" ] + }, + "Sunday": { + "060000" : [ "00:00", "800000", "060420" ], + "060001" : [ "00:01", "800000", "060420" ], + "060002" : [ "00:02", "800000", "060420" ], + "060003" : [ "00:03", "800000", "060420" ], + "060004" : [ "00:04", "800000", "060420" ], + "060005" : [ "00:05", "800000", "060420" ], + "060006" : [ "00:06", "800000", "060420" ], + "060007" : [ "00:07", "800000", "060420" ], + "060008" : [ "00:08", "800000", "060420" ], + "060009" : [ "00:09", "800000", "060420" ], + "060010" : [ "00:10", "800000", "060420" ], + "060011" : [ "00:11", "800000", "060420" ], + "060012" : [ "00:12", "800000", "060420" ], + "060013" : [ "00:13", "800000", "060420" ], + "060014" : [ "00:14", "800000", "060420" ], + "060015" : [ "00:15", "800000", "060420" ], + "060016" : [ "00:16", "800000", "060420" ], + "060017" : [ "00:17", "800000", "060420" ], + "060018" : [ "00:18", "800000", "060420" ], + "060019" : [ "00:19", "800000", "060420" ], + "060020" : [ "00:20", "800000", "060420" ], + "060021" : [ "00:21", "800000", "060420" ], + "060022" : [ "00:22", "800000", "060420" ], + "060023" : [ "00:23", "800000", "060420" ], + "060024" : [ "00:24", "800000", "060420" ], + "060025" : [ "00:25", "800000", "060420" ], + "060026" : [ "00:26", "800000", "060420" ], + "060027" : [ "00:27", "800000", "060420" ], + "060028" : [ "00:28", "800000", "060420" ], + "060029" : [ "00:29", "800000", "060420" ], + "060030" : [ "00:30", "800000", "060420" ], + "060031" : [ "00:31", "800000", "060420" ], + "060032" : [ "00:32", "800000", "060420" ], + "060033" : [ "00:33", "800000", "060420" ], + "060034" : [ "00:34", "800000", "060420" ], + "060035" : [ "00:35", "800000", "060420" ], + "060036" : [ "00:36", "800000", "060420" ], + "060037" : [ "00:37", "800000", "060420" ], + "060038" : [ "00:38", "800000", "060420" ], + "060039" : [ "00:39", "800000", "060420" ], + "060040" : [ "00:40", "800000", "060420" ], + "060041" : [ "00:41", "800000", "060420" ], + "060042" : [ "00:42", "800000", "060420" ], + "060043" : [ "00:43", "800000", "060420" ], + "060044" : [ "00:44", "800000", "060420" ], + "060045" : [ "00:45", "800000", "060420" ], + "060046" : [ "00:46", "800000", "060420" ], + "060047" : [ "00:47", "800000", "060420" ], + "060048" : [ "00:48", "800000", "060420" ], + "060049" : [ "00:49", "800000", "060420" ], + "060050" : [ "00:50", "800000", "060420" ], + "060051" : [ "00:51", "800000", "060420" ], + "060052" : [ "00:52", "800000", "060420" ], + "060053" : [ "00:53", "800000", "060420" ], + "060054" : [ "00:54", "800000", "060420" ], + "060055" : [ "00:55", "800000", "060420" ], + "060056" : [ "00:56", "800000", "060420" ], + "060057" : [ "00:57", "800000", "060420" ], + "060058" : [ "00:58", "800000", "060420" ], + "060059" : [ "00:59", "800000", "060420" ], + "060060" : [ "01:00", "800000", "060420" ], + "060061" : [ "01:01", "800000", "060420" ], + "060062" : [ "01:02", "800000", "060420" ], + "060063" : [ "01:03", "800000", "060420" ], + "060064" : [ "01:04", "800000", "060420" ], + "060065" : [ "01:05", "800000", "060420" ], + "060066" : [ "01:06", "800000", "060420" ], + "060067" : [ "01:07", "800000", "060420" ], + "060068" : [ "01:08", "800000", "060420" ], + "060069" : [ "01:09", "800000", "060420" ], + "060070" : [ "01:10", "800000", "060420" ], + "060071" : [ "01:11", "800000", "060420" ], + "060072" : [ "01:12", "800000", "060420" ], + "060073" : [ "01:13", "800000", "060420" ], + "060074" : [ "01:14", "800000", "060420" ], + "060075" : [ "01:15", "800000", "060420" ], + "060076" : [ "01:16", "800000", "060420" ], + "060077" : [ "01:17", "800000", "060420" ], + "060078" : [ "01:18", "800000", "060420" ], + "060079" : [ "01:19", "800000", "060420" ], + "060080" : [ "01:20", "800000", "060420" ], + "060081" : [ "01:21", "800000", "060420" ], + "060082" : [ "01:22", "800000", "060420" ], + "060083" : [ "01:23", "800000", "060420" ], + "060084" : [ "01:24", "800000", "060420" ], + "060085" : [ "01:25", "800000", "060420" ], + "060086" : [ "01:26", "800000", "060420" ], + "060087" : [ "01:27", "800000", "060420" ], + "060088" : [ "01:28", "800000", "060420" ], + "060089" : [ "01:29", "800000", "060420" ], + "060090" : [ "01:30", "800000", "060420" ], + "060091" : [ "01:31", "800000", "060420" ], + "060092" : [ "01:32", "800000", "060420" ], + "060093" : [ "01:33", "800000", "060420" ], + "060094" : [ "01:34", "800000", "060420" ], + "060095" : [ "01:35", "800000", "060420" ], + "060096" : [ "01:36", "800000", "060420" ], + "060097" : [ "01:37", "800000", "060420" ], + "060098" : [ "01:38", "800000", "060420" ], + "060099" : [ "01:39", "800000", "060420" ], + "060100" : [ "01:40", "800000", "060420" ], + "060101" : [ "01:41", "800000", "060420" ], + "060102" : [ "01:42", "800000", "060420" ], + "060103" : [ "01:43", "800000", "060420" ], + "060104" : [ "01:44", "800000", "060420" ], + "060105" : [ "01:45", "800000", "060420" ], + "060106" : [ "01:46", "800000", "060420" ], + "060107" : [ "01:47", "800000", "060420" ], + "060108" : [ "01:48", "800000", "060420" ], + "060109" : [ "01:49", "800000", "060420" ], + "060110" : [ "01:50", "800000", "060420" ], + "060111" : [ "01:51", "800000", "060420" ], + "060112" : [ "01:52", "800000", "060420" ], + "060113" : [ "01:53", "800000", "060420" ], + "060114" : [ "01:54", "800000", "060420" ], + "060115" : [ "01:55", "800000", "060420" ], + "060116" : [ "01:56", "800000", "060420" ], + "060117" : [ "01:57", "800000", "060420" ], + "060118" : [ "01:58", "800000", "060420" ], + "060119" : [ "01:59", "800000", "060420" ], + "060120" : [ "02:00", "800000", "060420" ], + "060121" : [ "02:01", "800000", "060420" ], + "060122" : [ "02:02", "800000", "060420" ], + "060123" : [ "02:03", "800000", "060420" ], + "060124" : [ "02:04", "800000", "060420" ], + "060125" : [ "02:05", "800000", "060420" ], + "060126" : [ "02:06", "800000", "060420" ], + "060127" : [ "02:07", "800000", "060420" ], + "060128" : [ "02:08", "800000", "060420" ], + "060129" : [ "02:09", "800000", "060420" ], + "060130" : [ "02:10", "800000", "060420" ], + "060131" : [ "02:11", "800000", "060420" ], + "060132" : [ "02:12", "800000", "060420" ], + "060133" : [ "02:13", "800000", "060420" ], + "060134" : [ "02:14", "800000", "060420" ], + "060135" : [ "02:15", "800000", "060420" ], + "060136" : [ "02:16", "800000", "060420" ], + "060137" : [ "02:17", "800000", "060420" ], + "060138" : [ "02:18", "800000", "060420" ], + "060139" : [ "02:19", "800000", "060420" ], + "060140" : [ "02:20", "800000", "060420" ], + "060141" : [ "02:21", "800000", "060420" ], + "060142" : [ "02:22", "800000", "060420" ], + "060143" : [ "02:23", "800000", "060420" ], + "060144" : [ "02:24", "800000", "060420" ], + "060145" : [ "02:25", "800000", "060420" ], + "060146" : [ "02:26", "800000", "060420" ], + "060147" : [ "02:27", "800000", "060420" ], + "060148" : [ "02:28", "800000", "060420" ], + "060149" : [ "02:29", "800000", "060420" ], + "060150" : [ "02:30", "800000", "060420" ], + "060151" : [ "02:31", "800000", "060420" ], + "060152" : [ "02:32", "800000", "060420" ], + "060153" : [ "02:33", "800000", "060420" ], + "060154" : [ "02:34", "800000", "060420" ], + "060155" : [ "02:35", "800000", "060420" ], + "060156" : [ "02:36", "800000", "060420" ], + "060157" : [ "02:37", "800000", "060420" ], + "060158" : [ "02:38", "800000", "060420" ], + "060159" : [ "02:39", "800000", "060420" ], + "060160" : [ "02:40", "800000", "060420" ], + "060161" : [ "02:41", "800000", "060420" ], + "060162" : [ "02:42", "800000", "060420" ], + "060163" : [ "02:43", "800000", "060420" ], + "060164" : [ "02:44", "800000", "060420" ], + "060165" : [ "02:45", "800000", "060420" ], + "060166" : [ "02:46", "800000", "060420" ], + "060167" : [ "02:47", "800000", "060420" ], + "060168" : [ "02:48", "800000", "060420" ], + "060169" : [ "02:49", "800000", "060420" ], + "060170" : [ "02:50", "800000", "060420" ], + "060171" : [ "02:51", "800000", "060420" ], + "060172" : [ "02:52", "800000", "060420" ], + "060173" : [ "02:53", "800000", "060420" ], + "060174" : [ "02:54", "800000", "060420" ], + "060175" : [ "02:55", "800000", "060420" ], + "060176" : [ "02:56", "800000", "060420" ], + "060177" : [ "02:57", "800000", "060420" ], + "060178" : [ "02:58", "800000", "060420" ], + "060179" : [ "02:59", "800000", "060420" ], + "060180" : [ "03:00", "800000", "060420" ], + "060181" : [ "03:01", "800000", "060420" ], + "060182" : [ "03:02", "800000", "060420" ], + "060183" : [ "03:03", "800000", "060420" ], + "060184" : [ "03:04", "800000", "060420" ], + "060185" : [ "03:05", "800000", "060420" ], + "060186" : [ "03:06", "800000", "060420" ], + "060187" : [ "03:07", "800000", "060420" ], + "060188" : [ "03:08", "800000", "060420" ], + "060189" : [ "03:09", "800000", "060420" ], + "060190" : [ "03:10", "800000", "060420" ], + "060191" : [ "03:11", "800000", "060420" ], + "060192" : [ "03:12", "800000", "060420" ], + "060193" : [ "03:13", "800000", "060420" ], + "060194" : [ "03:14", "800000", "060420" ], + "060195" : [ "03:15", "800000", "060420" ], + "060196" : [ "03:16", "800000", "060420" ], + "060197" : [ "03:17", "800000", "060420" ], + "060198" : [ "03:18", "800000", "060420" ], + "060199" : [ "03:19", "800000", "060420" ], + "060200" : [ "03:20", "800000", "060420" ], + "060201" : [ "03:21", "800000", "060420" ], + "060202" : [ "03:22", "800000", "060420" ], + "060203" : [ "03:23", "800000", "060420" ], + "060204" : [ "03:24", "800000", "060420" ], + "060205" : [ "03:25", "800000", "060420" ], + "060206" : [ "03:26", "800000", "060420" ], + "060207" : [ "03:27", "800000", "060420" ], + "060208" : [ "03:28", "800000", "060420" ], + "060209" : [ "03:29", "800000", "060420" ], + "060210" : [ "03:30", "800000", "060420" ], + "060211" : [ "03:31", "800000", "060420" ], + "060212" : [ "03:32", "800000", "060420" ], + "060213" : [ "03:33", "800000", "060420" ], + "060214" : [ "03:34", "800000", "060420" ], + "060215" : [ "03:35", "800000", "060420" ], + "060216" : [ "03:36", "800000", "060420" ], + "060217" : [ "03:37", "800000", "060420" ], + "060218" : [ "03:38", "800000", "060420" ], + "060219" : [ "03:39", "800000", "060420" ], + "060220" : [ "03:40", "800000", "060420" ], + "060221" : [ "03:41", "800000", "060420" ], + "060222" : [ "03:42", "800000", "060420" ], + "060223" : [ "03:43", "800000", "060420" ], + "060224" : [ "03:44", "800000", "060420" ], + "060225" : [ "03:45", "800000", "060420" ], + "060226" : [ "03:46", "800000", "060420" ], + "060227" : [ "03:47", "800000", "060420" ], + "060228" : [ "03:48", "800000", "060420" ], + "060229" : [ "03:49", "800000", "060420" ], + "060230" : [ "03:50", "800000", "060420" ], + "060231" : [ "03:51", "800000", "060420" ], + "060232" : [ "03:52", "800000", "060420" ], + "060233" : [ "03:53", "800000", "060420" ], + "060234" : [ "03:54", "800000", "060420" ], + "060235" : [ "03:55", "800000", "060420" ], + "060236" : [ "03:56", "800000", "060420" ], + "060237" : [ "03:57", "800000", "060420" ], + "060238" : [ "03:58", "800000", "060420" ], + "060239" : [ "03:59", "800000", "060420" ], + "060240" : [ "04:00", "800000", "060420" ], + "060241" : [ "04:01", "800000", "060420" ], + "060242" : [ "04:02", "800000", "060420" ], + "060243" : [ "04:03", "800000", "060420" ], + "060244" : [ "04:04", "800000", "060420" ], + "060245" : [ "04:05", "800000", "060420" ], + "060246" : [ "04:06", "800000", "060420" ], + "060247" : [ "04:07", "800000", "060420" ], + "060248" : [ "04:08", "800000", "060420" ], + "060249" : [ "04:09", "800000", "060420" ], + "060250" : [ "04:10", "800000", "060420" ], + "060251" : [ "04:11", "800000", "060420" ], + "060252" : [ "04:12", "800000", "060420" ], + "060253" : [ "04:13", "800000", "060420" ], + "060254" : [ "04:14", "800000", "060420" ], + "060255" : [ "04:15", "800000", "060420" ], + "060256" : [ "04:16", "800000", "060420" ], + "060257" : [ "04:17", "800000", "060420" ], + "060258" : [ "04:18", "800000", "060420" ], + "060259" : [ "04:19", "800000", "060420" ], + "060260" : [ "04:20", "800000", "060420" ], + "060261" : [ "04:21", "800000", "060420" ], + "060262" : [ "04:22", "800000", "060420" ], + "060263" : [ "04:23", "800000", "060420" ], + "060264" : [ "04:24", "800000", "060420" ], + "060265" : [ "04:25", "800000", "060420" ], + "060266" : [ "04:26", "800000", "060420" ], + "060267" : [ "04:27", "800000", "060420" ], + "060268" : [ "04:28", "800000", "060420" ], + "060269" : [ "04:29", "800000", "060420" ], + "060270" : [ "04:30", "800000", "060420" ], + "060271" : [ "04:31", "800000", "060420" ], + "060272" : [ "04:32", "800000", "060420" ], + "060273" : [ "04:33", "800000", "060420" ], + "060274" : [ "04:34", "800000", "060420" ], + "060275" : [ "04:35", "800000", "060420" ], + "060276" : [ "04:36", "800000", "060420" ], + "060277" : [ "04:37", "800000", "060420" ], + "060278" : [ "04:38", "800000", "060420" ], + "060279" : [ "04:39", "800000", "060420" ], + "060280" : [ "04:40", "800000", "060420" ], + "060281" : [ "04:41", "800000", "060420" ], + "060282" : [ "04:42", "800000", "060420" ], + "060283" : [ "04:43", "800000", "060420" ], + "060284" : [ "04:44", "800000", "060420" ], + "060285" : [ "04:45", "800000", "060420" ], + "060286" : [ "04:46", "800000", "060420" ], + "060287" : [ "04:47", "800000", "060420" ], + "060288" : [ "04:48", "800000", "060420" ], + "060289" : [ "04:49", "800000", "060420" ], + "060290" : [ "04:50", "800000", "060420" ], + "060291" : [ "04:51", "800000", "060420" ], + "060292" : [ "04:52", "800000", "060420" ], + "060293" : [ "04:53", "800000", "060420" ], + "060294" : [ "04:54", "800000", "060420" ], + "060295" : [ "04:55", "800000", "060420" ], + "060296" : [ "04:56", "800000", "060420" ], + "060297" : [ "04:57", "800000", "060420" ], + "060298" : [ "04:58", "800000", "060420" ], + "060299" : [ "04:59", "800000", "060420" ], + "060300" : [ "05:00", "800000", "060420" ], + "060301" : [ "05:01", "800000", "060420" ], + "060302" : [ "05:02", "800000", "060420" ], + "060303" : [ "05:03", "800000", "060420" ], + "060304" : [ "05:04", "800000", "060420" ], + "060305" : [ "05:05", "800000", "060420" ], + "060306" : [ "05:06", "800000", "060420" ], + "060307" : [ "05:07", "800000", "060420" ], + "060308" : [ "05:08", "800000", "060420" ], + "060309" : [ "05:09", "800000", "060420" ], + "060310" : [ "05:10", "800000", "060420" ], + "060311" : [ "05:11", "800000", "060420" ], + "060312" : [ "05:12", "800000", "060420" ], + "060313" : [ "05:13", "800000", "060420" ], + "060314" : [ "05:14", "800000", "060420" ], + "060315" : [ "05:15", "800000", "060420" ], + "060316" : [ "05:16", "800000", "060420" ], + "060317" : [ "05:17", "800000", "060420" ], + "060318" : [ "05:18", "800000", "060420" ], + "060319" : [ "05:19", "800000", "060420" ], + "060320" : [ "05:20", "800000", "060420" ], + "060321" : [ "05:21", "800000", "060420" ], + "060322" : [ "05:22", "800000", "060420" ], + "060323" : [ "05:23", "800000", "060420" ], + "060324" : [ "05:24", "800000", "060420" ], + "060325" : [ "05:25", "800000", "060420" ], + "060326" : [ "05:26", "800000", "060420" ], + "060327" : [ "05:27", "800000", "060420" ], + "060328" : [ "05:28", "800000", "060420" ], + "060329" : [ "05:29", "800000", "060420" ], + "060330" : [ "05:30", "800000", "060420" ], + "060331" : [ "05:31", "800000", "060420" ], + "060332" : [ "05:32", "800000", "060420" ], + "060333" : [ "05:33", "800000", "060420" ], + "060334" : [ "05:34", "800000", "060420" ], + "060335" : [ "05:35", "800000", "060420" ], + "060336" : [ "05:36", "800000", "060420" ], + "060337" : [ "05:37", "800000", "060420" ], + "060338" : [ "05:38", "800000", "060420" ], + "060339" : [ "05:39", "800000", "060420" ], + "060340" : [ "05:40", "800000", "060420" ], + "060341" : [ "05:41", "800000", "060420" ], + "060342" : [ "05:42", "800000", "060420" ], + "060343" : [ "05:43", "800000", "060420" ], + "060344" : [ "05:44", "800000", "060420" ], + "060345" : [ "05:45", "800000", "060420" ], + "060346" : [ "05:46", "800000", "060420" ], + "060347" : [ "05:47", "800000", "060420" ], + "060348" : [ "05:48", "800000", "060420" ], + "060349" : [ "05:49", "800000", "060420" ], + "060350" : [ "05:50", "800000", "060420" ], + "060351" : [ "05:51", "800000", "060420" ], + "060352" : [ "05:52", "800000", "060420" ], + "060353" : [ "05:53", "800000", "060420" ], + "060354" : [ "05:54", "800000", "060420" ], + "060355" : [ "05:55", "800000", "060420" ], + "060356" : [ "05:56", "800000", "060420" ], + "060357" : [ "05:57", "800000", "060420" ], + "060358" : [ "05:58", "800000", "060420" ], + "060359" : [ "05:59", "800000", "060420" ], + "060360" : [ "06:00", "800000", "060420" ], + "060361" : [ "06:01", "800000", "060420" ], + "060362" : [ "06:02", "800000", "060420" ], + "060363" : [ "06:03", "800000", "060420" ], + "060364" : [ "06:04", "800000", "060420" ], + "060365" : [ "06:05", "800000", "060420" ], + "060366" : [ "06:06", "800000", "060420" ], + "060367" : [ "06:07", "800000", "060420" ], + "060368" : [ "06:08", "800000", "060420" ], + "060369" : [ "06:09", "800000", "060420" ], + "060370" : [ "06:10", "800000", "060420" ], + "060371" : [ "06:11", "800000", "060420" ], + "060372" : [ "06:12", "800000", "060420" ], + "060373" : [ "06:13", "800000", "060420" ], + "060374" : [ "06:14", "800000", "060420" ], + "060375" : [ "06:15", "800000", "060420" ], + "060376" : [ "06:16", "800000", "060420" ], + "060377" : [ "06:17", "800000", "060420" ], + "060378" : [ "06:18", "800000", "060420" ], + "060379" : [ "06:19", "800000", "060420" ], + "060380" : [ "06:20", "800000", "060420" ], + "060381" : [ "06:21", "800000", "060420" ], + "060382" : [ "06:22", "800000", "060420" ], + "060383" : [ "06:23", "800000", "060420" ], + "060384" : [ "06:24", "800000", "060420" ], + "060385" : [ "06:25", "800000", "060420" ], + "060386" : [ "06:26", "800000", "060420" ], + "060387" : [ "06:27", "800000", "060420" ], + "060388" : [ "06:28", "800000", "060420" ], + "060389" : [ "06:29", "800000", "060420" ], + "060390" : [ "06:30", "800000", "060420" ], + "060391" : [ "06:31", "800000", "060420" ], + "060392" : [ "06:32", "800000", "060420" ], + "060393" : [ "06:33", "800000", "060420" ], + "060394" : [ "06:34", "800000", "060420" ], + "060395" : [ "06:35", "800000", "060420" ], + "060396" : [ "06:36", "800000", "060420" ], + "060397" : [ "06:37", "800000", "060420" ], + "060398" : [ "06:38", "800000", "060420" ], + "060399" : [ "06:39", "800000", "060420" ], + "060400" : [ "06:40", "800000", "060420" ], + "060401" : [ "06:41", "800000", "060420" ], + "060402" : [ "06:42", "800000", "060420" ], + "060403" : [ "06:43", "800000", "060420" ], + "060404" : [ "06:44", "800000", "060420" ], + "060405" : [ "06:45", "800000", "060420" ], + "060406" : [ "06:46", "800000", "060420" ], + "060407" : [ "06:47", "800000", "060420" ], + "060408" : [ "06:48", "800000", "060420" ], + "060409" : [ "06:49", "800000", "060420" ], + "060410" : [ "06:50", "800000", "060420" ], + "060411" : [ "06:51", "800000", "060420" ], + "060412" : [ "06:52", "800000", "060420" ], + "060413" : [ "06:53", "800000", "060420" ], + "060414" : [ "06:54", "800000", "060420" ], + "060415" : [ "06:55", "800000", "060420" ], + "060416" : [ "06:56", "800000", "060420" ], + "060417" : [ "06:57", "800000", "060420" ], + "060418" : [ "06:58", "800000", "060420" ], + "060419" : [ "06:59", "800000", "060420" ], + "060420" : [ "07:00", "350000", "060480" ], + "060421" : [ "07:01", "350000", "060481" ], + "060422" : [ "07:02", "350000", "060482" ], + "060423" : [ "07:03", "350000", "060483" ], + "060424" : [ "07:04", "350000", "060484" ], + "060425" : [ "07:05", "350000", "060485" ], + "060426" : [ "07:06", "350000", "060486" ], + "060427" : [ "07:07", "350000", "060487" ], + "060428" : [ "07:08", "350000", "060488" ], + "060429" : [ "07:09", "350000", "060489" ], + "060430" : [ "07:10", "350000", "060490" ], + "060431" : [ "07:11", "350000", "060491" ], + "060432" : [ "07:12", "350000", "060492" ], + "060433" : [ "07:13", "350000", "060493" ], + "060434" : [ "07:14", "350000", "060494" ], + "060435" : [ "07:15", "350000", "060495" ], + "060436" : [ "07:16", "350000", "060496" ], + "060437" : [ "07:17", "350000", "060497" ], + "060438" : [ "07:18", "350000", "060498" ], + "060439" : [ "07:19", "350000", "060499" ], + "060440" : [ "07:20", "350000", "060500" ], + "060441" : [ "07:21", "350000", "060501" ], + "060442" : [ "07:22", "350000", "060502" ], + "060443" : [ "07:23", "350000", "060503" ], + "060444" : [ "07:24", "350000", "060504" ], + "060445" : [ "07:25", "350000", "060505" ], + "060446" : [ "07:26", "350000", "060506" ], + "060447" : [ "07:27", "350000", "060507" ], + "060448" : [ "07:28", "350000", "060508" ], + "060449" : [ "07:29", "350000", "060509" ], + "060450" : [ "07:30", "350000", "060510" ], + "060451" : [ "07:31", "350000", "060511" ], + "060452" : [ "07:32", "350000", "060512" ], + "060453" : [ "07:33", "350000", "060513" ], + "060454" : [ "07:34", "350000", "060514" ], + "060455" : [ "07:35", "350000", "060515" ], + "060456" : [ "07:36", "350000", "060516" ], + "060457" : [ "07:37", "350000", "060517" ], + "060458" : [ "07:38", "350000", "060518" ], + "060459" : [ "07:39", "350000", "060519" ], + "060460" : [ "07:40", "350000", "060520" ], + "060461" : [ "07:41", "350000", "060521" ], + "060462" : [ "07:42", "350000", "060522" ], + "060463" : [ "07:43", "350000", "060523" ], + "060464" : [ "07:44", "350000", "060524" ], + "060465" : [ "07:45", "350000", "060525" ], + "060466" : [ "07:46", "350000", "060526" ], + "060467" : [ "07:47", "350000", "060527" ], + "060468" : [ "07:48", "350000", "060528" ], + "060469" : [ "07:49", "350000", "060529" ], + "060470" : [ "07:50", "350000", "060530" ], + "060471" : [ "07:51", "350000", "060531" ], + "060472" : [ "07:52", "350000", "060532" ], + "060473" : [ "07:53", "350000", "060533" ], + "060474" : [ "07:54", "350000", "060534" ], + "060475" : [ "07:55", "350000", "060535" ], + "060476" : [ "07:56", "350000", "060536" ], + "060477" : [ "07:57", "350000", "060537" ], + "060478" : [ "07:58", "350000", "060538" ], + "060479" : [ "07:59", "350000", "060539" ], + "060480" : [ "08:00", "350000", "060540" ], + "060481" : [ "08:01", "350000", "060541" ], + "060482" : [ "08:02", "350000", "060542" ], + "060483" : [ "08:03", "350000", "060543" ], + "060484" : [ "08:04", "350000", "060544" ], + "060485" : [ "08:05", "350000", "060545" ], + "060486" : [ "08:06", "350000", "060546" ], + "060487" : [ "08:07", "350000", "060547" ], + "060488" : [ "08:08", "350000", "060548" ], + "060489" : [ "08:09", "350000", "060549" ], + "060490" : [ "08:10", "350000", "060550" ], + "060491" : [ "08:11", "350000", "060551" ], + "060492" : [ "08:12", "350000", "060552" ], + "060493" : [ "08:13", "350000", "060553" ], + "060494" : [ "08:14", "350000", "060554" ], + "060495" : [ "08:15", "350000", "060555" ], + "060496" : [ "08:16", "350000", "060556" ], + "060497" : [ "08:17", "350000", "060557" ], + "060498" : [ "08:18", "350000", "060558" ], + "060499" : [ "08:19", "350000", "060559" ], + "060500" : [ "08:20", "350000", "060560" ], + "060501" : [ "08:21", "350000", "060561" ], + "060502" : [ "08:22", "350000", "060562" ], + "060503" : [ "08:23", "350000", "060563" ], + "060504" : [ "08:24", "350000", "060564" ], + "060505" : [ "08:25", "350000", "060565" ], + "060506" : [ "08:26", "350000", "060566" ], + "060507" : [ "08:27", "350000", "060567" ], + "060508" : [ "08:28", "350000", "060568" ], + "060509" : [ "08:29", "350000", "060569" ], + "060510" : [ "08:30", "350000", "060570" ], + "060511" : [ "08:31", "350000", "060571" ], + "060512" : [ "08:32", "350000", "060572" ], + "060513" : [ "08:33", "350000", "060573" ], + "060514" : [ "08:34", "350000", "060574" ], + "060515" : [ "08:35", "350000", "060575" ], + "060516" : [ "08:36", "350000", "060576" ], + "060517" : [ "08:37", "350000", "060577" ], + "060518" : [ "08:38", "350000", "060578" ], + "060519" : [ "08:39", "350000", "060579" ], + "060520" : [ "08:40", "350000", "060580" ], + "060521" : [ "08:41", "350000", "060581" ], + "060522" : [ "08:42", "350000", "060582" ], + "060523" : [ "08:43", "350000", "060583" ], + "060524" : [ "08:44", "350000", "060584" ], + "060525" : [ "08:45", "350000", "060585" ], + "060526" : [ "08:46", "350000", "060586" ], + "060527" : [ "08:47", "350000", "060587" ], + "060528" : [ "08:48", "350000", "060588" ], + "060529" : [ "08:49", "350000", "060589" ], + "060530" : [ "08:50", "350000", "060590" ], + "060531" : [ "08:51", "350000", "060591" ], + "060532" : [ "08:52", "350000", "060592" ], + "060533" : [ "08:53", "350000", "060593" ], + "060534" : [ "08:54", "350000", "060594" ], + "060535" : [ "08:55", "350000", "060595" ], + "060536" : [ "08:56", "350000", "060596" ], + "060537" : [ "08:57", "350000", "060597" ], + "060538" : [ "08:58", "350000", "060598" ], + "060539" : [ "08:59", "350000", "060599" ], + "060540" : [ "09:00", "350000", "060600" ], + "060541" : [ "09:01", "350000", "060601" ], + "060542" : [ "09:02", "350000", "060602" ], + "060543" : [ "09:03", "350000", "060603" ], + "060544" : [ "09:04", "350000", "060604" ], + "060545" : [ "09:05", "350000", "060605" ], + "060546" : [ "09:06", "350000", "060606" ], + "060547" : [ "09:07", "350000", "060607" ], + "060548" : [ "09:08", "350000", "060608" ], + "060549" : [ "09:09", "350000", "060609" ], + "060550" : [ "09:10", "350000", "060610" ], + "060551" : [ "09:11", "350000", "060611" ], + "060552" : [ "09:12", "350000", "060612" ], + "060553" : [ "09:13", "350000", "060613" ], + "060554" : [ "09:14", "350000", "060614" ], + "060555" : [ "09:15", "350000", "060615" ], + "060556" : [ "09:16", "350000", "060616" ], + "060557" : [ "09:17", "350000", "060617" ], + "060558" : [ "09:18", "350000", "060618" ], + "060559" : [ "09:19", "350000", "060619" ], + "060560" : [ "09:20", "350000", "060620" ], + "060561" : [ "09:21", "350000", "060621" ], + "060562" : [ "09:22", "350000", "060622" ], + "060563" : [ "09:23", "350000", "060623" ], + "060564" : [ "09:24", "350000", "060624" ], + "060565" : [ "09:25", "350000", "060625" ], + "060566" : [ "09:26", "350000", "060626" ], + "060567" : [ "09:27", "350000", "060627" ], + "060568" : [ "09:28", "350000", "060628" ], + "060569" : [ "09:29", "350000", "060629" ], + "060570" : [ "09:30", "350000", "060630" ], + "060571" : [ "09:31", "350000", "060631" ], + "060572" : [ "09:32", "350000", "060632" ], + "060573" : [ "09:33", "350000", "060633" ], + "060574" : [ "09:34", "350000", "060634" ], + "060575" : [ "09:35", "350000", "060635" ], + "060576" : [ "09:36", "350000", "060636" ], + "060577" : [ "09:37", "350000", "060637" ], + "060578" : [ "09:38", "350000", "060638" ], + "060579" : [ "09:39", "350000", "060639" ], + "060580" : [ "09:40", "350000", "060640" ], + "060581" : [ "09:41", "350000", "060641" ], + "060582" : [ "09:42", "350000", "060642" ], + "060583" : [ "09:43", "350000", "060643" ], + "060584" : [ "09:44", "350000", "060644" ], + "060585" : [ "09:45", "350000", "060645" ], + "060586" : [ "09:46", "350000", "060646" ], + "060587" : [ "09:47", "350000", "060647" ], + "060588" : [ "09:48", "350000", "060648" ], + "060589" : [ "09:49", "350000", "060649" ], + "060590" : [ "09:50", "350000", "060650" ], + "060591" : [ "09:51", "350000", "060651" ], + "060592" : [ "09:52", "350000", "060652" ], + "060593" : [ "09:53", "350000", "060653" ], + "060594" : [ "09:54", "350000", "060654" ], + "060595" : [ "09:55", "350000", "060655" ], + "060596" : [ "09:56", "350000", "060656" ], + "060597" : [ "09:57", "350000", "060657" ], + "060598" : [ "09:58", "350000", "060658" ], + "060599" : [ "09:59", "350000", "060659" ], + "060600" : [ "10:00", "350000", "060660" ], + "060601" : [ "10:01", "350000", "060661" ], + "060602" : [ "10:02", "350000", "060662" ], + "060603" : [ "10:03", "350000", "060663" ], + "060604" : [ "10:04", "350000", "060664" ], + "060605" : [ "10:05", "350000", "060665" ], + "060606" : [ "10:06", "350000", "060666" ], + "060607" : [ "10:07", "350000", "060667" ], + "060608" : [ "10:08", "350000", "060668" ], + "060609" : [ "10:09", "350000", "060669" ], + "060610" : [ "10:10", "350000", "060670" ], + "060611" : [ "10:11", "350000", "060671" ], + "060612" : [ "10:12", "350000", "060672" ], + "060613" : [ "10:13", "350000", "060673" ], + "060614" : [ "10:14", "350000", "060674" ], + "060615" : [ "10:15", "350000", "060675" ], + "060616" : [ "10:16", "350000", "060676" ], + "060617" : [ "10:17", "350000", "060677" ], + "060618" : [ "10:18", "350000", "060678" ], + "060619" : [ "10:19", "350000", "060679" ], + "060620" : [ "10:20", "350000", "060680" ], + "060621" : [ "10:21", "350000", "060681" ], + "060622" : [ "10:22", "350000", "060682" ], + "060623" : [ "10:23", "350000", "060683" ], + "060624" : [ "10:24", "350000", "060684" ], + "060625" : [ "10:25", "350000", "060685" ], + "060626" : [ "10:26", "350000", "060686" ], + "060627" : [ "10:27", "350000", "060687" ], + "060628" : [ "10:28", "350000", "060688" ], + "060629" : [ "10:29", "350000", "060689" ], + "060630" : [ "10:30", "350000", "060690" ], + "060631" : [ "10:31", "350000", "060691" ], + "060632" : [ "10:32", "350000", "060692" ], + "060633" : [ "10:33", "350000", "060693" ], + "060634" : [ "10:34", "350000", "060694" ], + "060635" : [ "10:35", "350000", "060695" ], + "060636" : [ "10:36", "350000", "060696" ], + "060637" : [ "10:37", "350000", "060697" ], + "060638" : [ "10:38", "350000", "060698" ], + "060639" : [ "10:39", "350000", "060699" ], + "060640" : [ "10:40", "350000", "060700" ], + "060641" : [ "10:41", "350000", "060701" ], + "060642" : [ "10:42", "350000", "060702" ], + "060643" : [ "10:43", "350000", "060703" ], + "060644" : [ "10:44", "350000", "060704" ], + "060645" : [ "10:45", "350000", "060705" ], + "060646" : [ "10:46", "350000", "060706" ], + "060647" : [ "10:47", "350000", "060707" ], + "060648" : [ "10:48", "350000", "060708" ], + "060649" : [ "10:49", "350000", "060709" ], + "060650" : [ "10:50", "350000", "060710" ], + "060651" : [ "10:51", "350000", "060711" ], + "060652" : [ "10:52", "350000", "060712" ], + "060653" : [ "10:53", "350000", "060713" ], + "060654" : [ "10:54", "350000", "060714" ], + "060655" : [ "10:55", "350000", "060715" ], + "060656" : [ "10:56", "350000", "060716" ], + "060657" : [ "10:57", "350000", "060717" ], + "060658" : [ "10:58", "350000", "060718" ], + "060659" : [ "10:59", "350000", "060719" ], + "060660" : [ "11:00", "350000", "060720" ], + "060661" : [ "11:01", "350000", "060721" ], + "060662" : [ "11:02", "350000", "060722" ], + "060663" : [ "11:03", "350000", "060723" ], + "060664" : [ "11:04", "350000", "060724" ], + "060665" : [ "11:05", "350000", "060725" ], + "060666" : [ "11:06", "350000", "060726" ], + "060667" : [ "11:07", "350000", "060727" ], + "060668" : [ "11:08", "350000", "060728" ], + "060669" : [ "11:09", "350000", "060729" ], + "060670" : [ "11:10", "350000", "060730" ], + "060671" : [ "11:11", "350000", "060731" ], + "060672" : [ "11:12", "350000", "060732" ], + "060673" : [ "11:13", "350000", "060733" ], + "060674" : [ "11:14", "350000", "060734" ], + "060675" : [ "11:15", "350000", "060735" ], + "060676" : [ "11:16", "350000", "060736" ], + "060677" : [ "11:17", "350000", "060737" ], + "060678" : [ "11:18", "350000", "060738" ], + "060679" : [ "11:19", "350000", "060739" ], + "060680" : [ "11:20", "350000", "060740" ], + "060681" : [ "11:21", "350000", "060741" ], + "060682" : [ "11:22", "350000", "060742" ], + "060683" : [ "11:23", "350000", "060743" ], + "060684" : [ "11:24", "350000", "060744" ], + "060685" : [ "11:25", "350000", "060745" ], + "060686" : [ "11:26", "350000", "060746" ], + "060687" : [ "11:27", "350000", "060747" ], + "060688" : [ "11:28", "350000", "060748" ], + "060689" : [ "11:29", "350000", "060749" ], + "060690" : [ "11:30", "350000", "060750" ], + "060691" : [ "11:31", "350000", "060751" ], + "060692" : [ "11:32", "350000", "060752" ], + "060693" : [ "11:33", "350000", "060753" ], + "060694" : [ "11:34", "350000", "060754" ], + "060695" : [ "11:35", "350000", "060755" ], + "060696" : [ "11:36", "350000", "060756" ], + "060697" : [ "11:37", "350000", "060757" ], + "060698" : [ "11:38", "350000", "060758" ], + "060699" : [ "11:39", "350000", "060759" ], + "060700" : [ "11:40", "350000", "060760" ], + "060701" : [ "11:41", "350000", "060761" ], + "060702" : [ "11:42", "350000", "060762" ], + "060703" : [ "11:43", "350000", "060763" ], + "060704" : [ "11:44", "350000", "060764" ], + "060705" : [ "11:45", "350000", "060765" ], + "060706" : [ "11:46", "350000", "060766" ], + "060707" : [ "11:47", "350000", "060767" ], + "060708" : [ "11:48", "350000", "060768" ], + "060709" : [ "11:49", "350000", "060769" ], + "060710" : [ "11:50", "350000", "060770" ], + "060711" : [ "11:51", "350000", "060771" ], + "060712" : [ "11:52", "350000", "060772" ], + "060713" : [ "11:53", "350000", "060773" ], + "060714" : [ "11:54", "350000", "060774" ], + "060715" : [ "11:55", "350000", "060775" ], + "060716" : [ "11:56", "350000", "060776" ], + "060717" : [ "11:57", "350000", "060777" ], + "060718" : [ "11:58", "350000", "060778" ], + "060719" : [ "11:59", "350000", "060779" ], + "060720" : [ "12:00", "350000", "060780" ], + "060721" : [ "12:01", "350000", "060781" ], + "060722" : [ "12:02", "350000", "060782" ], + "060723" : [ "12:03", "350000", "060783" ], + "060724" : [ "12:04", "350000", "060784" ], + "060725" : [ "12:05", "350000", "060785" ], + "060726" : [ "12:06", "350000", "060786" ], + "060727" : [ "12:07", "350000", "060787" ], + "060728" : [ "12:08", "350000", "060788" ], + "060729" : [ "12:09", "350000", "060789" ], + "060730" : [ "12:10", "350000", "060790" ], + "060731" : [ "12:11", "350000", "060791" ], + "060732" : [ "12:12", "350000", "060792" ], + "060733" : [ "12:13", "350000", "060793" ], + "060734" : [ "12:14", "350000", "060794" ], + "060735" : [ "12:15", "350000", "060795" ], + "060736" : [ "12:16", "350000", "060796" ], + "060737" : [ "12:17", "350000", "060797" ], + "060738" : [ "12:18", "350000", "060798" ], + "060739" : [ "12:19", "350000", "060799" ], + "060740" : [ "12:20", "350000", "060800" ], + "060741" : [ "12:21", "350000", "060801" ], + "060742" : [ "12:22", "350000", "060802" ], + "060743" : [ "12:23", "350000", "060803" ], + "060744" : [ "12:24", "350000", "060804" ], + "060745" : [ "12:25", "350000", "060805" ], + "060746" : [ "12:26", "350000", "060806" ], + "060747" : [ "12:27", "350000", "060807" ], + "060748" : [ "12:28", "350000", "060808" ], + "060749" : [ "12:29", "350000", "060809" ], + "060750" : [ "12:30", "350000", "060810" ], + "060751" : [ "12:31", "350000", "060811" ], + "060752" : [ "12:32", "350000", "060812" ], + "060753" : [ "12:33", "350000", "060813" ], + "060754" : [ "12:34", "350000", "060814" ], + "060755" : [ "12:35", "350000", "060815" ], + "060756" : [ "12:36", "350000", "060816" ], + "060757" : [ "12:37", "350000", "060817" ], + "060758" : [ "12:38", "350000", "060818" ], + "060759" : [ "12:39", "350000", "060819" ], + "060760" : [ "12:40", "350000", "060820" ], + "060761" : [ "12:41", "350000", "060821" ], + "060762" : [ "12:42", "350000", "060822" ], + "060763" : [ "12:43", "350000", "060823" ], + "060764" : [ "12:44", "350000", "060824" ], + "060765" : [ "12:45", "350000", "060825" ], + "060766" : [ "12:46", "350000", "060826" ], + "060767" : [ "12:47", "350000", "060827" ], + "060768" : [ "12:48", "350000", "060828" ], + "060769" : [ "12:49", "350000", "060829" ], + "060770" : [ "12:50", "350000", "060830" ], + "060771" : [ "12:51", "350000", "060831" ], + "060772" : [ "12:52", "350000", "060832" ], + "060773" : [ "12:53", "350000", "060833" ], + "060774" : [ "12:54", "350000", "060834" ], + "060775" : [ "12:55", "350000", "060835" ], + "060776" : [ "12:56", "350000", "060836" ], + "060777" : [ "12:57", "350000", "060837" ], + "060778" : [ "12:58", "350000", "060838" ], + "060779" : [ "12:59", "350000", "060839" ], + "060780" : [ "13:00", "350000", "060840" ], + "060781" : [ "13:01", "350000", "060841" ], + "060782" : [ "13:02", "350000", "060842" ], + "060783" : [ "13:03", "350000", "060843" ], + "060784" : [ "13:04", "350000", "060844" ], + "060785" : [ "13:05", "350000", "060845" ], + "060786" : [ "13:06", "350000", "060846" ], + "060787" : [ "13:07", "350000", "060847" ], + "060788" : [ "13:08", "350000", "060848" ], + "060789" : [ "13:09", "350000", "060849" ], + "060790" : [ "13:10", "350000", "060850" ], + "060791" : [ "13:11", "350000", "060851" ], + "060792" : [ "13:12", "350000", "060852" ], + "060793" : [ "13:13", "350000", "060853" ], + "060794" : [ "13:14", "350000", "060854" ], + "060795" : [ "13:15", "350000", "060855" ], + "060796" : [ "13:16", "350000", "060856" ], + "060797" : [ "13:17", "350000", "060857" ], + "060798" : [ "13:18", "350000", "060858" ], + "060799" : [ "13:19", "350000", "060859" ], + "060800" : [ "13:20", "350000", "060860" ], + "060801" : [ "13:21", "350000", "060861" ], + "060802" : [ "13:22", "350000", "060862" ], + "060803" : [ "13:23", "350000", "060863" ], + "060804" : [ "13:24", "350000", "060864" ], + "060805" : [ "13:25", "350000", "060865" ], + "060806" : [ "13:26", "350000", "060866" ], + "060807" : [ "13:27", "350000", "060867" ], + "060808" : [ "13:28", "350000", "060868" ], + "060809" : [ "13:29", "350000", "060869" ], + "060810" : [ "13:30", "350000", "060870" ], + "060811" : [ "13:31", "350000", "060871" ], + "060812" : [ "13:32", "350000", "060872" ], + "060813" : [ "13:33", "350000", "060873" ], + "060814" : [ "13:34", "350000", "060874" ], + "060815" : [ "13:35", "350000", "060875" ], + "060816" : [ "13:36", "350000", "060876" ], + "060817" : [ "13:37", "350000", "060877" ], + "060818" : [ "13:38", "350000", "060878" ], + "060819" : [ "13:39", "350000", "060879" ], + "060820" : [ "13:40", "350000", "060880" ], + "060821" : [ "13:41", "350000", "060881" ], + "060822" : [ "13:42", "350000", "060882" ], + "060823" : [ "13:43", "350000", "060883" ], + "060824" : [ "13:44", "350000", "060884" ], + "060825" : [ "13:45", "350000", "060885" ], + "060826" : [ "13:46", "350000", "060886" ], + "060827" : [ "13:47", "350000", "060887" ], + "060828" : [ "13:48", "350000", "060888" ], + "060829" : [ "13:49", "350000", "060889" ], + "060830" : [ "13:50", "350000", "060890" ], + "060831" : [ "13:51", "350000", "060891" ], + "060832" : [ "13:52", "350000", "060892" ], + "060833" : [ "13:53", "350000", "060893" ], + "060834" : [ "13:54", "350000", "060894" ], + "060835" : [ "13:55", "350000", "060895" ], + "060836" : [ "13:56", "350000", "060896" ], + "060837" : [ "13:57", "350000", "060897" ], + "060838" : [ "13:58", "350000", "060898" ], + "060839" : [ "13:59", "350000", "060899" ], + "060840" : [ "14:00", "350000", "060900" ], + "060841" : [ "14:01", "350000", "060901" ], + "060842" : [ "14:02", "350000", "060902" ], + "060843" : [ "14:03", "350000", "060903" ], + "060844" : [ "14:04", "350000", "060904" ], + "060845" : [ "14:05", "350000", "060905" ], + "060846" : [ "14:06", "350000", "060906" ], + "060847" : [ "14:07", "350000", "060907" ], + "060848" : [ "14:08", "350000", "060908" ], + "060849" : [ "14:09", "350000", "060909" ], + "060850" : [ "14:10", "350000", "060910" ], + "060851" : [ "14:11", "350000", "060911" ], + "060852" : [ "14:12", "350000", "060912" ], + "060853" : [ "14:13", "350000", "060913" ], + "060854" : [ "14:14", "350000", "060914" ], + "060855" : [ "14:15", "350000", "060915" ], + "060856" : [ "14:16", "350000", "060916" ], + "060857" : [ "14:17", "350000", "060917" ], + "060858" : [ "14:18", "350000", "060918" ], + "060859" : [ "14:19", "350000", "060919" ], + "060860" : [ "14:20", "350000", "060920" ], + "060861" : [ "14:21", "350000", "060921" ], + "060862" : [ "14:22", "350000", "060922" ], + "060863" : [ "14:23", "350000", "060923" ], + "060864" : [ "14:24", "350000", "060924" ], + "060865" : [ "14:25", "350000", "060925" ], + "060866" : [ "14:26", "350000", "060926" ], + "060867" : [ "14:27", "350000", "060927" ], + "060868" : [ "14:28", "350000", "060928" ], + "060869" : [ "14:29", "350000", "060929" ], + "060870" : [ "14:30", "350000", "060930" ], + "060871" : [ "14:31", "350000", "060931" ], + "060872" : [ "14:32", "350000", "060932" ], + "060873" : [ "14:33", "350000", "060933" ], + "060874" : [ "14:34", "350000", "060934" ], + "060875" : [ "14:35", "350000", "060935" ], + "060876" : [ "14:36", "350000", "060936" ], + "060877" : [ "14:37", "350000", "060937" ], + "060878" : [ "14:38", "350000", "060938" ], + "060879" : [ "14:39", "350000", "060939" ], + "060880" : [ "14:40", "350000", "060940" ], + "060881" : [ "14:41", "350000", "060941" ], + "060882" : [ "14:42", "350000", "060942" ], + "060883" : [ "14:43", "350000", "060943" ], + "060884" : [ "14:44", "350000", "060944" ], + "060885" : [ "14:45", "350000", "060945" ], + "060886" : [ "14:46", "350000", "060946" ], + "060887" : [ "14:47", "350000", "060947" ], + "060888" : [ "14:48", "350000", "060948" ], + "060889" : [ "14:49", "350000", "060949" ], + "060890" : [ "14:50", "350000", "060950" ], + "060891" : [ "14:51", "350000", "060951" ], + "060892" : [ "14:52", "350000", "060952" ], + "060893" : [ "14:53", "350000", "060953" ], + "060894" : [ "14:54", "350000", "060954" ], + "060895" : [ "14:55", "350000", "060955" ], + "060896" : [ "14:56", "350000", "060956" ], + "060897" : [ "14:57", "350000", "060957" ], + "060898" : [ "14:58", "350000", "060958" ], + "060899" : [ "14:59", "350000", "060959" ], + "060900" : [ "15:00", "350000", "060960" ], + "060901" : [ "15:01", "350000", "060961" ], + "060902" : [ "15:02", "350000", "060962" ], + "060903" : [ "15:03", "350000", "060963" ], + "060904" : [ "15:04", "350000", "060964" ], + "060905" : [ "15:05", "350000", "060965" ], + "060906" : [ "15:06", "350000", "060966" ], + "060907" : [ "15:07", "350000", "060967" ], + "060908" : [ "15:08", "350000", "060968" ], + "060909" : [ "15:09", "350000", "060969" ], + "060910" : [ "15:10", "350000", "060970" ], + "060911" : [ "15:11", "350000", "060971" ], + "060912" : [ "15:12", "350000", "060972" ], + "060913" : [ "15:13", "350000", "060973" ], + "060914" : [ "15:14", "350000", "060974" ], + "060915" : [ "15:15", "350000", "060975" ], + "060916" : [ "15:16", "350000", "060976" ], + "060917" : [ "15:17", "350000", "060977" ], + "060918" : [ "15:18", "350000", "060978" ], + "060919" : [ "15:19", "350000", "060979" ], + "060920" : [ "15:20", "350000", "060980" ], + "060921" : [ "15:21", "350000", "060981" ], + "060922" : [ "15:22", "350000", "060982" ], + "060923" : [ "15:23", "350000", "060983" ], + "060924" : [ "15:24", "350000", "060984" ], + "060925" : [ "15:25", "350000", "060985" ], + "060926" : [ "15:26", "350000", "060986" ], + "060927" : [ "15:27", "350000", "060987" ], + "060928" : [ "15:28", "350000", "060988" ], + "060929" : [ "15:29", "350000", "060989" ], + "060930" : [ "15:30", "350000", "060990" ], + "060931" : [ "15:31", "350000", "060991" ], + "060932" : [ "15:32", "350000", "060992" ], + "060933" : [ "15:33", "350000", "060993" ], + "060934" : [ "15:34", "350000", "060994" ], + "060935" : [ "15:35", "350000", "060995" ], + "060936" : [ "15:36", "350000", "060996" ], + "060937" : [ "15:37", "350000", "060997" ], + "060938" : [ "15:38", "350000", "060998" ], + "060939" : [ "15:39", "350000", "060999" ], + "060940" : [ "15:40", "350000", "061000" ], + "060941" : [ "15:41", "350000", "061001" ], + "060942" : [ "15:42", "350000", "061002" ], + "060943" : [ "15:43", "350000", "061003" ], + "060944" : [ "15:44", "350000", "061004" ], + "060945" : [ "15:45", "350000", "061005" ], + "060946" : [ "15:46", "350000", "061006" ], + "060947" : [ "15:47", "350000", "061007" ], + "060948" : [ "15:48", "350000", "061008" ], + "060949" : [ "15:49", "350000", "061009" ], + "060950" : [ "15:50", "350000", "061010" ], + "060951" : [ "15:51", "350000", "061011" ], + "060952" : [ "15:52", "350000", "061012" ], + "060953" : [ "15:53", "350000", "061013" ], + "060954" : [ "15:54", "350000", "061014" ], + "060955" : [ "15:55", "350000", "061015" ], + "060956" : [ "15:56", "350000", "061016" ], + "060957" : [ "15:57", "350000", "061017" ], + "060958" : [ "15:58", "350000", "061018" ], + "060959" : [ "15:59", "350000", "061019" ], + "060960" : [ "16:00", "350000", "061020" ], + "060961" : [ "16:01", "350000", "061021" ], + "060962" : [ "16:02", "350000", "061022" ], + "060963" : [ "16:03", "350000", "061023" ], + "060964" : [ "16:04", "350000", "061024" ], + "060965" : [ "16:05", "350000", "061025" ], + "060966" : [ "16:06", "350000", "061026" ], + "060967" : [ "16:07", "350000", "061027" ], + "060968" : [ "16:08", "350000", "061028" ], + "060969" : [ "16:09", "350000", "061029" ], + "060970" : [ "16:10", "350000", "061030" ], + "060971" : [ "16:11", "350000", "061031" ], + "060972" : [ "16:12", "350000", "061032" ], + "060973" : [ "16:13", "350000", "061033" ], + "060974" : [ "16:14", "350000", "061034" ], + "060975" : [ "16:15", "350000", "061035" ], + "060976" : [ "16:16", "350000", "061036" ], + "060977" : [ "16:17", "350000", "061037" ], + "060978" : [ "16:18", "350000", "061038" ], + "060979" : [ "16:19", "350000", "061039" ], + "060980" : [ "16:20", "350000", "061040" ], + "060981" : [ "16:21", "350000", "061041" ], + "060982" : [ "16:22", "350000", "061042" ], + "060983" : [ "16:23", "350000", "061043" ], + "060984" : [ "16:24", "350000", "061044" ], + "060985" : [ "16:25", "350000", "061045" ], + "060986" : [ "16:26", "350000", "061046" ], + "060987" : [ "16:27", "350000", "061047" ], + "060988" : [ "16:28", "350000", "061048" ], + "060989" : [ "16:29", "350000", "061049" ], + "060990" : [ "16:30", "350000", "061050" ], + "060991" : [ "16:31", "350000", "061051" ], + "060992" : [ "16:32", "350000", "061052" ], + "060993" : [ "16:33", "350000", "061053" ], + "060994" : [ "16:34", "350000", "061054" ], + "060995" : [ "16:35", "350000", "061055" ], + "060996" : [ "16:36", "350000", "061056" ], + "060997" : [ "16:37", "350000", "061057" ], + "060998" : [ "16:38", "350000", "061058" ], + "060999" : [ "16:39", "350000", "061059" ], + "061000" : [ "16:40", "350000", "061060" ], + "061001" : [ "16:41", "350000", "061061" ], + "061002" : [ "16:42", "350000", "061062" ], + "061003" : [ "16:43", "350000", "061063" ], + "061004" : [ "16:44", "350000", "061064" ], + "061005" : [ "16:45", "350000", "061065" ], + "061006" : [ "16:46", "350000", "061066" ], + "061007" : [ "16:47", "350000", "061067" ], + "061008" : [ "16:48", "350000", "061068" ], + "061009" : [ "16:49", "350000", "061069" ], + "061010" : [ "16:50", "350000", "061070" ], + "061011" : [ "16:51", "350000", "061071" ], + "061012" : [ "16:52", "350000", "061072" ], + "061013" : [ "16:53", "350000", "061073" ], + "061014" : [ "16:54", "350000", "061074" ], + "061015" : [ "16:55", "350000", "061075" ], + "061016" : [ "16:56", "350000", "061076" ], + "061017" : [ "16:57", "350000", "061077" ], + "061018" : [ "16:58", "350000", "061078" ], + "061019" : [ "16:59", "350000", "061079" ], + "061020" : [ "17:00", "350000", "061080" ], + "061021" : [ "17:01", "350000", "061081" ], + "061022" : [ "17:02", "350000", "061082" ], + "061023" : [ "17:03", "350000", "061083" ], + "061024" : [ "17:04", "350000", "061084" ], + "061025" : [ "17:05", "350000", "061085" ], + "061026" : [ "17:06", "350000", "061086" ], + "061027" : [ "17:07", "350000", "061087" ], + "061028" : [ "17:08", "350000", "061088" ], + "061029" : [ "17:09", "350000", "061089" ], + "061030" : [ "17:10", "350000", "061090" ], + "061031" : [ "17:11", "350000", "061091" ], + "061032" : [ "17:12", "350000", "061092" ], + "061033" : [ "17:13", "350000", "061093" ], + "061034" : [ "17:14", "350000", "061094" ], + "061035" : [ "17:15", "350000", "061095" ], + "061036" : [ "17:16", "350000", "061096" ], + "061037" : [ "17:17", "350000", "061097" ], + "061038" : [ "17:18", "350000", "061098" ], + "061039" : [ "17:19", "350000", "061099" ], + "061040" : [ "17:20", "350000", "061100" ], + "061041" : [ "17:21", "350000", "061101" ], + "061042" : [ "17:22", "350000", "061102" ], + "061043" : [ "17:23", "350000", "061103" ], + "061044" : [ "17:24", "350000", "061104" ], + "061045" : [ "17:25", "350000", "061105" ], + "061046" : [ "17:26", "350000", "061106" ], + "061047" : [ "17:27", "350000", "061107" ], + "061048" : [ "17:28", "350000", "061108" ], + "061049" : [ "17:29", "350000", "061109" ], + "061050" : [ "17:30", "350000", "061110" ], + "061051" : [ "17:31", "350000", "061111" ], + "061052" : [ "17:32", "350000", "061112" ], + "061053" : [ "17:33", "350000", "061113" ], + "061054" : [ "17:34", "350000", "061114" ], + "061055" : [ "17:35", "350000", "061115" ], + "061056" : [ "17:36", "350000", "061116" ], + "061057" : [ "17:37", "350000", "061117" ], + "061058" : [ "17:38", "350000", "061118" ], + "061059" : [ "17:39", "350000", "061119" ], + "061060" : [ "17:40", "350000", "061120" ], + "061061" : [ "17:41", "350000", "061121" ], + "061062" : [ "17:42", "350000", "061122" ], + "061063" : [ "17:43", "350000", "061123" ], + "061064" : [ "17:44", "350000", "061124" ], + "061065" : [ "17:45", "350000", "061125" ], + "061066" : [ "17:46", "350000", "061126" ], + "061067" : [ "17:47", "350000", "061127" ], + "061068" : [ "17:48", "350000", "061128" ], + "061069" : [ "17:49", "350000", "061129" ], + "061070" : [ "17:50", "350000", "061130" ], + "061071" : [ "17:51", "350000", "061131" ], + "061072" : [ "17:52", "350000", "061132" ], + "061073" : [ "17:53", "350000", "061133" ], + "061074" : [ "17:54", "350000", "061134" ], + "061075" : [ "17:55", "350000", "061135" ], + "061076" : [ "17:56", "350000", "061136" ], + "061077" : [ "17:57", "350000", "061137" ], + "061078" : [ "17:58", "350000", "061138" ], + "061079" : [ "17:59", "350000", "061139" ], + "061080" : [ "18:00", "350000", "061140" ], + "061081" : [ "18:01", "350000", "061141" ], + "061082" : [ "18:02", "350000", "061142" ], + "061083" : [ "18:03", "350000", "061143" ], + "061084" : [ "18:04", "350000", "061144" ], + "061085" : [ "18:05", "350000", "061145" ], + "061086" : [ "18:06", "350000", "061146" ], + "061087" : [ "18:07", "350000", "061147" ], + "061088" : [ "18:08", "350000", "061148" ], + "061089" : [ "18:09", "350000", "061149" ], + "061090" : [ "18:10", "350000", "061150" ], + "061091" : [ "18:11", "350000", "061151" ], + "061092" : [ "18:12", "350000", "061152" ], + "061093" : [ "18:13", "350000", "061153" ], + "061094" : [ "18:14", "350000", "061154" ], + "061095" : [ "18:15", "350000", "061155" ], + "061096" : [ "18:16", "350000", "061156" ], + "061097" : [ "18:17", "350000", "061157" ], + "061098" : [ "18:18", "350000", "061158" ], + "061099" : [ "18:19", "350000", "061159" ], + "061100" : [ "18:20", "350000", "061160" ], + "061101" : [ "18:21", "350000", "061161" ], + "061102" : [ "18:22", "350000", "061162" ], + "061103" : [ "18:23", "350000", "061163" ], + "061104" : [ "18:24", "350000", "061164" ], + "061105" : [ "18:25", "350000", "061165" ], + "061106" : [ "18:26", "350000", "061166" ], + "061107" : [ "18:27", "350000", "061167" ], + "061108" : [ "18:28", "350000", "061168" ], + "061109" : [ "18:29", "350000", "061169" ], + "061110" : [ "18:30", "350000", "061170" ], + "061111" : [ "18:31", "350000", "061171" ], + "061112" : [ "18:32", "350000", "061172" ], + "061113" : [ "18:33", "350000", "061173" ], + "061114" : [ "18:34", "350000", "061174" ], + "061115" : [ "18:35", "350000", "061175" ], + "061116" : [ "18:36", "350000", "061176" ], + "061117" : [ "18:37", "350000", "061177" ], + "061118" : [ "18:38", "350000", "061178" ], + "061119" : [ "18:39", "350000", "061179" ], + "061120" : [ "18:40", "350000", "061180" ], + "061121" : [ "18:41", "350000", "061181" ], + "061122" : [ "18:42", "350000", "061182" ], + "061123" : [ "18:43", "350000", "061183" ], + "061124" : [ "18:44", "350000", "061184" ], + "061125" : [ "18:45", "350000", "061185" ], + "061126" : [ "18:46", "350000", "061186" ], + "061127" : [ "18:47", "350000", "061187" ], + "061128" : [ "18:48", "350000", "061188" ], + "061129" : [ "18:49", "350000", "061189" ], + "061130" : [ "18:50", "350000", "061190" ], + "061131" : [ "18:51", "350000", "061191" ], + "061132" : [ "18:52", "350000", "061192" ], + "061133" : [ "18:53", "350000", "061193" ], + "061134" : [ "18:54", "350000", "061194" ], + "061135" : [ "18:55", "350000", "061195" ], + "061136" : [ "18:56", "350000", "061196" ], + "061137" : [ "18:57", "350000", "061197" ], + "061138" : [ "18:58", "350000", "061198" ], + "061139" : [ "18:59", "350000", "061199" ], + "061140" : [ "19:00", "350000", "061200" ], + "061141" : [ "19:01", "350000", "061200" ], + "061142" : [ "19:02", "350000", "061200" ], + "061143" : [ "19:03", "350000", "061200" ], + "061144" : [ "19:04", "350000", "061200" ], + "061145" : [ "19:05", "350000", "061200" ], + "061146" : [ "19:06", "350000", "061200" ], + "061147" : [ "19:07", "350000", "061200" ], + "061148" : [ "19:08", "350000", "061200" ], + "061149" : [ "19:09", "350000", "061200" ], + "061150" : [ "19:10", "350000", "061200" ], + "061151" : [ "19:11", "350000", "061200" ], + "061152" : [ "19:12", "350000", "061200" ], + "061153" : [ "19:13", "350000", "061200" ], + "061154" : [ "19:14", "350000", "061200" ], + "061155" : [ "19:15", "350000", "061200" ], + "061156" : [ "19:16", "350000", "061200" ], + "061157" : [ "19:17", "350000", "061200" ], + "061158" : [ "19:18", "350000", "061200" ], + "061159" : [ "19:19", "350000", "061200" ], + "061160" : [ "19:20", "350000", "061200" ], + "061161" : [ "19:21", "350000", "061200" ], + "061162" : [ "19:22", "350000", "061200" ], + "061163" : [ "19:23", "350000", "061200" ], + "061164" : [ "19:24", "350000", "061200" ], + "061165" : [ "19:25", "350000", "061200" ], + "061166" : [ "19:26", "350000", "061200" ], + "061167" : [ "19:27", "350000", "061200" ], + "061168" : [ "19:28", "350000", "061200" ], + "061169" : [ "19:29", "350000", "061200" ], + "061170" : [ "19:30", "350000", "061200" ], + "061171" : [ "19:31", "350000", "061200" ], + "061172" : [ "19:32", "350000", "061200" ], + "061173" : [ "19:33", "350000", "061200" ], + "061174" : [ "19:34", "350000", "061200" ], + "061175" : [ "19:35", "350000", "061200" ], + "061176" : [ "19:36", "350000", "061200" ], + "061177" : [ "19:37", "350000", "061200" ], + "061178" : [ "19:38", "350000", "061200" ], + "061179" : [ "19:39", "350000", "061200" ], + "061180" : [ "19:40", "350000", "061200" ], + "061181" : [ "19:41", "350000", "061200" ], + "061182" : [ "19:42", "350000", "061200" ], + "061183" : [ "19:43", "350000", "061200" ], + "061184" : [ "19:44", "350000", "061200" ], + "061185" : [ "19:45", "350000", "061200" ], + "061186" : [ "19:46", "350000", "061200" ], + "061187" : [ "19:47", "350000", "061200" ], + "061188" : [ "19:48", "350000", "061200" ], + "061189" : [ "19:49", "350000", "061200" ], + "061190" : [ "19:50", "350000", "061200" ], + "061191" : [ "19:51", "350000", "061200" ], + "061192" : [ "19:52", "350000", "061200" ], + "061193" : [ "19:53", "350000", "061200" ], + "061194" : [ "19:54", "350000", "061200" ], + "061195" : [ "19:55", "350000", "061200" ], + "061196" : [ "19:56", "350000", "061200" ], + "061197" : [ "19:57", "350000", "061200" ], + "061198" : [ "19:58", "350000", "061200" ], + "061199" : [ "19:59", "350000", "061200" ], + "061200" : [ "20:00", "800000", "100420" ], + "061201" : [ "20:01", "800000", "100420" ], + "061202" : [ "20:02", "800000", "100420" ], + "061203" : [ "20:03", "800000", "100420" ], + "061204" : [ "20:04", "800000", "100420" ], + "061205" : [ "20:05", "800000", "100420" ], + "061206" : [ "20:06", "800000", "100420" ], + "061207" : [ "20:07", "800000", "100420" ], + "061208" : [ "20:08", "800000", "100420" ], + "061209" : [ "20:09", "800000", "100420" ], + "061210" : [ "20:10", "800000", "100420" ], + "061211" : [ "20:11", "800000", "100420" ], + "061212" : [ "20:12", "800000", "100420" ], + "061213" : [ "20:13", "800000", "100420" ], + "061214" : [ "20:14", "800000", "100420" ], + "061215" : [ "20:15", "800000", "100420" ], + "061216" : [ "20:16", "800000", "100420" ], + "061217" : [ "20:17", "800000", "100420" ], + "061218" : [ "20:18", "800000", "100420" ], + "061219" : [ "20:19", "800000", "100420" ], + "061220" : [ "20:20", "800000", "100420" ], + "061221" : [ "20:21", "800000", "100420" ], + "061222" : [ "20:22", "800000", "100420" ], + "061223" : [ "20:23", "800000", "100420" ], + "061224" : [ "20:24", "800000", "100420" ], + "061225" : [ "20:25", "800000", "100420" ], + "061226" : [ "20:26", "800000", "100420" ], + "061227" : [ "20:27", "800000", "100420" ], + "061228" : [ "20:28", "800000", "100420" ], + "061229" : [ "20:29", "800000", "100420" ], + "061230" : [ "20:30", "800000", "100420" ], + "061231" : [ "20:31", "800000", "100420" ], + "061232" : [ "20:32", "800000", "100420" ], + "061233" : [ "20:33", "800000", "100420" ], + "061234" : [ "20:34", "800000", "100420" ], + "061235" : [ "20:35", "800000", "100420" ], + "061236" : [ "20:36", "800000", "100420" ], + "061237" : [ "20:37", "800000", "100420" ], + "061238" : [ "20:38", "800000", "100420" ], + "061239" : [ "20:39", "800000", "100420" ], + "061240" : [ "20:40", "800000", "100420" ], + "061241" : [ "20:41", "800000", "100420" ], + "061242" : [ "20:42", "800000", "100420" ], + "061243" : [ "20:43", "800000", "100420" ], + "061244" : [ "20:44", "800000", "100420" ], + "061245" : [ "20:45", "800000", "100420" ], + "061246" : [ "20:46", "800000", "100420" ], + "061247" : [ "20:47", "800000", "100420" ], + "061248" : [ "20:48", "800000", "100420" ], + "061249" : [ "20:49", "800000", "100420" ], + "061250" : [ "20:50", "800000", "100420" ], + "061251" : [ "20:51", "800000", "100420" ], + "061252" : [ "20:52", "800000", "100420" ], + "061253" : [ "20:53", "800000", "100420" ], + "061254" : [ "20:54", "800000", "100420" ], + "061255" : [ "20:55", "800000", "100420" ], + "061256" : [ "20:56", "800000", "100420" ], + "061257" : [ "20:57", "800000", "100420" ], + "061258" : [ "20:58", "800000", "100420" ], + "061259" : [ "20:59", "800000", "100420" ], + "061260" : [ "21:00", "800000", "100420" ], + "061261" : [ "21:01", "800000", "100420" ], + "061262" : [ "21:02", "800000", "100420" ], + "061263" : [ "21:03", "800000", "100420" ], + "061264" : [ "21:04", "800000", "100420" ], + "061265" : [ "21:05", "800000", "100420" ], + "061266" : [ "21:06", "800000", "100420" ], + "061267" : [ "21:07", "800000", "100420" ], + "061268" : [ "21:08", "800000", "100420" ], + "061269" : [ "21:09", "800000", "100420" ], + "061270" : [ "21:10", "800000", "100420" ], + "061271" : [ "21:11", "800000", "100420" ], + "061272" : [ "21:12", "800000", "100420" ], + "061273" : [ "21:13", "800000", "100420" ], + "061274" : [ "21:14", "800000", "100420" ], + "061275" : [ "21:15", "800000", "100420" ], + "061276" : [ "21:16", "800000", "100420" ], + "061277" : [ "21:17", "800000", "100420" ], + "061278" : [ "21:18", "800000", "100420" ], + "061279" : [ "21:19", "800000", "100420" ], + "061280" : [ "21:20", "800000", "100420" ], + "061281" : [ "21:21", "800000", "100420" ], + "061282" : [ "21:22", "800000", "100420" ], + "061283" : [ "21:23", "800000", "100420" ], + "061284" : [ "21:24", "800000", "100420" ], + "061285" : [ "21:25", "800000", "100420" ], + "061286" : [ "21:26", "800000", "100420" ], + "061287" : [ "21:27", "800000", "100420" ], + "061288" : [ "21:28", "800000", "100420" ], + "061289" : [ "21:29", "800000", "100420" ], + "061290" : [ "21:30", "800000", "100420" ], + "061291" : [ "21:31", "800000", "100420" ], + "061292" : [ "21:32", "800000", "100420" ], + "061293" : [ "21:33", "800000", "100420" ], + "061294" : [ "21:34", "800000", "100420" ], + "061295" : [ "21:35", "800000", "100420" ], + "061296" : [ "21:36", "800000", "100420" ], + "061297" : [ "21:37", "800000", "100420" ], + "061298" : [ "21:38", "800000", "100420" ], + "061299" : [ "21:39", "800000", "100420" ], + "061300" : [ "21:40", "800000", "100420" ], + "061301" : [ "21:41", "800000", "100420" ], + "061302" : [ "21:42", "800000", "100420" ], + "061303" : [ "21:43", "800000", "100420" ], + "061304" : [ "21:44", "800000", "100420" ], + "061305" : [ "21:45", "800000", "100420" ], + "061306" : [ "21:46", "800000", "100420" ], + "061307" : [ "21:47", "800000", "100420" ], + "061308" : [ "21:48", "800000", "100420" ], + "061309" : [ "21:49", "800000", "100420" ], + "061310" : [ "21:50", "800000", "100420" ], + "061311" : [ "21:51", "800000", "100420" ], + "061312" : [ "21:52", "800000", "100420" ], + "061313" : [ "21:53", "800000", "100420" ], + "061314" : [ "21:54", "800000", "100420" ], + "061315" : [ "21:55", "800000", "100420" ], + "061316" : [ "21:56", "800000", "100420" ], + "061317" : [ "21:57", "800000", "100420" ], + "061318" : [ "21:58", "800000", "100420" ], + "061319" : [ "21:59", "800000", "100420" ], + "061320" : [ "22:00", "800000", "100420" ], + "061321" : [ "22:01", "800000", "100420" ], + "061322" : [ "22:02", "800000", "100420" ], + "061323" : [ "22:03", "800000", "100420" ], + "061324" : [ "22:04", "800000", "100420" ], + "061325" : [ "22:05", "800000", "100420" ], + "061326" : [ "22:06", "800000", "100420" ], + "061327" : [ "22:07", "800000", "100420" ], + "061328" : [ "22:08", "800000", "100420" ], + "061329" : [ "22:09", "800000", "100420" ], + "061330" : [ "22:10", "800000", "100420" ], + "061331" : [ "22:11", "800000", "100420" ], + "061332" : [ "22:12", "800000", "100420" ], + "061333" : [ "22:13", "800000", "100420" ], + "061334" : [ "22:14", "800000", "100420" ], + "061335" : [ "22:15", "800000", "100420" ], + "061336" : [ "22:16", "800000", "100420" ], + "061337" : [ "22:17", "800000", "100420" ], + "061338" : [ "22:18", "800000", "100420" ], + "061339" : [ "22:19", "800000", "100420" ], + "061340" : [ "22:20", "800000", "100420" ], + "061341" : [ "22:21", "800000", "100420" ], + "061342" : [ "22:22", "800000", "100420" ], + "061343" : [ "22:23", "800000", "100420" ], + "061344" : [ "22:24", "800000", "100420" ], + "061345" : [ "22:25", "800000", "100420" ], + "061346" : [ "22:26", "800000", "100420" ], + "061347" : [ "22:27", "800000", "100420" ], + "061348" : [ "22:28", "800000", "100420" ], + "061349" : [ "22:29", "800000", "100420" ], + "061350" : [ "22:30", "800000", "100420" ], + "061351" : [ "22:31", "800000", "100420" ], + "061352" : [ "22:32", "800000", "100420" ], + "061353" : [ "22:33", "800000", "100420" ], + "061354" : [ "22:34", "800000", "100420" ], + "061355" : [ "22:35", "800000", "100420" ], + "061356" : [ "22:36", "800000", "100420" ], + "061357" : [ "22:37", "800000", "100420" ], + "061358" : [ "22:38", "800000", "100420" ], + "061359" : [ "22:39", "800000", "100420" ], + "061360" : [ "22:40", "800000", "100420" ], + "061361" : [ "22:41", "800000", "100420" ], + "061362" : [ "22:42", "800000", "100420" ], + "061363" : [ "22:43", "800000", "100420" ], + "061364" : [ "22:44", "800000", "100420" ], + "061365" : [ "22:45", "800000", "100420" ], + "061366" : [ "22:46", "800000", "100420" ], + "061367" : [ "22:47", "800000", "100420" ], + "061368" : [ "22:48", "800000", "100420" ], + "061369" : [ "22:49", "800000", "100420" ], + "061370" : [ "22:50", "800000", "100420" ], + "061371" : [ "22:51", "800000", "100420" ], + "061372" : [ "22:52", "800000", "100420" ], + "061373" : [ "22:53", "800000", "100420" ], + "061374" : [ "22:54", "800000", "100420" ], + "061375" : [ "22:55", "800000", "100420" ], + "061376" : [ "22:56", "800000", "100420" ], + "061377" : [ "22:57", "800000", "100420" ], + "061378" : [ "22:58", "800000", "100420" ], + "061379" : [ "22:59", "800000", "100420" ], + "061380" : [ "23:00", "800000", "100420" ], + "061381" : [ "23:01", "800000", "100420" ], + "061382" : [ "23:02", "800000", "100420" ], + "061383" : [ "23:03", "800000", "100420" ], + "061384" : [ "23:04", "800000", "100420" ], + "061385" : [ "23:05", "800000", "100420" ], + "061386" : [ "23:06", "800000", "100420" ], + "061387" : [ "23:07", "800000", "100420" ], + "061388" : [ "23:08", "800000", "100420" ], + "061389" : [ "23:09", "800000", "100420" ], + "061390" : [ "23:10", "800000", "100420" ], + "061391" : [ "23:11", "800000", "100420" ], + "061392" : [ "23:12", "800000", "100420" ], + "061393" : [ "23:13", "800000", "100420" ], + "061394" : [ "23:14", "800000", "100420" ], + "061395" : [ "23:15", "800000", "100420" ], + "061396" : [ "23:16", "800000", "100420" ], + "061397" : [ "23:17", "800000", "100420" ], + "061398" : [ "23:18", "800000", "100420" ], + "061399" : [ "23:19", "800000", "100420" ], + "061400" : [ "23:20", "800000", "100420" ], + "061401" : [ "23:21", "800000", "100420" ], + "061402" : [ "23:22", "800000", "100420" ], + "061403" : [ "23:23", "800000", "100420" ], + "061404" : [ "23:24", "800000", "100420" ], + "061405" : [ "23:25", "800000", "100420" ], + "061406" : [ "23:26", "800000", "100420" ], + "061407" : [ "23:27", "800000", "100420" ], + "061408" : [ "23:28", "800000", "100420" ], + "061409" : [ "23:29", "800000", "100420" ], + "061410" : [ "23:30", "800000", "100420" ], + "061411" : [ "23:31", "800000", "100420" ], + "061412" : [ "23:32", "800000", "100420" ], + "061413" : [ "23:33", "800000", "100420" ], + "061414" : [ "23:34", "800000", "100420" ], + "061415" : [ "23:35", "800000", "100420" ], + "061416" : [ "23:36", "800000", "100420" ], + "061417" : [ "23:37", "800000", "100420" ], + "061418" : [ "23:38", "800000", "100420" ], + "061419" : [ "23:39", "800000", "100420" ], + "061420" : [ "23:40", "800000", "100420" ], + "061421" : [ "23:41", "800000", "100420" ], + "061422" : [ "23:42", "800000", "100420" ], + "061423" : [ "23:43", "800000", "100420" ], + "061424" : [ "23:44", "800000", "100420" ], + "061425" : [ "23:45", "800000", "100420" ], + "061426" : [ "23:46", "800000", "100420" ], + "061427" : [ "23:47", "800000", "100420" ], + "061428" : [ "23:48", "800000", "100420" ], + "061429" : [ "23:49", "800000", "100420" ], + "061430" : [ "23:50", "800000", "100420" ], + "061431" : [ "23:51", "800000", "100420" ], + "061432" : [ "23:52", "800000", "100420" ], + "061433" : [ "23:53", "800000", "100420" ], + "061434" : [ "23:54", "800000", "100420" ], + "061435" : [ "23:55", "800000", "100420" ], + "061436" : [ "23:56", "800000", "100420" ], + "061437" : [ "23:57", "800000", "100420" ], + "061438" : [ "23:58", "800000", "100420" ], + "061439" : [ "23:59", "800000", "100420" ] + } + }, + "week2" : { + "Monday": { + "100000" : [ "00:00", "800000", "100420" ], + "100001" : [ "00:01", "800000", "100420" ], + "100002" : [ "00:02", "800000", "100420" ], + "100003" : [ "00:03", "800000", "100420" ], + "100004" : [ "00:04", "800000", "100420" ], + "100005" : [ "00:05", "800000", "100420" ], + "100006" : [ "00:06", "800000", "100420" ], + "100007" : [ "00:07", "800000", "100420" ], + "100008" : [ "00:08", "800000", "100420" ], + "100009" : [ "00:09", "800000", "100420" ], + "100010" : [ "00:10", "800000", "100420" ], + "100011" : [ "00:11", "800000", "100420" ], + "100012" : [ "00:12", "800000", "100420" ], + "100013" : [ "00:13", "800000", "100420" ], + "100014" : [ "00:14", "800000", "100420" ], + "100015" : [ "00:15", "800000", "100420" ], + "100016" : [ "00:16", "800000", "100420" ], + "100017" : [ "00:17", "800000", "100420" ], + "100018" : [ "00:18", "800000", "100420" ], + "100019" : [ "00:19", "800000", "100420" ], + "100020" : [ "00:20", "800000", "100420" ], + "100021" : [ "00:21", "800000", "100420" ], + "100022" : [ "00:22", "800000", "100420" ], + "100023" : [ "00:23", "800000", "100420" ], + "100024" : [ "00:24", "800000", "100420" ], + "100025" : [ "00:25", "800000", "100420" ], + "100026" : [ "00:26", "800000", "100420" ], + "100027" : [ "00:27", "800000", "100420" ], + "100028" : [ "00:28", "800000", "100420" ], + "100029" : [ "00:29", "800000", "100420" ], + "100030" : [ "00:30", "800000", "100420" ], + "100031" : [ "00:31", "800000", "100420" ], + "100032" : [ "00:32", "800000", "100420" ], + "100033" : [ "00:33", "800000", "100420" ], + "100034" : [ "00:34", "800000", "100420" ], + "100035" : [ "00:35", "800000", "100420" ], + "100036" : [ "00:36", "800000", "100420" ], + "100037" : [ "00:37", "800000", "100420" ], + "100038" : [ "00:38", "800000", "100420" ], + "100039" : [ "00:39", "800000", "100420" ], + "100040" : [ "00:40", "800000", "100420" ], + "100041" : [ "00:41", "800000", "100420" ], + "100042" : [ "00:42", "800000", "100420" ], + "100043" : [ "00:43", "800000", "100420" ], + "100044" : [ "00:44", "800000", "100420" ], + "100045" : [ "00:45", "800000", "100420" ], + "100046" : [ "00:46", "800000", "100420" ], + "100047" : [ "00:47", "800000", "100420" ], + "100048" : [ "00:48", "800000", "100420" ], + "100049" : [ "00:49", "800000", "100420" ], + "100050" : [ "00:50", "800000", "100420" ], + "100051" : [ "00:51", "800000", "100420" ], + "100052" : [ "00:52", "800000", "100420" ], + "100053" : [ "00:53", "800000", "100420" ], + "100054" : [ "00:54", "800000", "100420" ], + "100055" : [ "00:55", "800000", "100420" ], + "100056" : [ "00:56", "800000", "100420" ], + "100057" : [ "00:57", "800000", "100420" ], + "100058" : [ "00:58", "800000", "100420" ], + "100059" : [ "00:59", "800000", "100420" ], + "100060" : [ "01:00", "800000", "100420" ], + "100061" : [ "01:01", "800000", "100420" ], + "100062" : [ "01:02", "800000", "100420" ], + "100063" : [ "01:03", "800000", "100420" ], + "100064" : [ "01:04", "800000", "100420" ], + "100065" : [ "01:05", "800000", "100420" ], + "100066" : [ "01:06", "800000", "100420" ], + "100067" : [ "01:07", "800000", "100420" ], + "100068" : [ "01:08", "800000", "100420" ], + "100069" : [ "01:09", "800000", "100420" ], + "100070" : [ "01:10", "800000", "100420" ], + "100071" : [ "01:11", "800000", "100420" ], + "100072" : [ "01:12", "800000", "100420" ], + "100073" : [ "01:13", "800000", "100420" ], + "100074" : [ "01:14", "800000", "100420" ], + "100075" : [ "01:15", "800000", "100420" ], + "100076" : [ "01:16", "800000", "100420" ], + "100077" : [ "01:17", "800000", "100420" ], + "100078" : [ "01:18", "800000", "100420" ], + "100079" : [ "01:19", "800000", "100420" ], + "100080" : [ "01:20", "800000", "100420" ], + "100081" : [ "01:21", "800000", "100420" ], + "100082" : [ "01:22", "800000", "100420" ], + "100083" : [ "01:23", "800000", "100420" ], + "100084" : [ "01:24", "800000", "100420" ], + "100085" : [ "01:25", "800000", "100420" ], + "100086" : [ "01:26", "800000", "100420" ], + "100087" : [ "01:27", "800000", "100420" ], + "100088" : [ "01:28", "800000", "100420" ], + "100089" : [ "01:29", "800000", "100420" ], + "100090" : [ "01:30", "800000", "100420" ], + "100091" : [ "01:31", "800000", "100420" ], + "100092" : [ "01:32", "800000", "100420" ], + "100093" : [ "01:33", "800000", "100420" ], + "100094" : [ "01:34", "800000", "100420" ], + "100095" : [ "01:35", "800000", "100420" ], + "100096" : [ "01:36", "800000", "100420" ], + "100097" : [ "01:37", "800000", "100420" ], + "100098" : [ "01:38", "800000", "100420" ], + "100099" : [ "01:39", "800000", "100420" ], + "100100" : [ "01:40", "800000", "100420" ], + "100101" : [ "01:41", "800000", "100420" ], + "100102" : [ "01:42", "800000", "100420" ], + "100103" : [ "01:43", "800000", "100420" ], + "100104" : [ "01:44", "800000", "100420" ], + "100105" : [ "01:45", "800000", "100420" ], + "100106" : [ "01:46", "800000", "100420" ], + "100107" : [ "01:47", "800000", "100420" ], + "100108" : [ "01:48", "800000", "100420" ], + "100109" : [ "01:49", "800000", "100420" ], + "100110" : [ "01:50", "800000", "100420" ], + "100111" : [ "01:51", "800000", "100420" ], + "100112" : [ "01:52", "800000", "100420" ], + "100113" : [ "01:53", "800000", "100420" ], + "100114" : [ "01:54", "800000", "100420" ], + "100115" : [ "01:55", "800000", "100420" ], + "100116" : [ "01:56", "800000", "100420" ], + "100117" : [ "01:57", "800000", "100420" ], + "100118" : [ "01:58", "800000", "100420" ], + "100119" : [ "01:59", "800000", "100420" ], + "100120" : [ "02:00", "800000", "100420" ], + "100121" : [ "02:01", "800000", "100420" ], + "100122" : [ "02:02", "800000", "100420" ], + "100123" : [ "02:03", "800000", "100420" ], + "100124" : [ "02:04", "800000", "100420" ], + "100125" : [ "02:05", "800000", "100420" ], + "100126" : [ "02:06", "800000", "100420" ], + "100127" : [ "02:07", "800000", "100420" ], + "100128" : [ "02:08", "800000", "100420" ], + "100129" : [ "02:09", "800000", "100420" ], + "100130" : [ "02:10", "800000", "100420" ], + "100131" : [ "02:11", "800000", "100420" ], + "100132" : [ "02:12", "800000", "100420" ], + "100133" : [ "02:13", "800000", "100420" ], + "100134" : [ "02:14", "800000", "100420" ], + "100135" : [ "02:15", "800000", "100420" ], + "100136" : [ "02:16", "800000", "100420" ], + "100137" : [ "02:17", "800000", "100420" ], + "100138" : [ "02:18", "800000", "100420" ], + "100139" : [ "02:19", "800000", "100420" ], + "100140" : [ "02:20", "800000", "100420" ], + "100141" : [ "02:21", "800000", "100420" ], + "100142" : [ "02:22", "800000", "100420" ], + "100143" : [ "02:23", "800000", "100420" ], + "100144" : [ "02:24", "800000", "100420" ], + "100145" : [ "02:25", "800000", "100420" ], + "100146" : [ "02:26", "800000", "100420" ], + "100147" : [ "02:27", "800000", "100420" ], + "100148" : [ "02:28", "800000", "100420" ], + "100149" : [ "02:29", "800000", "100420" ], + "100150" : [ "02:30", "800000", "100420" ], + "100151" : [ "02:31", "800000", "100420" ], + "100152" : [ "02:32", "800000", "100420" ], + "100153" : [ "02:33", "800000", "100420" ], + "100154" : [ "02:34", "800000", "100420" ], + "100155" : [ "02:35", "800000", "100420" ], + "100156" : [ "02:36", "800000", "100420" ], + "100157" : [ "02:37", "800000", "100420" ], + "100158" : [ "02:38", "800000", "100420" ], + "100159" : [ "02:39", "800000", "100420" ], + "100160" : [ "02:40", "800000", "100420" ], + "100161" : [ "02:41", "800000", "100420" ], + "100162" : [ "02:42", "800000", "100420" ], + "100163" : [ "02:43", "800000", "100420" ], + "100164" : [ "02:44", "800000", "100420" ], + "100165" : [ "02:45", "800000", "100420" ], + "100166" : [ "02:46", "800000", "100420" ], + "100167" : [ "02:47", "800000", "100420" ], + "100168" : [ "02:48", "800000", "100420" ], + "100169" : [ "02:49", "800000", "100420" ], + "100170" : [ "02:50", "800000", "100420" ], + "100171" : [ "02:51", "800000", "100420" ], + "100172" : [ "02:52", "800000", "100420" ], + "100173" : [ "02:53", "800000", "100420" ], + "100174" : [ "02:54", "800000", "100420" ], + "100175" : [ "02:55", "800000", "100420" ], + "100176" : [ "02:56", "800000", "100420" ], + "100177" : [ "02:57", "800000", "100420" ], + "100178" : [ "02:58", "800000", "100420" ], + "100179" : [ "02:59", "800000", "100420" ], + "100180" : [ "03:00", "800000", "100420" ], + "100181" : [ "03:01", "800000", "100420" ], + "100182" : [ "03:02", "800000", "100420" ], + "100183" : [ "03:03", "800000", "100420" ], + "100184" : [ "03:04", "800000", "100420" ], + "100185" : [ "03:05", "800000", "100420" ], + "100186" : [ "03:06", "800000", "100420" ], + "100187" : [ "03:07", "800000", "100420" ], + "100188" : [ "03:08", "800000", "100420" ], + "100189" : [ "03:09", "800000", "100420" ], + "100190" : [ "03:10", "800000", "100420" ], + "100191" : [ "03:11", "800000", "100420" ], + "100192" : [ "03:12", "800000", "100420" ], + "100193" : [ "03:13", "800000", "100420" ], + "100194" : [ "03:14", "800000", "100420" ], + "100195" : [ "03:15", "800000", "100420" ], + "100196" : [ "03:16", "800000", "100420" ], + "100197" : [ "03:17", "800000", "100420" ], + "100198" : [ "03:18", "800000", "100420" ], + "100199" : [ "03:19", "800000", "100420" ], + "100200" : [ "03:20", "800000", "100420" ], + "100201" : [ "03:21", "800000", "100420" ], + "100202" : [ "03:22", "800000", "100420" ], + "100203" : [ "03:23", "800000", "100420" ], + "100204" : [ "03:24", "800000", "100420" ], + "100205" : [ "03:25", "800000", "100420" ], + "100206" : [ "03:26", "800000", "100420" ], + "100207" : [ "03:27", "800000", "100420" ], + "100208" : [ "03:28", "800000", "100420" ], + "100209" : [ "03:29", "800000", "100420" ], + "100210" : [ "03:30", "800000", "100420" ], + "100211" : [ "03:31", "800000", "100420" ], + "100212" : [ "03:32", "800000", "100420" ], + "100213" : [ "03:33", "800000", "100420" ], + "100214" : [ "03:34", "800000", "100420" ], + "100215" : [ "03:35", "800000", "100420" ], + "100216" : [ "03:36", "800000", "100420" ], + "100217" : [ "03:37", "800000", "100420" ], + "100218" : [ "03:38", "800000", "100420" ], + "100219" : [ "03:39", "800000", "100420" ], + "100220" : [ "03:40", "800000", "100420" ], + "100221" : [ "03:41", "800000", "100420" ], + "100222" : [ "03:42", "800000", "100420" ], + "100223" : [ "03:43", "800000", "100420" ], + "100224" : [ "03:44", "800000", "100420" ], + "100225" : [ "03:45", "800000", "100420" ], + "100226" : [ "03:46", "800000", "100420" ], + "100227" : [ "03:47", "800000", "100420" ], + "100228" : [ "03:48", "800000", "100420" ], + "100229" : [ "03:49", "800000", "100420" ], + "100230" : [ "03:50", "800000", "100420" ], + "100231" : [ "03:51", "800000", "100420" ], + "100232" : [ "03:52", "800000", "100420" ], + "100233" : [ "03:53", "800000", "100420" ], + "100234" : [ "03:54", "800000", "100420" ], + "100235" : [ "03:55", "800000", "100420" ], + "100236" : [ "03:56", "800000", "100420" ], + "100237" : [ "03:57", "800000", "100420" ], + "100238" : [ "03:58", "800000", "100420" ], + "100239" : [ "03:59", "800000", "100420" ], + "100240" : [ "04:00", "800000", "100420" ], + "100241" : [ "04:01", "800000", "100420" ], + "100242" : [ "04:02", "800000", "100420" ], + "100243" : [ "04:03", "800000", "100420" ], + "100244" : [ "04:04", "800000", "100420" ], + "100245" : [ "04:05", "800000", "100420" ], + "100246" : [ "04:06", "800000", "100420" ], + "100247" : [ "04:07", "800000", "100420" ], + "100248" : [ "04:08", "800000", "100420" ], + "100249" : [ "04:09", "800000", "100420" ], + "100250" : [ "04:10", "800000", "100420" ], + "100251" : [ "04:11", "800000", "100420" ], + "100252" : [ "04:12", "800000", "100420" ], + "100253" : [ "04:13", "800000", "100420" ], + "100254" : [ "04:14", "800000", "100420" ], + "100255" : [ "04:15", "800000", "100420" ], + "100256" : [ "04:16", "800000", "100420" ], + "100257" : [ "04:17", "800000", "100420" ], + "100258" : [ "04:18", "800000", "100420" ], + "100259" : [ "04:19", "800000", "100420" ], + "100260" : [ "04:20", "800000", "100420" ], + "100261" : [ "04:21", "800000", "100420" ], + "100262" : [ "04:22", "800000", "100420" ], + "100263" : [ "04:23", "800000", "100420" ], + "100264" : [ "04:24", "800000", "100420" ], + "100265" : [ "04:25", "800000", "100420" ], + "100266" : [ "04:26", "800000", "100420" ], + "100267" : [ "04:27", "800000", "100420" ], + "100268" : [ "04:28", "800000", "100420" ], + "100269" : [ "04:29", "800000", "100420" ], + "100270" : [ "04:30", "800000", "100420" ], + "100271" : [ "04:31", "800000", "100420" ], + "100272" : [ "04:32", "800000", "100420" ], + "100273" : [ "04:33", "800000", "100420" ], + "100274" : [ "04:34", "800000", "100420" ], + "100275" : [ "04:35", "800000", "100420" ], + "100276" : [ "04:36", "800000", "100420" ], + "100277" : [ "04:37", "800000", "100420" ], + "100278" : [ "04:38", "800000", "100420" ], + "100279" : [ "04:39", "800000", "100420" ], + "100280" : [ "04:40", "800000", "100420" ], + "100281" : [ "04:41", "800000", "100420" ], + "100282" : [ "04:42", "800000", "100420" ], + "100283" : [ "04:43", "800000", "100420" ], + "100284" : [ "04:44", "800000", "100420" ], + "100285" : [ "04:45", "800000", "100420" ], + "100286" : [ "04:46", "800000", "100420" ], + "100287" : [ "04:47", "800000", "100420" ], + "100288" : [ "04:48", "800000", "100420" ], + "100289" : [ "04:49", "800000", "100420" ], + "100290" : [ "04:50", "800000", "100420" ], + "100291" : [ "04:51", "800000", "100420" ], + "100292" : [ "04:52", "800000", "100420" ], + "100293" : [ "04:53", "800000", "100420" ], + "100294" : [ "04:54", "800000", "100420" ], + "100295" : [ "04:55", "800000", "100420" ], + "100296" : [ "04:56", "800000", "100420" ], + "100297" : [ "04:57", "800000", "100420" ], + "100298" : [ "04:58", "800000", "100420" ], + "100299" : [ "04:59", "800000", "100420" ], + "100300" : [ "05:00", "800000", "100420" ], + "100301" : [ "05:01", "800000", "100420" ], + "100302" : [ "05:02", "800000", "100420" ], + "100303" : [ "05:03", "800000", "100420" ], + "100304" : [ "05:04", "800000", "100420" ], + "100305" : [ "05:05", "800000", "100420" ], + "100306" : [ "05:06", "800000", "100420" ], + "100307" : [ "05:07", "800000", "100420" ], + "100308" : [ "05:08", "800000", "100420" ], + "100309" : [ "05:09", "800000", "100420" ], + "100310" : [ "05:10", "800000", "100420" ], + "100311" : [ "05:11", "800000", "100420" ], + "100312" : [ "05:12", "800000", "100420" ], + "100313" : [ "05:13", "800000", "100420" ], + "100314" : [ "05:14", "800000", "100420" ], + "100315" : [ "05:15", "800000", "100420" ], + "100316" : [ "05:16", "800000", "100420" ], + "100317" : [ "05:17", "800000", "100420" ], + "100318" : [ "05:18", "800000", "100420" ], + "100319" : [ "05:19", "800000", "100420" ], + "100320" : [ "05:20", "800000", "100420" ], + "100321" : [ "05:21", "800000", "100420" ], + "100322" : [ "05:22", "800000", "100420" ], + "100323" : [ "05:23", "800000", "100420" ], + "100324" : [ "05:24", "800000", "100420" ], + "100325" : [ "05:25", "800000", "100420" ], + "100326" : [ "05:26", "800000", "100420" ], + "100327" : [ "05:27", "800000", "100420" ], + "100328" : [ "05:28", "800000", "100420" ], + "100329" : [ "05:29", "800000", "100420" ], + "100330" : [ "05:30", "800000", "100420" ], + "100331" : [ "05:31", "800000", "100420" ], + "100332" : [ "05:32", "800000", "100420" ], + "100333" : [ "05:33", "800000", "100420" ], + "100334" : [ "05:34", "800000", "100420" ], + "100335" : [ "05:35", "800000", "100420" ], + "100336" : [ "05:36", "800000", "100420" ], + "100337" : [ "05:37", "800000", "100420" ], + "100338" : [ "05:38", "800000", "100420" ], + "100339" : [ "05:39", "800000", "100420" ], + "100340" : [ "05:40", "800000", "100420" ], + "100341" : [ "05:41", "800000", "100420" ], + "100342" : [ "05:42", "800000", "100420" ], + "100343" : [ "05:43", "800000", "100420" ], + "100344" : [ "05:44", "800000", "100420" ], + "100345" : [ "05:45", "800000", "100420" ], + "100346" : [ "05:46", "800000", "100420" ], + "100347" : [ "05:47", "800000", "100420" ], + "100348" : [ "05:48", "800000", "100420" ], + "100349" : [ "05:49", "800000", "100420" ], + "100350" : [ "05:50", "800000", "100420" ], + "100351" : [ "05:51", "800000", "100420" ], + "100352" : [ "05:52", "800000", "100420" ], + "100353" : [ "05:53", "800000", "100420" ], + "100354" : [ "05:54", "800000", "100420" ], + "100355" : [ "05:55", "800000", "100420" ], + "100356" : [ "05:56", "800000", "100420" ], + "100357" : [ "05:57", "800000", "100420" ], + "100358" : [ "05:58", "800000", "100420" ], + "100359" : [ "05:59", "800000", "100420" ], + "100360" : [ "06:00", "800000", "100420" ], + "100361" : [ "06:01", "800000", "100420" ], + "100362" : [ "06:02", "800000", "100420" ], + "100363" : [ "06:03", "800000", "100420" ], + "100364" : [ "06:04", "800000", "100420" ], + "100365" : [ "06:05", "800000", "100420" ], + "100366" : [ "06:06", "800000", "100420" ], + "100367" : [ "06:07", "800000", "100420" ], + "100368" : [ "06:08", "800000", "100420" ], + "100369" : [ "06:09", "800000", "100420" ], + "100370" : [ "06:10", "800000", "100420" ], + "100371" : [ "06:11", "800000", "100420" ], + "100372" : [ "06:12", "800000", "100420" ], + "100373" : [ "06:13", "800000", "100420" ], + "100374" : [ "06:14", "800000", "100420" ], + "100375" : [ "06:15", "800000", "100420" ], + "100376" : [ "06:16", "800000", "100420" ], + "100377" : [ "06:17", "800000", "100420" ], + "100378" : [ "06:18", "800000", "100420" ], + "100379" : [ "06:19", "800000", "100420" ], + "100380" : [ "06:20", "800000", "100420" ], + "100381" : [ "06:21", "800000", "100420" ], + "100382" : [ "06:22", "800000", "100420" ], + "100383" : [ "06:23", "800000", "100420" ], + "100384" : [ "06:24", "800000", "100420" ], + "100385" : [ "06:25", "800000", "100420" ], + "100386" : [ "06:26", "800000", "100420" ], + "100387" : [ "06:27", "800000", "100420" ], + "100388" : [ "06:28", "800000", "100420" ], + "100389" : [ "06:29", "800000", "100420" ], + "100390" : [ "06:30", "800000", "100420" ], + "100391" : [ "06:31", "800000", "100420" ], + "100392" : [ "06:32", "800000", "100420" ], + "100393" : [ "06:33", "800000", "100420" ], + "100394" : [ "06:34", "800000", "100420" ], + "100395" : [ "06:35", "800000", "100420" ], + "100396" : [ "06:36", "800000", "100420" ], + "100397" : [ "06:37", "800000", "100420" ], + "100398" : [ "06:38", "800000", "100420" ], + "100399" : [ "06:39", "800000", "100420" ], + "100400" : [ "06:40", "800000", "100420" ], + "100401" : [ "06:41", "800000", "100420" ], + "100402" : [ "06:42", "800000", "100420" ], + "100403" : [ "06:43", "800000", "100420" ], + "100404" : [ "06:44", "800000", "100420" ], + "100405" : [ "06:45", "800000", "100420" ], + "100406" : [ "06:46", "800000", "100420" ], + "100407" : [ "06:47", "800000", "100420" ], + "100408" : [ "06:48", "800000", "100420" ], + "100409" : [ "06:49", "800000", "100420" ], + "100410" : [ "06:50", "800000", "100420" ], + "100411" : [ "06:51", "800000", "100420" ], + "100412" : [ "06:52", "800000", "100420" ], + "100413" : [ "06:53", "800000", "100420" ], + "100414" : [ "06:54", "800000", "100420" ], + "100415" : [ "06:55", "800000", "100420" ], + "100416" : [ "06:56", "800000", "100420" ], + "100417" : [ "06:57", "800000", "100420" ], + "100418" : [ "06:58", "800000", "100420" ], + "100419" : [ "06:59", "800000", "100420" ], + "100420" : [ "07:00", "350000", "100480" ], + "100421" : [ "07:01", "350000", "100481" ], + "100422" : [ "07:02", "350000", "100482" ], + "100423" : [ "07:03", "350000", "100483" ], + "100424" : [ "07:04", "350000", "100484" ], + "100425" : [ "07:05", "350000", "100485" ], + "100426" : [ "07:06", "350000", "100486" ], + "100427" : [ "07:07", "350000", "100487" ], + "100428" : [ "07:08", "350000", "100488" ], + "100429" : [ "07:09", "350000", "100489" ], + "100430" : [ "07:10", "350000", "100490" ], + "100431" : [ "07:11", "350000", "100491" ], + "100432" : [ "07:12", "350000", "100492" ], + "100433" : [ "07:13", "350000", "100493" ], + "100434" : [ "07:14", "350000", "100494" ], + "100435" : [ "07:15", "350000", "100495" ], + "100436" : [ "07:16", "350000", "100496" ], + "100437" : [ "07:17", "350000", "100497" ], + "100438" : [ "07:18", "350000", "100498" ], + "100439" : [ "07:19", "350000", "100499" ], + "100440" : [ "07:20", "350000", "100500" ], + "100441" : [ "07:21", "350000", "100501" ], + "100442" : [ "07:22", "350000", "100502" ], + "100443" : [ "07:23", "350000", "100503" ], + "100444" : [ "07:24", "350000", "100504" ], + "100445" : [ "07:25", "350000", "100505" ], + "100446" : [ "07:26", "350000", "100506" ], + "100447" : [ "07:27", "350000", "100507" ], + "100448" : [ "07:28", "350000", "100508" ], + "100449" : [ "07:29", "350000", "100509" ], + "100450" : [ "07:30", "350000", "100510" ], + "100451" : [ "07:31", "350000", "100511" ], + "100452" : [ "07:32", "350000", "100512" ], + "100453" : [ "07:33", "350000", "100513" ], + "100454" : [ "07:34", "350000", "100514" ], + "100455" : [ "07:35", "350000", "100515" ], + "100456" : [ "07:36", "350000", "100516" ], + "100457" : [ "07:37", "350000", "100517" ], + "100458" : [ "07:38", "350000", "100518" ], + "100459" : [ "07:39", "350000", "100519" ], + "100460" : [ "07:40", "350000", "100520" ], + "100461" : [ "07:41", "350000", "100521" ], + "100462" : [ "07:42", "350000", "100522" ], + "100463" : [ "07:43", "350000", "100523" ], + "100464" : [ "07:44", "350000", "100524" ], + "100465" : [ "07:45", "350000", "100525" ], + "100466" : [ "07:46", "350000", "100526" ], + "100467" : [ "07:47", "350000", "100527" ], + "100468" : [ "07:48", "350000", "100528" ], + "100469" : [ "07:49", "350000", "100529" ], + "100470" : [ "07:50", "350000", "100530" ], + "100471" : [ "07:51", "350000", "100531" ], + "100472" : [ "07:52", "350000", "100532" ], + "100473" : [ "07:53", "350000", "100533" ], + "100474" : [ "07:54", "350000", "100534" ], + "100475" : [ "07:55", "350000", "100535" ], + "100476" : [ "07:56", "350000", "100536" ], + "100477" : [ "07:57", "350000", "100537" ], + "100478" : [ "07:58", "350000", "100538" ], + "100479" : [ "07:59", "350000", "100539" ], + "100480" : [ "08:00", "350000", "100540" ], + "100481" : [ "08:01", "350000", "100541" ], + "100482" : [ "08:02", "350000", "100542" ], + "100483" : [ "08:03", "350000", "100543" ], + "100484" : [ "08:04", "350000", "100544" ], + "100485" : [ "08:05", "350000", "100545" ], + "100486" : [ "08:06", "350000", "100546" ], + "100487" : [ "08:07", "350000", "100547" ], + "100488" : [ "08:08", "350000", "100548" ], + "100489" : [ "08:09", "350000", "100549" ], + "100490" : [ "08:10", "350000", "100550" ], + "100491" : [ "08:11", "350000", "100551" ], + "100492" : [ "08:12", "350000", "100552" ], + "100493" : [ "08:13", "350000", "100553" ], + "100494" : [ "08:14", "350000", "100554" ], + "100495" : [ "08:15", "350000", "100555" ], + "100496" : [ "08:16", "350000", "100556" ], + "100497" : [ "08:17", "350000", "100557" ], + "100498" : [ "08:18", "350000", "100558" ], + "100499" : [ "08:19", "350000", "100559" ], + "100500" : [ "08:20", "350000", "100560" ], + "100501" : [ "08:21", "350000", "100561" ], + "100502" : [ "08:22", "350000", "100562" ], + "100503" : [ "08:23", "350000", "100563" ], + "100504" : [ "08:24", "350000", "100564" ], + "100505" : [ "08:25", "350000", "100565" ], + "100506" : [ "08:26", "350000", "100566" ], + "100507" : [ "08:27", "350000", "100567" ], + "100508" : [ "08:28", "350000", "100568" ], + "100509" : [ "08:29", "350000", "100569" ], + "100510" : [ "08:30", "350000", "100570" ], + "100511" : [ "08:31", "350000", "100571" ], + "100512" : [ "08:32", "350000", "100572" ], + "100513" : [ "08:33", "350000", "100573" ], + "100514" : [ "08:34", "350000", "100574" ], + "100515" : [ "08:35", "350000", "100575" ], + "100516" : [ "08:36", "350000", "100576" ], + "100517" : [ "08:37", "350000", "100577" ], + "100518" : [ "08:38", "350000", "100578" ], + "100519" : [ "08:39", "350000", "100579" ], + "100520" : [ "08:40", "350000", "100580" ], + "100521" : [ "08:41", "350000", "100581" ], + "100522" : [ "08:42", "350000", "100582" ], + "100523" : [ "08:43", "350000", "100583" ], + "100524" : [ "08:44", "350000", "100584" ], + "100525" : [ "08:45", "350000", "100585" ], + "100526" : [ "08:46", "350000", "100586" ], + "100527" : [ "08:47", "350000", "100587" ], + "100528" : [ "08:48", "350000", "100588" ], + "100529" : [ "08:49", "350000", "100589" ], + "100530" : [ "08:50", "350000", "100590" ], + "100531" : [ "08:51", "350000", "100591" ], + "100532" : [ "08:52", "350000", "100592" ], + "100533" : [ "08:53", "350000", "100593" ], + "100534" : [ "08:54", "350000", "100594" ], + "100535" : [ "08:55", "350000", "100595" ], + "100536" : [ "08:56", "350000", "100596" ], + "100537" : [ "08:57", "350000", "100597" ], + "100538" : [ "08:58", "350000", "100598" ], + "100539" : [ "08:59", "350000", "100599" ], + "100540" : [ "09:00", "350000", "100600" ], + "100541" : [ "09:01", "350000", "100601" ], + "100542" : [ "09:02", "350000", "100602" ], + "100543" : [ "09:03", "350000", "100603" ], + "100544" : [ "09:04", "350000", "100604" ], + "100545" : [ "09:05", "350000", "100605" ], + "100546" : [ "09:06", "350000", "100606" ], + "100547" : [ "09:07", "350000", "100607" ], + "100548" : [ "09:08", "350000", "100608" ], + "100549" : [ "09:09", "350000", "100609" ], + "100550" : [ "09:10", "350000", "100610" ], + "100551" : [ "09:11", "350000", "100611" ], + "100552" : [ "09:12", "350000", "100612" ], + "100553" : [ "09:13", "350000", "100613" ], + "100554" : [ "09:14", "350000", "100614" ], + "100555" : [ "09:15", "350000", "100615" ], + "100556" : [ "09:16", "350000", "100616" ], + "100557" : [ "09:17", "350000", "100617" ], + "100558" : [ "09:18", "350000", "100618" ], + "100559" : [ "09:19", "350000", "100619" ], + "100560" : [ "09:20", "350000", "100620" ], + "100561" : [ "09:21", "350000", "100621" ], + "100562" : [ "09:22", "350000", "100622" ], + "100563" : [ "09:23", "350000", "100623" ], + "100564" : [ "09:24", "350000", "100624" ], + "100565" : [ "09:25", "350000", "100625" ], + "100566" : [ "09:26", "350000", "100626" ], + "100567" : [ "09:27", "350000", "100627" ], + "100568" : [ "09:28", "350000", "100628" ], + "100569" : [ "09:29", "350000", "100629" ], + "100570" : [ "09:30", "350000", "100630" ], + "100571" : [ "09:31", "350000", "100631" ], + "100572" : [ "09:32", "350000", "100632" ], + "100573" : [ "09:33", "350000", "100633" ], + "100574" : [ "09:34", "350000", "100634" ], + "100575" : [ "09:35", "350000", "100635" ], + "100576" : [ "09:36", "350000", "100636" ], + "100577" : [ "09:37", "350000", "100637" ], + "100578" : [ "09:38", "350000", "100638" ], + "100579" : [ "09:39", "350000", "100639" ], + "100580" : [ "09:40", "350000", "100640" ], + "100581" : [ "09:41", "350000", "100641" ], + "100582" : [ "09:42", "350000", "100642" ], + "100583" : [ "09:43", "350000", "100643" ], + "100584" : [ "09:44", "350000", "100644" ], + "100585" : [ "09:45", "350000", "100645" ], + "100586" : [ "09:46", "350000", "100646" ], + "100587" : [ "09:47", "350000", "100647" ], + "100588" : [ "09:48", "350000", "100648" ], + "100589" : [ "09:49", "350000", "100649" ], + "100590" : [ "09:50", "350000", "100650" ], + "100591" : [ "09:51", "350000", "100651" ], + "100592" : [ "09:52", "350000", "100652" ], + "100593" : [ "09:53", "350000", "100653" ], + "100594" : [ "09:54", "350000", "100654" ], + "100595" : [ "09:55", "350000", "100655" ], + "100596" : [ "09:56", "350000", "100656" ], + "100597" : [ "09:57", "350000", "100657" ], + "100598" : [ "09:58", "350000", "100658" ], + "100599" : [ "09:59", "350000", "100659" ], + "100600" : [ "10:00", "350000", "100660" ], + "100601" : [ "10:01", "350000", "100661" ], + "100602" : [ "10:02", "350000", "100662" ], + "100603" : [ "10:03", "350000", "100663" ], + "100604" : [ "10:04", "350000", "100664" ], + "100605" : [ "10:05", "350000", "100665" ], + "100606" : [ "10:06", "350000", "100666" ], + "100607" : [ "10:07", "350000", "100667" ], + "100608" : [ "10:08", "350000", "100668" ], + "100609" : [ "10:09", "350000", "100669" ], + "100610" : [ "10:10", "350000", "100670" ], + "100611" : [ "10:11", "350000", "100671" ], + "100612" : [ "10:12", "350000", "100672" ], + "100613" : [ "10:13", "350000", "100673" ], + "100614" : [ "10:14", "350000", "100674" ], + "100615" : [ "10:15", "350000", "100675" ], + "100616" : [ "10:16", "350000", "100676" ], + "100617" : [ "10:17", "350000", "100677" ], + "100618" : [ "10:18", "350000", "100678" ], + "100619" : [ "10:19", "350000", "100679" ], + "100620" : [ "10:20", "350000", "100680" ], + "100621" : [ "10:21", "350000", "100681" ], + "100622" : [ "10:22", "350000", "100682" ], + "100623" : [ "10:23", "350000", "100683" ], + "100624" : [ "10:24", "350000", "100684" ], + "100625" : [ "10:25", "350000", "100685" ], + "100626" : [ "10:26", "350000", "100686" ], + "100627" : [ "10:27", "350000", "100687" ], + "100628" : [ "10:28", "350000", "100688" ], + "100629" : [ "10:29", "350000", "100689" ], + "100630" : [ "10:30", "350000", "100690" ], + "100631" : [ "10:31", "350000", "100691" ], + "100632" : [ "10:32", "350000", "100692" ], + "100633" : [ "10:33", "350000", "100693" ], + "100634" : [ "10:34", "350000", "100694" ], + "100635" : [ "10:35", "350000", "100695" ], + "100636" : [ "10:36", "350000", "100696" ], + "100637" : [ "10:37", "350000", "100697" ], + "100638" : [ "10:38", "350000", "100698" ], + "100639" : [ "10:39", "350000", "100699" ], + "100640" : [ "10:40", "350000", "100700" ], + "100641" : [ "10:41", "350000", "100701" ], + "100642" : [ "10:42", "350000", "100702" ], + "100643" : [ "10:43", "350000", "100703" ], + "100644" : [ "10:44", "350000", "100704" ], + "100645" : [ "10:45", "350000", "100705" ], + "100646" : [ "10:46", "350000", "100706" ], + "100647" : [ "10:47", "350000", "100707" ], + "100648" : [ "10:48", "350000", "100708" ], + "100649" : [ "10:49", "350000", "100709" ], + "100650" : [ "10:50", "350000", "100710" ], + "100651" : [ "10:51", "350000", "100711" ], + "100652" : [ "10:52", "350000", "100712" ], + "100653" : [ "10:53", "350000", "100713" ], + "100654" : [ "10:54", "350000", "100714" ], + "100655" : [ "10:55", "350000", "100715" ], + "100656" : [ "10:56", "350000", "100716" ], + "100657" : [ "10:57", "350000", "100717" ], + "100658" : [ "10:58", "350000", "100718" ], + "100659" : [ "10:59", "350000", "100719" ], + "100660" : [ "11:00", "350000", "100720" ], + "100661" : [ "11:01", "350000", "100721" ], + "100662" : [ "11:02", "350000", "100722" ], + "100663" : [ "11:03", "350000", "100723" ], + "100664" : [ "11:04", "350000", "100724" ], + "100665" : [ "11:05", "350000", "100725" ], + "100666" : [ "11:06", "350000", "100726" ], + "100667" : [ "11:07", "350000", "100727" ], + "100668" : [ "11:08", "350000", "100728" ], + "100669" : [ "11:09", "350000", "100729" ], + "100670" : [ "11:10", "350000", "100730" ], + "100671" : [ "11:11", "350000", "100731" ], + "100672" : [ "11:12", "350000", "100732" ], + "100673" : [ "11:13", "350000", "100733" ], + "100674" : [ "11:14", "350000", "100734" ], + "100675" : [ "11:15", "350000", "100735" ], + "100676" : [ "11:16", "350000", "100736" ], + "100677" : [ "11:17", "350000", "100737" ], + "100678" : [ "11:18", "350000", "100738" ], + "100679" : [ "11:19", "350000", "100739" ], + "100680" : [ "11:20", "350000", "100740" ], + "100681" : [ "11:21", "350000", "100741" ], + "100682" : [ "11:22", "350000", "100742" ], + "100683" : [ "11:23", "350000", "100743" ], + "100684" : [ "11:24", "350000", "100744" ], + "100685" : [ "11:25", "350000", "100745" ], + "100686" : [ "11:26", "350000", "100746" ], + "100687" : [ "11:27", "350000", "100747" ], + "100688" : [ "11:28", "350000", "100748" ], + "100689" : [ "11:29", "350000", "100749" ], + "100690" : [ "11:30", "350000", "100750" ], + "100691" : [ "11:31", "350000", "100751" ], + "100692" : [ "11:32", "350000", "100752" ], + "100693" : [ "11:33", "350000", "100753" ], + "100694" : [ "11:34", "350000", "100754" ], + "100695" : [ "11:35", "350000", "100755" ], + "100696" : [ "11:36", "350000", "100756" ], + "100697" : [ "11:37", "350000", "100757" ], + "100698" : [ "11:38", "350000", "100758" ], + "100699" : [ "11:39", "350000", "100759" ], + "100700" : [ "11:40", "350000", "100760" ], + "100701" : [ "11:41", "350000", "100761" ], + "100702" : [ "11:42", "350000", "100762" ], + "100703" : [ "11:43", "350000", "100763" ], + "100704" : [ "11:44", "350000", "100764" ], + "100705" : [ "11:45", "350000", "100765" ], + "100706" : [ "11:46", "350000", "100766" ], + "100707" : [ "11:47", "350000", "100767" ], + "100708" : [ "11:48", "350000", "100768" ], + "100709" : [ "11:49", "350000", "100769" ], + "100710" : [ "11:50", "350000", "100770" ], + "100711" : [ "11:51", "350000", "100771" ], + "100712" : [ "11:52", "350000", "100772" ], + "100713" : [ "11:53", "350000", "100773" ], + "100714" : [ "11:54", "350000", "100774" ], + "100715" : [ "11:55", "350000", "100775" ], + "100716" : [ "11:56", "350000", "100776" ], + "100717" : [ "11:57", "350000", "100777" ], + "100718" : [ "11:58", "350000", "100778" ], + "100719" : [ "11:59", "350000", "100779" ], + "100720" : [ "12:00", "350000", "100780" ], + "100721" : [ "12:01", "350000", "100781" ], + "100722" : [ "12:02", "350000", "100782" ], + "100723" : [ "12:03", "350000", "100783" ], + "100724" : [ "12:04", "350000", "100784" ], + "100725" : [ "12:05", "350000", "100785" ], + "100726" : [ "12:06", "350000", "100786" ], + "100727" : [ "12:07", "350000", "100787" ], + "100728" : [ "12:08", "350000", "100788" ], + "100729" : [ "12:09", "350000", "100789" ], + "100730" : [ "12:10", "350000", "100790" ], + "100731" : [ "12:11", "350000", "100791" ], + "100732" : [ "12:12", "350000", "100792" ], + "100733" : [ "12:13", "350000", "100793" ], + "100734" : [ "12:14", "350000", "100794" ], + "100735" : [ "12:15", "350000", "100795" ], + "100736" : [ "12:16", "350000", "100796" ], + "100737" : [ "12:17", "350000", "100797" ], + "100738" : [ "12:18", "350000", "100798" ], + "100739" : [ "12:19", "350000", "100799" ], + "100740" : [ "12:20", "350000", "100800" ], + "100741" : [ "12:21", "350000", "100801" ], + "100742" : [ "12:22", "350000", "100802" ], + "100743" : [ "12:23", "350000", "100803" ], + "100744" : [ "12:24", "350000", "100804" ], + "100745" : [ "12:25", "350000", "100805" ], + "100746" : [ "12:26", "350000", "100806" ], + "100747" : [ "12:27", "350000", "100807" ], + "100748" : [ "12:28", "350000", "100808" ], + "100749" : [ "12:29", "350000", "100809" ], + "100750" : [ "12:30", "350000", "100810" ], + "100751" : [ "12:31", "350000", "100811" ], + "100752" : [ "12:32", "350000", "100812" ], + "100753" : [ "12:33", "350000", "100813" ], + "100754" : [ "12:34", "350000", "100814" ], + "100755" : [ "12:35", "350000", "100815" ], + "100756" : [ "12:36", "350000", "100816" ], + "100757" : [ "12:37", "350000", "100817" ], + "100758" : [ "12:38", "350000", "100818" ], + "100759" : [ "12:39", "350000", "100819" ], + "100760" : [ "12:40", "350000", "100820" ], + "100761" : [ "12:41", "350000", "100821" ], + "100762" : [ "12:42", "350000", "100822" ], + "100763" : [ "12:43", "350000", "100823" ], + "100764" : [ "12:44", "350000", "100824" ], + "100765" : [ "12:45", "350000", "100825" ], + "100766" : [ "12:46", "350000", "100826" ], + "100767" : [ "12:47", "350000", "100827" ], + "100768" : [ "12:48", "350000", "100828" ], + "100769" : [ "12:49", "350000", "100829" ], + "100770" : [ "12:50", "350000", "100830" ], + "100771" : [ "12:51", "350000", "100831" ], + "100772" : [ "12:52", "350000", "100832" ], + "100773" : [ "12:53", "350000", "100833" ], + "100774" : [ "12:54", "350000", "100834" ], + "100775" : [ "12:55", "350000", "100835" ], + "100776" : [ "12:56", "350000", "100836" ], + "100777" : [ "12:57", "350000", "100837" ], + "100778" : [ "12:58", "350000", "100838" ], + "100779" : [ "12:59", "350000", "100839" ], + "100780" : [ "13:00", "350000", "100840" ], + "100781" : [ "13:01", "350000", "100841" ], + "100782" : [ "13:02", "350000", "100842" ], + "100783" : [ "13:03", "350000", "100843" ], + "100784" : [ "13:04", "350000", "100844" ], + "100785" : [ "13:05", "350000", "100845" ], + "100786" : [ "13:06", "350000", "100846" ], + "100787" : [ "13:07", "350000", "100847" ], + "100788" : [ "13:08", "350000", "100848" ], + "100789" : [ "13:09", "350000", "100849" ], + "100790" : [ "13:10", "350000", "100850" ], + "100791" : [ "13:11", "350000", "100851" ], + "100792" : [ "13:12", "350000", "100852" ], + "100793" : [ "13:13", "350000", "100853" ], + "100794" : [ "13:14", "350000", "100854" ], + "100795" : [ "13:15", "350000", "100855" ], + "100796" : [ "13:16", "350000", "100856" ], + "100797" : [ "13:17", "350000", "100857" ], + "100798" : [ "13:18", "350000", "100858" ], + "100799" : [ "13:19", "350000", "100859" ], + "100800" : [ "13:20", "350000", "100860" ], + "100801" : [ "13:21", "350000", "100861" ], + "100802" : [ "13:22", "350000", "100862" ], + "100803" : [ "13:23", "350000", "100863" ], + "100804" : [ "13:24", "350000", "100864" ], + "100805" : [ "13:25", "350000", "100865" ], + "100806" : [ "13:26", "350000", "100866" ], + "100807" : [ "13:27", "350000", "100867" ], + "100808" : [ "13:28", "350000", "100868" ], + "100809" : [ "13:29", "350000", "100869" ], + "100810" : [ "13:30", "350000", "100870" ], + "100811" : [ "13:31", "350000", "100871" ], + "100812" : [ "13:32", "350000", "100872" ], + "100813" : [ "13:33", "350000", "100873" ], + "100814" : [ "13:34", "350000", "100874" ], + "100815" : [ "13:35", "350000", "100875" ], + "100816" : [ "13:36", "350000", "100876" ], + "100817" : [ "13:37", "350000", "100877" ], + "100818" : [ "13:38", "350000", "100878" ], + "100819" : [ "13:39", "350000", "100879" ], + "100820" : [ "13:40", "350000", "100880" ], + "100821" : [ "13:41", "350000", "100881" ], + "100822" : [ "13:42", "350000", "100882" ], + "100823" : [ "13:43", "350000", "100883" ], + "100824" : [ "13:44", "350000", "100884" ], + "100825" : [ "13:45", "350000", "100885" ], + "100826" : [ "13:46", "350000", "100886" ], + "100827" : [ "13:47", "350000", "100887" ], + "100828" : [ "13:48", "350000", "100888" ], + "100829" : [ "13:49", "350000", "100889" ], + "100830" : [ "13:50", "350000", "100890" ], + "100831" : [ "13:51", "350000", "100891" ], + "100832" : [ "13:52", "350000", "100892" ], + "100833" : [ "13:53", "350000", "100893" ], + "100834" : [ "13:54", "350000", "100894" ], + "100835" : [ "13:55", "350000", "100895" ], + "100836" : [ "13:56", "350000", "100896" ], + "100837" : [ "13:57", "350000", "100897" ], + "100838" : [ "13:58", "350000", "100898" ], + "100839" : [ "13:59", "350000", "100899" ], + "100840" : [ "14:00", "350000", "100900" ], + "100841" : [ "14:01", "350000", "100901" ], + "100842" : [ "14:02", "350000", "100902" ], + "100843" : [ "14:03", "350000", "100903" ], + "100844" : [ "14:04", "350000", "100904" ], + "100845" : [ "14:05", "350000", "100905" ], + "100846" : [ "14:06", "350000", "100906" ], + "100847" : [ "14:07", "350000", "100907" ], + "100848" : [ "14:08", "350000", "100908" ], + "100849" : [ "14:09", "350000", "100909" ], + "100850" : [ "14:10", "350000", "100910" ], + "100851" : [ "14:11", "350000", "100911" ], + "100852" : [ "14:12", "350000", "100912" ], + "100853" : [ "14:13", "350000", "100913" ], + "100854" : [ "14:14", "350000", "100914" ], + "100855" : [ "14:15", "350000", "100915" ], + "100856" : [ "14:16", "350000", "100916" ], + "100857" : [ "14:17", "350000", "100917" ], + "100858" : [ "14:18", "350000", "100918" ], + "100859" : [ "14:19", "350000", "100919" ], + "100860" : [ "14:20", "350000", "100920" ], + "100861" : [ "14:21", "350000", "100921" ], + "100862" : [ "14:22", "350000", "100922" ], + "100863" : [ "14:23", "350000", "100923" ], + "100864" : [ "14:24", "350000", "100924" ], + "100865" : [ "14:25", "350000", "100925" ], + "100866" : [ "14:26", "350000", "100926" ], + "100867" : [ "14:27", "350000", "100927" ], + "100868" : [ "14:28", "350000", "100928" ], + "100869" : [ "14:29", "350000", "100929" ], + "100870" : [ "14:30", "350000", "100930" ], + "100871" : [ "14:31", "350000", "100931" ], + "100872" : [ "14:32", "350000", "100932" ], + "100873" : [ "14:33", "350000", "100933" ], + "100874" : [ "14:34", "350000", "100934" ], + "100875" : [ "14:35", "350000", "100935" ], + "100876" : [ "14:36", "350000", "100936" ], + "100877" : [ "14:37", "350000", "100937" ], + "100878" : [ "14:38", "350000", "100938" ], + "100879" : [ "14:39", "350000", "100939" ], + "100880" : [ "14:40", "350000", "100940" ], + "100881" : [ "14:41", "350000", "100941" ], + "100882" : [ "14:42", "350000", "100942" ], + "100883" : [ "14:43", "350000", "100943" ], + "100884" : [ "14:44", "350000", "100944" ], + "100885" : [ "14:45", "350000", "100945" ], + "100886" : [ "14:46", "350000", "100946" ], + "100887" : [ "14:47", "350000", "100947" ], + "100888" : [ "14:48", "350000", "100948" ], + "100889" : [ "14:49", "350000", "100949" ], + "100890" : [ "14:50", "350000", "100950" ], + "100891" : [ "14:51", "350000", "100951" ], + "100892" : [ "14:52", "350000", "100952" ], + "100893" : [ "14:53", "350000", "100953" ], + "100894" : [ "14:54", "350000", "100954" ], + "100895" : [ "14:55", "350000", "100955" ], + "100896" : [ "14:56", "350000", "100956" ], + "100897" : [ "14:57", "350000", "100957" ], + "100898" : [ "14:58", "350000", "100958" ], + "100899" : [ "14:59", "350000", "100959" ], + "100900" : [ "15:00", "350000", "100960" ], + "100901" : [ "15:01", "350000", "100961" ], + "100902" : [ "15:02", "350000", "100962" ], + "100903" : [ "15:03", "350000", "100963" ], + "100904" : [ "15:04", "350000", "100964" ], + "100905" : [ "15:05", "350000", "100965" ], + "100906" : [ "15:06", "350000", "100966" ], + "100907" : [ "15:07", "350000", "100967" ], + "100908" : [ "15:08", "350000", "100968" ], + "100909" : [ "15:09", "350000", "100969" ], + "100910" : [ "15:10", "350000", "100970" ], + "100911" : [ "15:11", "350000", "100971" ], + "100912" : [ "15:12", "350000", "100972" ], + "100913" : [ "15:13", "350000", "100973" ], + "100914" : [ "15:14", "350000", "100974" ], + "100915" : [ "15:15", "350000", "100975" ], + "100916" : [ "15:16", "350000", "100976" ], + "100917" : [ "15:17", "350000", "100977" ], + "100918" : [ "15:18", "350000", "100978" ], + "100919" : [ "15:19", "350000", "100979" ], + "100920" : [ "15:20", "350000", "100980" ], + "100921" : [ "15:21", "350000", "100981" ], + "100922" : [ "15:22", "350000", "100982" ], + "100923" : [ "15:23", "350000", "100983" ], + "100924" : [ "15:24", "350000", "100984" ], + "100925" : [ "15:25", "350000", "100985" ], + "100926" : [ "15:26", "350000", "100986" ], + "100927" : [ "15:27", "350000", "100987" ], + "100928" : [ "15:28", "350000", "100988" ], + "100929" : [ "15:29", "350000", "100989" ], + "100930" : [ "15:30", "350000", "100990" ], + "100931" : [ "15:31", "350000", "100991" ], + "100932" : [ "15:32", "350000", "100992" ], + "100933" : [ "15:33", "350000", "100993" ], + "100934" : [ "15:34", "350000", "100994" ], + "100935" : [ "15:35", "350000", "100995" ], + "100936" : [ "15:36", "350000", "100996" ], + "100937" : [ "15:37", "350000", "100997" ], + "100938" : [ "15:38", "350000", "100998" ], + "100939" : [ "15:39", "350000", "100999" ], + "100940" : [ "15:40", "350000", "101000" ], + "100941" : [ "15:41", "350000", "101001" ], + "100942" : [ "15:42", "350000", "101002" ], + "100943" : [ "15:43", "350000", "101003" ], + "100944" : [ "15:44", "350000", "101004" ], + "100945" : [ "15:45", "350000", "101005" ], + "100946" : [ "15:46", "350000", "101006" ], + "100947" : [ "15:47", "350000", "101007" ], + "100948" : [ "15:48", "350000", "101008" ], + "100949" : [ "15:49", "350000", "101009" ], + "100950" : [ "15:50", "350000", "101010" ], + "100951" : [ "15:51", "350000", "101011" ], + "100952" : [ "15:52", "350000", "101012" ], + "100953" : [ "15:53", "350000", "101013" ], + "100954" : [ "15:54", "350000", "101014" ], + "100955" : [ "15:55", "350000", "101015" ], + "100956" : [ "15:56", "350000", "101016" ], + "100957" : [ "15:57", "350000", "101017" ], + "100958" : [ "15:58", "350000", "101018" ], + "100959" : [ "15:59", "350000", "101019" ], + "100960" : [ "16:00", "350000", "101020" ], + "100961" : [ "16:01", "350000", "101021" ], + "100962" : [ "16:02", "350000", "101022" ], + "100963" : [ "16:03", "350000", "101023" ], + "100964" : [ "16:04", "350000", "101024" ], + "100965" : [ "16:05", "350000", "101025" ], + "100966" : [ "16:06", "350000", "101026" ], + "100967" : [ "16:07", "350000", "101027" ], + "100968" : [ "16:08", "350000", "101028" ], + "100969" : [ "16:09", "350000", "101029" ], + "100970" : [ "16:10", "350000", "101030" ], + "100971" : [ "16:11", "350000", "101031" ], + "100972" : [ "16:12", "350000", "101032" ], + "100973" : [ "16:13", "350000", "101033" ], + "100974" : [ "16:14", "350000", "101034" ], + "100975" : [ "16:15", "350000", "101035" ], + "100976" : [ "16:16", "350000", "101036" ], + "100977" : [ "16:17", "350000", "101037" ], + "100978" : [ "16:18", "350000", "101038" ], + "100979" : [ "16:19", "350000", "101039" ], + "100980" : [ "16:20", "350000", "101040" ], + "100981" : [ "16:21", "350000", "101041" ], + "100982" : [ "16:22", "350000", "101042" ], + "100983" : [ "16:23", "350000", "101043" ], + "100984" : [ "16:24", "350000", "101044" ], + "100985" : [ "16:25", "350000", "101045" ], + "100986" : [ "16:26", "350000", "101046" ], + "100987" : [ "16:27", "350000", "101047" ], + "100988" : [ "16:28", "350000", "101048" ], + "100989" : [ "16:29", "350000", "101049" ], + "100990" : [ "16:30", "350000", "101050" ], + "100991" : [ "16:31", "350000", "101051" ], + "100992" : [ "16:32", "350000", "101052" ], + "100993" : [ "16:33", "350000", "101053" ], + "100994" : [ "16:34", "350000", "101054" ], + "100995" : [ "16:35", "350000", "101055" ], + "100996" : [ "16:36", "350000", "101056" ], + "100997" : [ "16:37", "350000", "101057" ], + "100998" : [ "16:38", "350000", "101058" ], + "100999" : [ "16:39", "350000", "101059" ], + "101000" : [ "16:40", "350000", "101060" ], + "101001" : [ "16:41", "350000", "101061" ], + "101002" : [ "16:42", "350000", "101062" ], + "101003" : [ "16:43", "350000", "101063" ], + "101004" : [ "16:44", "350000", "101064" ], + "101005" : [ "16:45", "350000", "101065" ], + "101006" : [ "16:46", "350000", "101066" ], + "101007" : [ "16:47", "350000", "101067" ], + "101008" : [ "16:48", "350000", "101068" ], + "101009" : [ "16:49", "350000", "101069" ], + "101010" : [ "16:50", "350000", "101070" ], + "101011" : [ "16:51", "350000", "101071" ], + "101012" : [ "16:52", "350000", "101072" ], + "101013" : [ "16:53", "350000", "101073" ], + "101014" : [ "16:54", "350000", "101074" ], + "101015" : [ "16:55", "350000", "101075" ], + "101016" : [ "16:56", "350000", "101076" ], + "101017" : [ "16:57", "350000", "101077" ], + "101018" : [ "16:58", "350000", "101078" ], + "101019" : [ "16:59", "350000", "101079" ], + "101020" : [ "17:00", "350000", "101080" ], + "101021" : [ "17:01", "350000", "101081" ], + "101022" : [ "17:02", "350000", "101082" ], + "101023" : [ "17:03", "350000", "101083" ], + "101024" : [ "17:04", "350000", "101084" ], + "101025" : [ "17:05", "350000", "101085" ], + "101026" : [ "17:06", "350000", "101086" ], + "101027" : [ "17:07", "350000", "101087" ], + "101028" : [ "17:08", "350000", "101088" ], + "101029" : [ "17:09", "350000", "101089" ], + "101030" : [ "17:10", "350000", "101090" ], + "101031" : [ "17:11", "350000", "101091" ], + "101032" : [ "17:12", "350000", "101092" ], + "101033" : [ "17:13", "350000", "101093" ], + "101034" : [ "17:14", "350000", "101094" ], + "101035" : [ "17:15", "350000", "101095" ], + "101036" : [ "17:16", "350000", "101096" ], + "101037" : [ "17:17", "350000", "101097" ], + "101038" : [ "17:18", "350000", "101098" ], + "101039" : [ "17:19", "350000", "101099" ], + "101040" : [ "17:20", "350000", "101100" ], + "101041" : [ "17:21", "350000", "101101" ], + "101042" : [ "17:22", "350000", "101102" ], + "101043" : [ "17:23", "350000", "101103" ], + "101044" : [ "17:24", "350000", "101104" ], + "101045" : [ "17:25", "350000", "101105" ], + "101046" : [ "17:26", "350000", "101106" ], + "101047" : [ "17:27", "350000", "101107" ], + "101048" : [ "17:28", "350000", "101108" ], + "101049" : [ "17:29", "350000", "101109" ], + "101050" : [ "17:30", "350000", "101110" ], + "101051" : [ "17:31", "350000", "101111" ], + "101052" : [ "17:32", "350000", "101112" ], + "101053" : [ "17:33", "350000", "101113" ], + "101054" : [ "17:34", "350000", "101114" ], + "101055" : [ "17:35", "350000", "101115" ], + "101056" : [ "17:36", "350000", "101116" ], + "101057" : [ "17:37", "350000", "101117" ], + "101058" : [ "17:38", "350000", "101118" ], + "101059" : [ "17:39", "350000", "101119" ], + "101060" : [ "17:40", "350000", "101120" ], + "101061" : [ "17:41", "350000", "101121" ], + "101062" : [ "17:42", "350000", "101122" ], + "101063" : [ "17:43", "350000", "101123" ], + "101064" : [ "17:44", "350000", "101124" ], + "101065" : [ "17:45", "350000", "101125" ], + "101066" : [ "17:46", "350000", "101126" ], + "101067" : [ "17:47", "350000", "101127" ], + "101068" : [ "17:48", "350000", "101128" ], + "101069" : [ "17:49", "350000", "101129" ], + "101070" : [ "17:50", "350000", "101130" ], + "101071" : [ "17:51", "350000", "101131" ], + "101072" : [ "17:52", "350000", "101132" ], + "101073" : [ "17:53", "350000", "101133" ], + "101074" : [ "17:54", "350000", "101134" ], + "101075" : [ "17:55", "350000", "101135" ], + "101076" : [ "17:56", "350000", "101136" ], + "101077" : [ "17:57", "350000", "101137" ], + "101078" : [ "17:58", "350000", "101138" ], + "101079" : [ "17:59", "350000", "101139" ], + "101080" : [ "18:00", "350000", "101140" ], + "101081" : [ "18:01", "350000", "101141" ], + "101082" : [ "18:02", "350000", "101142" ], + "101083" : [ "18:03", "350000", "101143" ], + "101084" : [ "18:04", "350000", "101144" ], + "101085" : [ "18:05", "350000", "101145" ], + "101086" : [ "18:06", "350000", "101146" ], + "101087" : [ "18:07", "350000", "101147" ], + "101088" : [ "18:08", "350000", "101148" ], + "101089" : [ "18:09", "350000", "101149" ], + "101090" : [ "18:10", "350000", "101150" ], + "101091" : [ "18:11", "350000", "101151" ], + "101092" : [ "18:12", "350000", "101152" ], + "101093" : [ "18:13", "350000", "101153" ], + "101094" : [ "18:14", "350000", "101154" ], + "101095" : [ "18:15", "350000", "101155" ], + "101096" : [ "18:16", "350000", "101156" ], + "101097" : [ "18:17", "350000", "101157" ], + "101098" : [ "18:18", "350000", "101158" ], + "101099" : [ "18:19", "350000", "101159" ], + "101100" : [ "18:20", "350000", "101160" ], + "101101" : [ "18:21", "350000", "101161" ], + "101102" : [ "18:22", "350000", "101162" ], + "101103" : [ "18:23", "350000", "101163" ], + "101104" : [ "18:24", "350000", "101164" ], + "101105" : [ "18:25", "350000", "101165" ], + "101106" : [ "18:26", "350000", "101166" ], + "101107" : [ "18:27", "350000", "101167" ], + "101108" : [ "18:28", "350000", "101168" ], + "101109" : [ "18:29", "350000", "101169" ], + "101110" : [ "18:30", "350000", "101170" ], + "101111" : [ "18:31", "350000", "101171" ], + "101112" : [ "18:32", "350000", "101172" ], + "101113" : [ "18:33", "350000", "101173" ], + "101114" : [ "18:34", "350000", "101174" ], + "101115" : [ "18:35", "350000", "101175" ], + "101116" : [ "18:36", "350000", "101176" ], + "101117" : [ "18:37", "350000", "101177" ], + "101118" : [ "18:38", "350000", "101178" ], + "101119" : [ "18:39", "350000", "101179" ], + "101120" : [ "18:40", "350000", "101180" ], + "101121" : [ "18:41", "350000", "101181" ], + "101122" : [ "18:42", "350000", "101182" ], + "101123" : [ "18:43", "350000", "101183" ], + "101124" : [ "18:44", "350000", "101184" ], + "101125" : [ "18:45", "350000", "101185" ], + "101126" : [ "18:46", "350000", "101186" ], + "101127" : [ "18:47", "350000", "101187" ], + "101128" : [ "18:48", "350000", "101188" ], + "101129" : [ "18:49", "350000", "101189" ], + "101130" : [ "18:50", "350000", "101190" ], + "101131" : [ "18:51", "350000", "101191" ], + "101132" : [ "18:52", "350000", "101192" ], + "101133" : [ "18:53", "350000", "101193" ], + "101134" : [ "18:54", "350000", "101194" ], + "101135" : [ "18:55", "350000", "101195" ], + "101136" : [ "18:56", "350000", "101196" ], + "101137" : [ "18:57", "350000", "101197" ], + "101138" : [ "18:58", "350000", "101198" ], + "101139" : [ "18:59", "350000", "101199" ], + "101140" : [ "19:00", "350000", "101200" ], + "101141" : [ "19:01", "350000", "101200" ], + "101142" : [ "19:02", "350000", "101200" ], + "101143" : [ "19:03", "350000", "101200" ], + "101144" : [ "19:04", "350000", "101200" ], + "101145" : [ "19:05", "350000", "101200" ], + "101146" : [ "19:06", "350000", "101200" ], + "101147" : [ "19:07", "350000", "101200" ], + "101148" : [ "19:08", "350000", "101200" ], + "101149" : [ "19:09", "350000", "101200" ], + "101150" : [ "19:10", "350000", "101200" ], + "101151" : [ "19:11", "350000", "101200" ], + "101152" : [ "19:12", "350000", "101200" ], + "101153" : [ "19:13", "350000", "101200" ], + "101154" : [ "19:14", "350000", "101200" ], + "101155" : [ "19:15", "350000", "101200" ], + "101156" : [ "19:16", "350000", "101200" ], + "101157" : [ "19:17", "350000", "101200" ], + "101158" : [ "19:18", "350000", "101200" ], + "101159" : [ "19:19", "350000", "101200" ], + "101160" : [ "19:20", "350000", "101200" ], + "101161" : [ "19:21", "350000", "101200" ], + "101162" : [ "19:22", "350000", "101200" ], + "101163" : [ "19:23", "350000", "101200" ], + "101164" : [ "19:24", "350000", "101200" ], + "101165" : [ "19:25", "350000", "101200" ], + "101166" : [ "19:26", "350000", "101200" ], + "101167" : [ "19:27", "350000", "101200" ], + "101168" : [ "19:28", "350000", "101200" ], + "101169" : [ "19:29", "350000", "101200" ], + "101170" : [ "19:30", "350000", "101200" ], + "101171" : [ "19:31", "350000", "101200" ], + "101172" : [ "19:32", "350000", "101200" ], + "101173" : [ "19:33", "350000", "101200" ], + "101174" : [ "19:34", "350000", "101200" ], + "101175" : [ "19:35", "350000", "101200" ], + "101176" : [ "19:36", "350000", "101200" ], + "101177" : [ "19:37", "350000", "101200" ], + "101178" : [ "19:38", "350000", "101200" ], + "101179" : [ "19:39", "350000", "101200" ], + "101180" : [ "19:40", "350000", "101200" ], + "101181" : [ "19:41", "350000", "101200" ], + "101182" : [ "19:42", "350000", "101200" ], + "101183" : [ "19:43", "350000", "101200" ], + "101184" : [ "19:44", "350000", "101200" ], + "101185" : [ "19:45", "350000", "101200" ], + "101186" : [ "19:46", "350000", "101200" ], + "101187" : [ "19:47", "350000", "101200" ], + "101188" : [ "19:48", "350000", "101200" ], + "101189" : [ "19:49", "350000", "101200" ], + "101190" : [ "19:50", "350000", "101200" ], + "101191" : [ "19:51", "350000", "101200" ], + "101192" : [ "19:52", "350000", "101200" ], + "101193" : [ "19:53", "350000", "101200" ], + "101194" : [ "19:54", "350000", "101200" ], + "101195" : [ "19:55", "350000", "101200" ], + "101196" : [ "19:56", "350000", "101200" ], + "101197" : [ "19:57", "350000", "101200" ], + "101198" : [ "19:58", "350000", "101200" ], + "101199" : [ "19:59", "350000", "101200" ], + "101200" : [ "20:00", "800000", "110420" ], + "101201" : [ "20:01", "800000", "110420" ], + "101202" : [ "20:02", "800000", "110420" ], + "101203" : [ "20:03", "800000", "110420" ], + "101204" : [ "20:04", "800000", "110420" ], + "101205" : [ "20:05", "800000", "110420" ], + "101206" : [ "20:06", "800000", "110420" ], + "101207" : [ "20:07", "800000", "110420" ], + "101208" : [ "20:08", "800000", "110420" ], + "101209" : [ "20:09", "800000", "110420" ], + "101210" : [ "20:10", "800000", "110420" ], + "101211" : [ "20:11", "800000", "110420" ], + "101212" : [ "20:12", "800000", "110420" ], + "101213" : [ "20:13", "800000", "110420" ], + "101214" : [ "20:14", "800000", "110420" ], + "101215" : [ "20:15", "800000", "110420" ], + "101216" : [ "20:16", "800000", "110420" ], + "101217" : [ "20:17", "800000", "110420" ], + "101218" : [ "20:18", "800000", "110420" ], + "101219" : [ "20:19", "800000", "110420" ], + "101220" : [ "20:20", "800000", "110420" ], + "101221" : [ "20:21", "800000", "110420" ], + "101222" : [ "20:22", "800000", "110420" ], + "101223" : [ "20:23", "800000", "110420" ], + "101224" : [ "20:24", "800000", "110420" ], + "101225" : [ "20:25", "800000", "110420" ], + "101226" : [ "20:26", "800000", "110420" ], + "101227" : [ "20:27", "800000", "110420" ], + "101228" : [ "20:28", "800000", "110420" ], + "101229" : [ "20:29", "800000", "110420" ], + "101230" : [ "20:30", "800000", "110420" ], + "101231" : [ "20:31", "800000", "110420" ], + "101232" : [ "20:32", "800000", "110420" ], + "101233" : [ "20:33", "800000", "110420" ], + "101234" : [ "20:34", "800000", "110420" ], + "101235" : [ "20:35", "800000", "110420" ], + "101236" : [ "20:36", "800000", "110420" ], + "101237" : [ "20:37", "800000", "110420" ], + "101238" : [ "20:38", "800000", "110420" ], + "101239" : [ "20:39", "800000", "110420" ], + "101240" : [ "20:40", "800000", "110420" ], + "101241" : [ "20:41", "800000", "110420" ], + "101242" : [ "20:42", "800000", "110420" ], + "101243" : [ "20:43", "800000", "110420" ], + "101244" : [ "20:44", "800000", "110420" ], + "101245" : [ "20:45", "800000", "110420" ], + "101246" : [ "20:46", "800000", "110420" ], + "101247" : [ "20:47", "800000", "110420" ], + "101248" : [ "20:48", "800000", "110420" ], + "101249" : [ "20:49", "800000", "110420" ], + "101250" : [ "20:50", "800000", "110420" ], + "101251" : [ "20:51", "800000", "110420" ], + "101252" : [ "20:52", "800000", "110420" ], + "101253" : [ "20:53", "800000", "110420" ], + "101254" : [ "20:54", "800000", "110420" ], + "101255" : [ "20:55", "800000", "110420" ], + "101256" : [ "20:56", "800000", "110420" ], + "101257" : [ "20:57", "800000", "110420" ], + "101258" : [ "20:58", "800000", "110420" ], + "101259" : [ "20:59", "800000", "110420" ], + "101260" : [ "21:00", "800000", "110420" ], + "101261" : [ "21:01", "800000", "110420" ], + "101262" : [ "21:02", "800000", "110420" ], + "101263" : [ "21:03", "800000", "110420" ], + "101264" : [ "21:04", "800000", "110420" ], + "101265" : [ "21:05", "800000", "110420" ], + "101266" : [ "21:06", "800000", "110420" ], + "101267" : [ "21:07", "800000", "110420" ], + "101268" : [ "21:08", "800000", "110420" ], + "101269" : [ "21:09", "800000", "110420" ], + "101270" : [ "21:10", "800000", "110420" ], + "101271" : [ "21:11", "800000", "110420" ], + "101272" : [ "21:12", "800000", "110420" ], + "101273" : [ "21:13", "800000", "110420" ], + "101274" : [ "21:14", "800000", "110420" ], + "101275" : [ "21:15", "800000", "110420" ], + "101276" : [ "21:16", "800000", "110420" ], + "101277" : [ "21:17", "800000", "110420" ], + "101278" : [ "21:18", "800000", "110420" ], + "101279" : [ "21:19", "800000", "110420" ], + "101280" : [ "21:20", "800000", "110420" ], + "101281" : [ "21:21", "800000", "110420" ], + "101282" : [ "21:22", "800000", "110420" ], + "101283" : [ "21:23", "800000", "110420" ], + "101284" : [ "21:24", "800000", "110420" ], + "101285" : [ "21:25", "800000", "110420" ], + "101286" : [ "21:26", "800000", "110420" ], + "101287" : [ "21:27", "800000", "110420" ], + "101288" : [ "21:28", "800000", "110420" ], + "101289" : [ "21:29", "800000", "110420" ], + "101290" : [ "21:30", "800000", "110420" ], + "101291" : [ "21:31", "800000", "110420" ], + "101292" : [ "21:32", "800000", "110420" ], + "101293" : [ "21:33", "800000", "110420" ], + "101294" : [ "21:34", "800000", "110420" ], + "101295" : [ "21:35", "800000", "110420" ], + "101296" : [ "21:36", "800000", "110420" ], + "101297" : [ "21:37", "800000", "110420" ], + "101298" : [ "21:38", "800000", "110420" ], + "101299" : [ "21:39", "800000", "110420" ], + "101300" : [ "21:40", "800000", "110420" ], + "101301" : [ "21:41", "800000", "110420" ], + "101302" : [ "21:42", "800000", "110420" ], + "101303" : [ "21:43", "800000", "110420" ], + "101304" : [ "21:44", "800000", "110420" ], + "101305" : [ "21:45", "800000", "110420" ], + "101306" : [ "21:46", "800000", "110420" ], + "101307" : [ "21:47", "800000", "110420" ], + "101308" : [ "21:48", "800000", "110420" ], + "101309" : [ "21:49", "800000", "110420" ], + "101310" : [ "21:50", "800000", "110420" ], + "101311" : [ "21:51", "800000", "110420" ], + "101312" : [ "21:52", "800000", "110420" ], + "101313" : [ "21:53", "800000", "110420" ], + "101314" : [ "21:54", "800000", "110420" ], + "101315" : [ "21:55", "800000", "110420" ], + "101316" : [ "21:56", "800000", "110420" ], + "101317" : [ "21:57", "800000", "110420" ], + "101318" : [ "21:58", "800000", "110420" ], + "101319" : [ "21:59", "800000", "110420" ], + "101320" : [ "22:00", "800000", "110420" ], + "101321" : [ "22:01", "800000", "110420" ], + "101322" : [ "22:02", "800000", "110420" ], + "101323" : [ "22:03", "800000", "110420" ], + "101324" : [ "22:04", "800000", "110420" ], + "101325" : [ "22:05", "800000", "110420" ], + "101326" : [ "22:06", "800000", "110420" ], + "101327" : [ "22:07", "800000", "110420" ], + "101328" : [ "22:08", "800000", "110420" ], + "101329" : [ "22:09", "800000", "110420" ], + "101330" : [ "22:10", "800000", "110420" ], + "101331" : [ "22:11", "800000", "110420" ], + "101332" : [ "22:12", "800000", "110420" ], + "101333" : [ "22:13", "800000", "110420" ], + "101334" : [ "22:14", "800000", "110420" ], + "101335" : [ "22:15", "800000", "110420" ], + "101336" : [ "22:16", "800000", "110420" ], + "101337" : [ "22:17", "800000", "110420" ], + "101338" : [ "22:18", "800000", "110420" ], + "101339" : [ "22:19", "800000", "110420" ], + "101340" : [ "22:20", "800000", "110420" ], + "101341" : [ "22:21", "800000", "110420" ], + "101342" : [ "22:22", "800000", "110420" ], + "101343" : [ "22:23", "800000", "110420" ], + "101344" : [ "22:24", "800000", "110420" ], + "101345" : [ "22:25", "800000", "110420" ], + "101346" : [ "22:26", "800000", "110420" ], + "101347" : [ "22:27", "800000", "110420" ], + "101348" : [ "22:28", "800000", "110420" ], + "101349" : [ "22:29", "800000", "110420" ], + "101350" : [ "22:30", "800000", "110420" ], + "101351" : [ "22:31", "800000", "110420" ], + "101352" : [ "22:32", "800000", "110420" ], + "101353" : [ "22:33", "800000", "110420" ], + "101354" : [ "22:34", "800000", "110420" ], + "101355" : [ "22:35", "800000", "110420" ], + "101356" : [ "22:36", "800000", "110420" ], + "101357" : [ "22:37", "800000", "110420" ], + "101358" : [ "22:38", "800000", "110420" ], + "101359" : [ "22:39", "800000", "110420" ], + "101360" : [ "22:40", "800000", "110420" ], + "101361" : [ "22:41", "800000", "110420" ], + "101362" : [ "22:42", "800000", "110420" ], + "101363" : [ "22:43", "800000", "110420" ], + "101364" : [ "22:44", "800000", "110420" ], + "101365" : [ "22:45", "800000", "110420" ], + "101366" : [ "22:46", "800000", "110420" ], + "101367" : [ "22:47", "800000", "110420" ], + "101368" : [ "22:48", "800000", "110420" ], + "101369" : [ "22:49", "800000", "110420" ], + "101370" : [ "22:50", "800000", "110420" ], + "101371" : [ "22:51", "800000", "110420" ], + "101372" : [ "22:52", "800000", "110420" ], + "101373" : [ "22:53", "800000", "110420" ], + "101374" : [ "22:54", "800000", "110420" ], + "101375" : [ "22:55", "800000", "110420" ], + "101376" : [ "22:56", "800000", "110420" ], + "101377" : [ "22:57", "800000", "110420" ], + "101378" : [ "22:58", "800000", "110420" ], + "101379" : [ "22:59", "800000", "110420" ], + "101380" : [ "23:00", "800000", "110420" ], + "101381" : [ "23:01", "800000", "110420" ], + "101382" : [ "23:02", "800000", "110420" ], + "101383" : [ "23:03", "800000", "110420" ], + "101384" : [ "23:04", "800000", "110420" ], + "101385" : [ "23:05", "800000", "110420" ], + "101386" : [ "23:06", "800000", "110420" ], + "101387" : [ "23:07", "800000", "110420" ], + "101388" : [ "23:08", "800000", "110420" ], + "101389" : [ "23:09", "800000", "110420" ], + "101390" : [ "23:10", "800000", "110420" ], + "101391" : [ "23:11", "800000", "110420" ], + "101392" : [ "23:12", "800000", "110420" ], + "101393" : [ "23:13", "800000", "110420" ], + "101394" : [ "23:14", "800000", "110420" ], + "101395" : [ "23:15", "800000", "110420" ], + "101396" : [ "23:16", "800000", "110420" ], + "101397" : [ "23:17", "800000", "110420" ], + "101398" : [ "23:18", "800000", "110420" ], + "101399" : [ "23:19", "800000", "110420" ], + "101400" : [ "23:20", "800000", "110420" ], + "101401" : [ "23:21", "800000", "110420" ], + "101402" : [ "23:22", "800000", "110420" ], + "101403" : [ "23:23", "800000", "110420" ], + "101404" : [ "23:24", "800000", "110420" ], + "101405" : [ "23:25", "800000", "110420" ], + "101406" : [ "23:26", "800000", "110420" ], + "101407" : [ "23:27", "800000", "110420" ], + "101408" : [ "23:28", "800000", "110420" ], + "101409" : [ "23:29", "800000", "110420" ], + "101410" : [ "23:30", "800000", "110420" ], + "101411" : [ "23:31", "800000", "110420" ], + "101412" : [ "23:32", "800000", "110420" ], + "101413" : [ "23:33", "800000", "110420" ], + "101414" : [ "23:34", "800000", "110420" ], + "101415" : [ "23:35", "800000", "110420" ], + "101416" : [ "23:36", "800000", "110420" ], + "101417" : [ "23:37", "800000", "110420" ], + "101418" : [ "23:38", "800000", "110420" ], + "101419" : [ "23:39", "800000", "110420" ], + "101420" : [ "23:40", "800000", "110420" ], + "101421" : [ "23:41", "800000", "110420" ], + "101422" : [ "23:42", "800000", "110420" ], + "101423" : [ "23:43", "800000", "110420" ], + "101424" : [ "23:44", "800000", "110420" ], + "101425" : [ "23:45", "800000", "110420" ], + "101426" : [ "23:46", "800000", "110420" ], + "101427" : [ "23:47", "800000", "110420" ], + "101428" : [ "23:48", "800000", "110420" ], + "101429" : [ "23:49", "800000", "110420" ], + "101430" : [ "23:50", "800000", "110420" ], + "101431" : [ "23:51", "800000", "110420" ], + "101432" : [ "23:52", "800000", "110420" ], + "101433" : [ "23:53", "800000", "110420" ], + "101434" : [ "23:54", "800000", "110420" ], + "101435" : [ "23:55", "800000", "110420" ], + "101436" : [ "23:56", "800000", "110420" ], + "101437" : [ "23:57", "800000", "110420" ], + "101438" : [ "23:58", "800000", "110420" ], + "101439" : [ "23:59", "800000", "110420" ] + }, + "Tuesday": { + "110000" : [ "00:00", "800000", "110420" ], + "110001" : [ "00:01", "800000", "110420" ], + "110002" : [ "00:02", "800000", "110420" ], + "110003" : [ "00:03", "800000", "110420" ], + "110004" : [ "00:04", "800000", "110420" ], + "110005" : [ "00:05", "800000", "110420" ], + "110006" : [ "00:06", "800000", "110420" ], + "110007" : [ "00:07", "800000", "110420" ], + "110008" : [ "00:08", "800000", "110420" ], + "110009" : [ "00:09", "800000", "110420" ], + "110010" : [ "00:10", "800000", "110420" ], + "110011" : [ "00:11", "800000", "110420" ], + "110012" : [ "00:12", "800000", "110420" ], + "110013" : [ "00:13", "800000", "110420" ], + "110014" : [ "00:14", "800000", "110420" ], + "110015" : [ "00:15", "800000", "110420" ], + "110016" : [ "00:16", "800000", "110420" ], + "110017" : [ "00:17", "800000", "110420" ], + "110018" : [ "00:18", "800000", "110420" ], + "110019" : [ "00:19", "800000", "110420" ], + "110020" : [ "00:20", "800000", "110420" ], + "110021" : [ "00:21", "800000", "110420" ], + "110022" : [ "00:22", "800000", "110420" ], + "110023" : [ "00:23", "800000", "110420" ], + "110024" : [ "00:24", "800000", "110420" ], + "110025" : [ "00:25", "800000", "110420" ], + "110026" : [ "00:26", "800000", "110420" ], + "110027" : [ "00:27", "800000", "110420" ], + "110028" : [ "00:28", "800000", "110420" ], + "110029" : [ "00:29", "800000", "110420" ], + "110030" : [ "00:30", "800000", "110420" ], + "110031" : [ "00:31", "800000", "110420" ], + "110032" : [ "00:32", "800000", "110420" ], + "110033" : [ "00:33", "800000", "110420" ], + "110034" : [ "00:34", "800000", "110420" ], + "110035" : [ "00:35", "800000", "110420" ], + "110036" : [ "00:36", "800000", "110420" ], + "110037" : [ "00:37", "800000", "110420" ], + "110038" : [ "00:38", "800000", "110420" ], + "110039" : [ "00:39", "800000", "110420" ], + "110040" : [ "00:40", "800000", "110420" ], + "110041" : [ "00:41", "800000", "110420" ], + "110042" : [ "00:42", "800000", "110420" ], + "110043" : [ "00:43", "800000", "110420" ], + "110044" : [ "00:44", "800000", "110420" ], + "110045" : [ "00:45", "800000", "110420" ], + "110046" : [ "00:46", "800000", "110420" ], + "110047" : [ "00:47", "800000", "110420" ], + "110048" : [ "00:48", "800000", "110420" ], + "110049" : [ "00:49", "800000", "110420" ], + "110050" : [ "00:50", "800000", "110420" ], + "110051" : [ "00:51", "800000", "110420" ], + "110052" : [ "00:52", "800000", "110420" ], + "110053" : [ "00:53", "800000", "110420" ], + "110054" : [ "00:54", "800000", "110420" ], + "110055" : [ "00:55", "800000", "110420" ], + "110056" : [ "00:56", "800000", "110420" ], + "110057" : [ "00:57", "800000", "110420" ], + "110058" : [ "00:58", "800000", "110420" ], + "110059" : [ "00:59", "800000", "110420" ], + "110060" : [ "01:00", "800000", "110420" ], + "110061" : [ "01:01", "800000", "110420" ], + "110062" : [ "01:02", "800000", "110420" ], + "110063" : [ "01:03", "800000", "110420" ], + "110064" : [ "01:04", "800000", "110420" ], + "110065" : [ "01:05", "800000", "110420" ], + "110066" : [ "01:06", "800000", "110420" ], + "110067" : [ "01:07", "800000", "110420" ], + "110068" : [ "01:08", "800000", "110420" ], + "110069" : [ "01:09", "800000", "110420" ], + "110070" : [ "01:10", "800000", "110420" ], + "110071" : [ "01:11", "800000", "110420" ], + "110072" : [ "01:12", "800000", "110420" ], + "110073" : [ "01:13", "800000", "110420" ], + "110074" : [ "01:14", "800000", "110420" ], + "110075" : [ "01:15", "800000", "110420" ], + "110076" : [ "01:16", "800000", "110420" ], + "110077" : [ "01:17", "800000", "110420" ], + "110078" : [ "01:18", "800000", "110420" ], + "110079" : [ "01:19", "800000", "110420" ], + "110080" : [ "01:20", "800000", "110420" ], + "110081" : [ "01:21", "800000", "110420" ], + "110082" : [ "01:22", "800000", "110420" ], + "110083" : [ "01:23", "800000", "110420" ], + "110084" : [ "01:24", "800000", "110420" ], + "110085" : [ "01:25", "800000", "110420" ], + "110086" : [ "01:26", "800000", "110420" ], + "110087" : [ "01:27", "800000", "110420" ], + "110088" : [ "01:28", "800000", "110420" ], + "110089" : [ "01:29", "800000", "110420" ], + "110090" : [ "01:30", "800000", "110420" ], + "110091" : [ "01:31", "800000", "110420" ], + "110092" : [ "01:32", "800000", "110420" ], + "110093" : [ "01:33", "800000", "110420" ], + "110094" : [ "01:34", "800000", "110420" ], + "110095" : [ "01:35", "800000", "110420" ], + "110096" : [ "01:36", "800000", "110420" ], + "110097" : [ "01:37", "800000", "110420" ], + "110098" : [ "01:38", "800000", "110420" ], + "110099" : [ "01:39", "800000", "110420" ], + "110100" : [ "01:40", "800000", "110420" ], + "110101" : [ "01:41", "800000", "110420" ], + "110102" : [ "01:42", "800000", "110420" ], + "110103" : [ "01:43", "800000", "110420" ], + "110104" : [ "01:44", "800000", "110420" ], + "110105" : [ "01:45", "800000", "110420" ], + "110106" : [ "01:46", "800000", "110420" ], + "110107" : [ "01:47", "800000", "110420" ], + "110108" : [ "01:48", "800000", "110420" ], + "110109" : [ "01:49", "800000", "110420" ], + "110110" : [ "01:50", "800000", "110420" ], + "110111" : [ "01:51", "800000", "110420" ], + "110112" : [ "01:52", "800000", "110420" ], + "110113" : [ "01:53", "800000", "110420" ], + "110114" : [ "01:54", "800000", "110420" ], + "110115" : [ "01:55", "800000", "110420" ], + "110116" : [ "01:56", "800000", "110420" ], + "110117" : [ "01:57", "800000", "110420" ], + "110118" : [ "01:58", "800000", "110420" ], + "110119" : [ "01:59", "800000", "110420" ], + "110120" : [ "02:00", "800000", "110420" ], + "110121" : [ "02:01", "800000", "110420" ], + "110122" : [ "02:02", "800000", "110420" ], + "110123" : [ "02:03", "800000", "110420" ], + "110124" : [ "02:04", "800000", "110420" ], + "110125" : [ "02:05", "800000", "110420" ], + "110126" : [ "02:06", "800000", "110420" ], + "110127" : [ "02:07", "800000", "110420" ], + "110128" : [ "02:08", "800000", "110420" ], + "110129" : [ "02:09", "800000", "110420" ], + "110130" : [ "02:10", "800000", "110420" ], + "110131" : [ "02:11", "800000", "110420" ], + "110132" : [ "02:12", "800000", "110420" ], + "110133" : [ "02:13", "800000", "110420" ], + "110134" : [ "02:14", "800000", "110420" ], + "110135" : [ "02:15", "800000", "110420" ], + "110136" : [ "02:16", "800000", "110420" ], + "110137" : [ "02:17", "800000", "110420" ], + "110138" : [ "02:18", "800000", "110420" ], + "110139" : [ "02:19", "800000", "110420" ], + "110140" : [ "02:20", "800000", "110420" ], + "110141" : [ "02:21", "800000", "110420" ], + "110142" : [ "02:22", "800000", "110420" ], + "110143" : [ "02:23", "800000", "110420" ], + "110144" : [ "02:24", "800000", "110420" ], + "110145" : [ "02:25", "800000", "110420" ], + "110146" : [ "02:26", "800000", "110420" ], + "110147" : [ "02:27", "800000", "110420" ], + "110148" : [ "02:28", "800000", "110420" ], + "110149" : [ "02:29", "800000", "110420" ], + "110150" : [ "02:30", "800000", "110420" ], + "110151" : [ "02:31", "800000", "110420" ], + "110152" : [ "02:32", "800000", "110420" ], + "110153" : [ "02:33", "800000", "110420" ], + "110154" : [ "02:34", "800000", "110420" ], + "110155" : [ "02:35", "800000", "110420" ], + "110156" : [ "02:36", "800000", "110420" ], + "110157" : [ "02:37", "800000", "110420" ], + "110158" : [ "02:38", "800000", "110420" ], + "110159" : [ "02:39", "800000", "110420" ], + "110160" : [ "02:40", "800000", "110420" ], + "110161" : [ "02:41", "800000", "110420" ], + "110162" : [ "02:42", "800000", "110420" ], + "110163" : [ "02:43", "800000", "110420" ], + "110164" : [ "02:44", "800000", "110420" ], + "110165" : [ "02:45", "800000", "110420" ], + "110166" : [ "02:46", "800000", "110420" ], + "110167" : [ "02:47", "800000", "110420" ], + "110168" : [ "02:48", "800000", "110420" ], + "110169" : [ "02:49", "800000", "110420" ], + "110170" : [ "02:50", "800000", "110420" ], + "110171" : [ "02:51", "800000", "110420" ], + "110172" : [ "02:52", "800000", "110420" ], + "110173" : [ "02:53", "800000", "110420" ], + "110174" : [ "02:54", "800000", "110420" ], + "110175" : [ "02:55", "800000", "110420" ], + "110176" : [ "02:56", "800000", "110420" ], + "110177" : [ "02:57", "800000", "110420" ], + "110178" : [ "02:58", "800000", "110420" ], + "110179" : [ "02:59", "800000", "110420" ], + "110180" : [ "03:00", "800000", "110420" ], + "110181" : [ "03:01", "800000", "110420" ], + "110182" : [ "03:02", "800000", "110420" ], + "110183" : [ "03:03", "800000", "110420" ], + "110184" : [ "03:04", "800000", "110420" ], + "110185" : [ "03:05", "800000", "110420" ], + "110186" : [ "03:06", "800000", "110420" ], + "110187" : [ "03:07", "800000", "110420" ], + "110188" : [ "03:08", "800000", "110420" ], + "110189" : [ "03:09", "800000", "110420" ], + "110190" : [ "03:10", "800000", "110420" ], + "110191" : [ "03:11", "800000", "110420" ], + "110192" : [ "03:12", "800000", "110420" ], + "110193" : [ "03:13", "800000", "110420" ], + "110194" : [ "03:14", "800000", "110420" ], + "110195" : [ "03:15", "800000", "110420" ], + "110196" : [ "03:16", "800000", "110420" ], + "110197" : [ "03:17", "800000", "110420" ], + "110198" : [ "03:18", "800000", "110420" ], + "110199" : [ "03:19", "800000", "110420" ], + "110200" : [ "03:20", "800000", "110420" ], + "110201" : [ "03:21", "800000", "110420" ], + "110202" : [ "03:22", "800000", "110420" ], + "110203" : [ "03:23", "800000", "110420" ], + "110204" : [ "03:24", "800000", "110420" ], + "110205" : [ "03:25", "800000", "110420" ], + "110206" : [ "03:26", "800000", "110420" ], + "110207" : [ "03:27", "800000", "110420" ], + "110208" : [ "03:28", "800000", "110420" ], + "110209" : [ "03:29", "800000", "110420" ], + "110210" : [ "03:30", "800000", "110420" ], + "110211" : [ "03:31", "800000", "110420" ], + "110212" : [ "03:32", "800000", "110420" ], + "110213" : [ "03:33", "800000", "110420" ], + "110214" : [ "03:34", "800000", "110420" ], + "110215" : [ "03:35", "800000", "110420" ], + "110216" : [ "03:36", "800000", "110420" ], + "110217" : [ "03:37", "800000", "110420" ], + "110218" : [ "03:38", "800000", "110420" ], + "110219" : [ "03:39", "800000", "110420" ], + "110220" : [ "03:40", "800000", "110420" ], + "110221" : [ "03:41", "800000", "110420" ], + "110222" : [ "03:42", "800000", "110420" ], + "110223" : [ "03:43", "800000", "110420" ], + "110224" : [ "03:44", "800000", "110420" ], + "110225" : [ "03:45", "800000", "110420" ], + "110226" : [ "03:46", "800000", "110420" ], + "110227" : [ "03:47", "800000", "110420" ], + "110228" : [ "03:48", "800000", "110420" ], + "110229" : [ "03:49", "800000", "110420" ], + "110230" : [ "03:50", "800000", "110420" ], + "110231" : [ "03:51", "800000", "110420" ], + "110232" : [ "03:52", "800000", "110420" ], + "110233" : [ "03:53", "800000", "110420" ], + "110234" : [ "03:54", "800000", "110420" ], + "110235" : [ "03:55", "800000", "110420" ], + "110236" : [ "03:56", "800000", "110420" ], + "110237" : [ "03:57", "800000", "110420" ], + "110238" : [ "03:58", "800000", "110420" ], + "110239" : [ "03:59", "800000", "110420" ], + "110240" : [ "04:00", "800000", "110420" ], + "110241" : [ "04:01", "800000", "110420" ], + "110242" : [ "04:02", "800000", "110420" ], + "110243" : [ "04:03", "800000", "110420" ], + "110244" : [ "04:04", "800000", "110420" ], + "110245" : [ "04:05", "800000", "110420" ], + "110246" : [ "04:06", "800000", "110420" ], + "110247" : [ "04:07", "800000", "110420" ], + "110248" : [ "04:08", "800000", "110420" ], + "110249" : [ "04:09", "800000", "110420" ], + "110250" : [ "04:10", "800000", "110420" ], + "110251" : [ "04:11", "800000", "110420" ], + "110252" : [ "04:12", "800000", "110420" ], + "110253" : [ "04:13", "800000", "110420" ], + "110254" : [ "04:14", "800000", "110420" ], + "110255" : [ "04:15", "800000", "110420" ], + "110256" : [ "04:16", "800000", "110420" ], + "110257" : [ "04:17", "800000", "110420" ], + "110258" : [ "04:18", "800000", "110420" ], + "110259" : [ "04:19", "800000", "110420" ], + "110260" : [ "04:20", "800000", "110420" ], + "110261" : [ "04:21", "800000", "110420" ], + "110262" : [ "04:22", "800000", "110420" ], + "110263" : [ "04:23", "800000", "110420" ], + "110264" : [ "04:24", "800000", "110420" ], + "110265" : [ "04:25", "800000", "110420" ], + "110266" : [ "04:26", "800000", "110420" ], + "110267" : [ "04:27", "800000", "110420" ], + "110268" : [ "04:28", "800000", "110420" ], + "110269" : [ "04:29", "800000", "110420" ], + "110270" : [ "04:30", "800000", "110420" ], + "110271" : [ "04:31", "800000", "110420" ], + "110272" : [ "04:32", "800000", "110420" ], + "110273" : [ "04:33", "800000", "110420" ], + "110274" : [ "04:34", "800000", "110420" ], + "110275" : [ "04:35", "800000", "110420" ], + "110276" : [ "04:36", "800000", "110420" ], + "110277" : [ "04:37", "800000", "110420" ], + "110278" : [ "04:38", "800000", "110420" ], + "110279" : [ "04:39", "800000", "110420" ], + "110280" : [ "04:40", "800000", "110420" ], + "110281" : [ "04:41", "800000", "110420" ], + "110282" : [ "04:42", "800000", "110420" ], + "110283" : [ "04:43", "800000", "110420" ], + "110284" : [ "04:44", "800000", "110420" ], + "110285" : [ "04:45", "800000", "110420" ], + "110286" : [ "04:46", "800000", "110420" ], + "110287" : [ "04:47", "800000", "110420" ], + "110288" : [ "04:48", "800000", "110420" ], + "110289" : [ "04:49", "800000", "110420" ], + "110290" : [ "04:50", "800000", "110420" ], + "110291" : [ "04:51", "800000", "110420" ], + "110292" : [ "04:52", "800000", "110420" ], + "110293" : [ "04:53", "800000", "110420" ], + "110294" : [ "04:54", "800000", "110420" ], + "110295" : [ "04:55", "800000", "110420" ], + "110296" : [ "04:56", "800000", "110420" ], + "110297" : [ "04:57", "800000", "110420" ], + "110298" : [ "04:58", "800000", "110420" ], + "110299" : [ "04:59", "800000", "110420" ], + "110300" : [ "05:00", "800000", "110420" ], + "110301" : [ "05:01", "800000", "110420" ], + "110302" : [ "05:02", "800000", "110420" ], + "110303" : [ "05:03", "800000", "110420" ], + "110304" : [ "05:04", "800000", "110420" ], + "110305" : [ "05:05", "800000", "110420" ], + "110306" : [ "05:06", "800000", "110420" ], + "110307" : [ "05:07", "800000", "110420" ], + "110308" : [ "05:08", "800000", "110420" ], + "110309" : [ "05:09", "800000", "110420" ], + "110310" : [ "05:10", "800000", "110420" ], + "110311" : [ "05:11", "800000", "110420" ], + "110312" : [ "05:12", "800000", "110420" ], + "110313" : [ "05:13", "800000", "110420" ], + "110314" : [ "05:14", "800000", "110420" ], + "110315" : [ "05:15", "800000", "110420" ], + "110316" : [ "05:16", "800000", "110420" ], + "110317" : [ "05:17", "800000", "110420" ], + "110318" : [ "05:18", "800000", "110420" ], + "110319" : [ "05:19", "800000", "110420" ], + "110320" : [ "05:20", "800000", "110420" ], + "110321" : [ "05:21", "800000", "110420" ], + "110322" : [ "05:22", "800000", "110420" ], + "110323" : [ "05:23", "800000", "110420" ], + "110324" : [ "05:24", "800000", "110420" ], + "110325" : [ "05:25", "800000", "110420" ], + "110326" : [ "05:26", "800000", "110420" ], + "110327" : [ "05:27", "800000", "110420" ], + "110328" : [ "05:28", "800000", "110420" ], + "110329" : [ "05:29", "800000", "110420" ], + "110330" : [ "05:30", "800000", "110420" ], + "110331" : [ "05:31", "800000", "110420" ], + "110332" : [ "05:32", "800000", "110420" ], + "110333" : [ "05:33", "800000", "110420" ], + "110334" : [ "05:34", "800000", "110420" ], + "110335" : [ "05:35", "800000", "110420" ], + "110336" : [ "05:36", "800000", "110420" ], + "110337" : [ "05:37", "800000", "110420" ], + "110338" : [ "05:38", "800000", "110420" ], + "110339" : [ "05:39", "800000", "110420" ], + "110340" : [ "05:40", "800000", "110420" ], + "110341" : [ "05:41", "800000", "110420" ], + "110342" : [ "05:42", "800000", "110420" ], + "110343" : [ "05:43", "800000", "110420" ], + "110344" : [ "05:44", "800000", "110420" ], + "110345" : [ "05:45", "800000", "110420" ], + "110346" : [ "05:46", "800000", "110420" ], + "110347" : [ "05:47", "800000", "110420" ], + "110348" : [ "05:48", "800000", "110420" ], + "110349" : [ "05:49", "800000", "110420" ], + "110350" : [ "05:50", "800000", "110420" ], + "110351" : [ "05:51", "800000", "110420" ], + "110352" : [ "05:52", "800000", "110420" ], + "110353" : [ "05:53", "800000", "110420" ], + "110354" : [ "05:54", "800000", "110420" ], + "110355" : [ "05:55", "800000", "110420" ], + "110356" : [ "05:56", "800000", "110420" ], + "110357" : [ "05:57", "800000", "110420" ], + "110358" : [ "05:58", "800000", "110420" ], + "110359" : [ "05:59", "800000", "110420" ], + "110360" : [ "06:00", "800000", "110420" ], + "110361" : [ "06:01", "800000", "110420" ], + "110362" : [ "06:02", "800000", "110420" ], + "110363" : [ "06:03", "800000", "110420" ], + "110364" : [ "06:04", "800000", "110420" ], + "110365" : [ "06:05", "800000", "110420" ], + "110366" : [ "06:06", "800000", "110420" ], + "110367" : [ "06:07", "800000", "110420" ], + "110368" : [ "06:08", "800000", "110420" ], + "110369" : [ "06:09", "800000", "110420" ], + "110370" : [ "06:10", "800000", "110420" ], + "110371" : [ "06:11", "800000", "110420" ], + "110372" : [ "06:12", "800000", "110420" ], + "110373" : [ "06:13", "800000", "110420" ], + "110374" : [ "06:14", "800000", "110420" ], + "110375" : [ "06:15", "800000", "110420" ], + "110376" : [ "06:16", "800000", "110420" ], + "110377" : [ "06:17", "800000", "110420" ], + "110378" : [ "06:18", "800000", "110420" ], + "110379" : [ "06:19", "800000", "110420" ], + "110380" : [ "06:20", "800000", "110420" ], + "110381" : [ "06:21", "800000", "110420" ], + "110382" : [ "06:22", "800000", "110420" ], + "110383" : [ "06:23", "800000", "110420" ], + "110384" : [ "06:24", "800000", "110420" ], + "110385" : [ "06:25", "800000", "110420" ], + "110386" : [ "06:26", "800000", "110420" ], + "110387" : [ "06:27", "800000", "110420" ], + "110388" : [ "06:28", "800000", "110420" ], + "110389" : [ "06:29", "800000", "110420" ], + "110390" : [ "06:30", "800000", "110420" ], + "110391" : [ "06:31", "800000", "110420" ], + "110392" : [ "06:32", "800000", "110420" ], + "110393" : [ "06:33", "800000", "110420" ], + "110394" : [ "06:34", "800000", "110420" ], + "110395" : [ "06:35", "800000", "110420" ], + "110396" : [ "06:36", "800000", "110420" ], + "110397" : [ "06:37", "800000", "110420" ], + "110398" : [ "06:38", "800000", "110420" ], + "110399" : [ "06:39", "800000", "110420" ], + "110400" : [ "06:40", "800000", "110420" ], + "110401" : [ "06:41", "800000", "110420" ], + "110402" : [ "06:42", "800000", "110420" ], + "110403" : [ "06:43", "800000", "110420" ], + "110404" : [ "06:44", "800000", "110420" ], + "110405" : [ "06:45", "800000", "110420" ], + "110406" : [ "06:46", "800000", "110420" ], + "110407" : [ "06:47", "800000", "110420" ], + "110408" : [ "06:48", "800000", "110420" ], + "110409" : [ "06:49", "800000", "110420" ], + "110410" : [ "06:50", "800000", "110420" ], + "110411" : [ "06:51", "800000", "110420" ], + "110412" : [ "06:52", "800000", "110420" ], + "110413" : [ "06:53", "800000", "110420" ], + "110414" : [ "06:54", "800000", "110420" ], + "110415" : [ "06:55", "800000", "110420" ], + "110416" : [ "06:56", "800000", "110420" ], + "110417" : [ "06:57", "800000", "110420" ], + "110418" : [ "06:58", "800000", "110420" ], + "110419" : [ "06:59", "800000", "110420" ], + "110420" : [ "07:00", "350000", "110480" ], + "110421" : [ "07:01", "350000", "110481" ], + "110422" : [ "07:02", "350000", "110482" ], + "110423" : [ "07:03", "350000", "110483" ], + "110424" : [ "07:04", "350000", "110484" ], + "110425" : [ "07:05", "350000", "110485" ], + "110426" : [ "07:06", "350000", "110486" ], + "110427" : [ "07:07", "350000", "110487" ], + "110428" : [ "07:08", "350000", "110488" ], + "110429" : [ "07:09", "350000", "110489" ], + "110430" : [ "07:10", "350000", "110490" ], + "110431" : [ "07:11", "350000", "110491" ], + "110432" : [ "07:12", "350000", "110492" ], + "110433" : [ "07:13", "350000", "110493" ], + "110434" : [ "07:14", "350000", "110494" ], + "110435" : [ "07:15", "350000", "110495" ], + "110436" : [ "07:16", "350000", "110496" ], + "110437" : [ "07:17", "350000", "110497" ], + "110438" : [ "07:18", "350000", "110498" ], + "110439" : [ "07:19", "350000", "110499" ], + "110440" : [ "07:20", "350000", "110500" ], + "110441" : [ "07:21", "350000", "110501" ], + "110442" : [ "07:22", "350000", "110502" ], + "110443" : [ "07:23", "350000", "110503" ], + "110444" : [ "07:24", "350000", "110504" ], + "110445" : [ "07:25", "350000", "110505" ], + "110446" : [ "07:26", "350000", "110506" ], + "110447" : [ "07:27", "350000", "110507" ], + "110448" : [ "07:28", "350000", "110508" ], + "110449" : [ "07:29", "350000", "110509" ], + "110450" : [ "07:30", "350000", "110510" ], + "110451" : [ "07:31", "350000", "110511" ], + "110452" : [ "07:32", "350000", "110512" ], + "110453" : [ "07:33", "350000", "110513" ], + "110454" : [ "07:34", "350000", "110514" ], + "110455" : [ "07:35", "350000", "110515" ], + "110456" : [ "07:36", "350000", "110516" ], + "110457" : [ "07:37", "350000", "110517" ], + "110458" : [ "07:38", "350000", "110518" ], + "110459" : [ "07:39", "350000", "110519" ], + "110460" : [ "07:40", "350000", "110520" ], + "110461" : [ "07:41", "350000", "110521" ], + "110462" : [ "07:42", "350000", "110522" ], + "110463" : [ "07:43", "350000", "110523" ], + "110464" : [ "07:44", "350000", "110524" ], + "110465" : [ "07:45", "350000", "110525" ], + "110466" : [ "07:46", "350000", "110526" ], + "110467" : [ "07:47", "350000", "110527" ], + "110468" : [ "07:48", "350000", "110528" ], + "110469" : [ "07:49", "350000", "110529" ], + "110470" : [ "07:50", "350000", "110530" ], + "110471" : [ "07:51", "350000", "110531" ], + "110472" : [ "07:52", "350000", "110532" ], + "110473" : [ "07:53", "350000", "110533" ], + "110474" : [ "07:54", "350000", "110534" ], + "110475" : [ "07:55", "350000", "110535" ], + "110476" : [ "07:56", "350000", "110536" ], + "110477" : [ "07:57", "350000", "110537" ], + "110478" : [ "07:58", "350000", "110538" ], + "110479" : [ "07:59", "350000", "110539" ], + "110480" : [ "08:00", "350000", "110540" ], + "110481" : [ "08:01", "350000", "110541" ], + "110482" : [ "08:02", "350000", "110542" ], + "110483" : [ "08:03", "350000", "110543" ], + "110484" : [ "08:04", "350000", "110544" ], + "110485" : [ "08:05", "350000", "110545" ], + "110486" : [ "08:06", "350000", "110546" ], + "110487" : [ "08:07", "350000", "110547" ], + "110488" : [ "08:08", "350000", "110548" ], + "110489" : [ "08:09", "350000", "110549" ], + "110490" : [ "08:10", "350000", "110550" ], + "110491" : [ "08:11", "350000", "110551" ], + "110492" : [ "08:12", "350000", "110552" ], + "110493" : [ "08:13", "350000", "110553" ], + "110494" : [ "08:14", "350000", "110554" ], + "110495" : [ "08:15", "350000", "110555" ], + "110496" : [ "08:16", "350000", "110556" ], + "110497" : [ "08:17", "350000", "110557" ], + "110498" : [ "08:18", "350000", "110558" ], + "110499" : [ "08:19", "350000", "110559" ], + "110500" : [ "08:20", "350000", "110560" ], + "110501" : [ "08:21", "350000", "110561" ], + "110502" : [ "08:22", "350000", "110562" ], + "110503" : [ "08:23", "350000", "110563" ], + "110504" : [ "08:24", "350000", "110564" ], + "110505" : [ "08:25", "350000", "110565" ], + "110506" : [ "08:26", "350000", "110566" ], + "110507" : [ "08:27", "350000", "110567" ], + "110508" : [ "08:28", "350000", "110568" ], + "110509" : [ "08:29", "350000", "110569" ], + "110510" : [ "08:30", "350000", "110570" ], + "110511" : [ "08:31", "350000", "110571" ], + "110512" : [ "08:32", "350000", "110572" ], + "110513" : [ "08:33", "350000", "110573" ], + "110514" : [ "08:34", "350000", "110574" ], + "110515" : [ "08:35", "350000", "110575" ], + "110516" : [ "08:36", "350000", "110576" ], + "110517" : [ "08:37", "350000", "110577" ], + "110518" : [ "08:38", "350000", "110578" ], + "110519" : [ "08:39", "350000", "110579" ], + "110520" : [ "08:40", "350000", "110580" ], + "110521" : [ "08:41", "350000", "110581" ], + "110522" : [ "08:42", "350000", "110582" ], + "110523" : [ "08:43", "350000", "110583" ], + "110524" : [ "08:44", "350000", "110584" ], + "110525" : [ "08:45", "350000", "110585" ], + "110526" : [ "08:46", "350000", "110586" ], + "110527" : [ "08:47", "350000", "110587" ], + "110528" : [ "08:48", "350000", "110588" ], + "110529" : [ "08:49", "350000", "110589" ], + "110530" : [ "08:50", "350000", "110590" ], + "110531" : [ "08:51", "350000", "110591" ], + "110532" : [ "08:52", "350000", "110592" ], + "110533" : [ "08:53", "350000", "110593" ], + "110534" : [ "08:54", "350000", "110594" ], + "110535" : [ "08:55", "350000", "110595" ], + "110536" : [ "08:56", "350000", "110596" ], + "110537" : [ "08:57", "350000", "110597" ], + "110538" : [ "08:58", "350000", "110598" ], + "110539" : [ "08:59", "350000", "110599" ], + "110540" : [ "09:00", "350000", "110600" ], + "110541" : [ "09:01", "350000", "110601" ], + "110542" : [ "09:02", "350000", "110602" ], + "110543" : [ "09:03", "350000", "110603" ], + "110544" : [ "09:04", "350000", "110604" ], + "110545" : [ "09:05", "350000", "110605" ], + "110546" : [ "09:06", "350000", "110606" ], + "110547" : [ "09:07", "350000", "110607" ], + "110548" : [ "09:08", "350000", "110608" ], + "110549" : [ "09:09", "350000", "110609" ], + "110550" : [ "09:10", "350000", "110610" ], + "110551" : [ "09:11", "350000", "110611" ], + "110552" : [ "09:12", "350000", "110612" ], + "110553" : [ "09:13", "350000", "110613" ], + "110554" : [ "09:14", "350000", "110614" ], + "110555" : [ "09:15", "350000", "110615" ], + "110556" : [ "09:16", "350000", "110616" ], + "110557" : [ "09:17", "350000", "110617" ], + "110558" : [ "09:18", "350000", "110618" ], + "110559" : [ "09:19", "350000", "110619" ], + "110560" : [ "09:20", "350000", "110620" ], + "110561" : [ "09:21", "350000", "110621" ], + "110562" : [ "09:22", "350000", "110622" ], + "110563" : [ "09:23", "350000", "110623" ], + "110564" : [ "09:24", "350000", "110624" ], + "110565" : [ "09:25", "350000", "110625" ], + "110566" : [ "09:26", "350000", "110626" ], + "110567" : [ "09:27", "350000", "110627" ], + "110568" : [ "09:28", "350000", "110628" ], + "110569" : [ "09:29", "350000", "110629" ], + "110570" : [ "09:30", "350000", "110630" ], + "110571" : [ "09:31", "350000", "110631" ], + "110572" : [ "09:32", "350000", "110632" ], + "110573" : [ "09:33", "350000", "110633" ], + "110574" : [ "09:34", "350000", "110634" ], + "110575" : [ "09:35", "350000", "110635" ], + "110576" : [ "09:36", "350000", "110636" ], + "110577" : [ "09:37", "350000", "110637" ], + "110578" : [ "09:38", "350000", "110638" ], + "110579" : [ "09:39", "350000", "110639" ], + "110580" : [ "09:40", "350000", "110640" ], + "110581" : [ "09:41", "350000", "110641" ], + "110582" : [ "09:42", "350000", "110642" ], + "110583" : [ "09:43", "350000", "110643" ], + "110584" : [ "09:44", "350000", "110644" ], + "110585" : [ "09:45", "350000", "110645" ], + "110586" : [ "09:46", "350000", "110646" ], + "110587" : [ "09:47", "350000", "110647" ], + "110588" : [ "09:48", "350000", "110648" ], + "110589" : [ "09:49", "350000", "110649" ], + "110590" : [ "09:50", "350000", "110650" ], + "110591" : [ "09:51", "350000", "110651" ], + "110592" : [ "09:52", "350000", "110652" ], + "110593" : [ "09:53", "350000", "110653" ], + "110594" : [ "09:54", "350000", "110654" ], + "110595" : [ "09:55", "350000", "110655" ], + "110596" : [ "09:56", "350000", "110656" ], + "110597" : [ "09:57", "350000", "110657" ], + "110598" : [ "09:58", "350000", "110658" ], + "110599" : [ "09:59", "350000", "110659" ], + "110600" : [ "10:00", "350000", "110660" ], + "110601" : [ "10:01", "350000", "110661" ], + "110602" : [ "10:02", "350000", "110662" ], + "110603" : [ "10:03", "350000", "110663" ], + "110604" : [ "10:04", "350000", "110664" ], + "110605" : [ "10:05", "350000", "110665" ], + "110606" : [ "10:06", "350000", "110666" ], + "110607" : [ "10:07", "350000", "110667" ], + "110608" : [ "10:08", "350000", "110668" ], + "110609" : [ "10:09", "350000", "110669" ], + "110610" : [ "10:10", "350000", "110670" ], + "110611" : [ "10:11", "350000", "110671" ], + "110612" : [ "10:12", "350000", "110672" ], + "110613" : [ "10:13", "350000", "110673" ], + "110614" : [ "10:14", "350000", "110674" ], + "110615" : [ "10:15", "350000", "110675" ], + "110616" : [ "10:16", "350000", "110676" ], + "110617" : [ "10:17", "350000", "110677" ], + "110618" : [ "10:18", "350000", "110678" ], + "110619" : [ "10:19", "350000", "110679" ], + "110620" : [ "10:20", "350000", "110680" ], + "110621" : [ "10:21", "350000", "110681" ], + "110622" : [ "10:22", "350000", "110682" ], + "110623" : [ "10:23", "350000", "110683" ], + "110624" : [ "10:24", "350000", "110684" ], + "110625" : [ "10:25", "350000", "110685" ], + "110626" : [ "10:26", "350000", "110686" ], + "110627" : [ "10:27", "350000", "110687" ], + "110628" : [ "10:28", "350000", "110688" ], + "110629" : [ "10:29", "350000", "110689" ], + "110630" : [ "10:30", "350000", "110690" ], + "110631" : [ "10:31", "350000", "110691" ], + "110632" : [ "10:32", "350000", "110692" ], + "110633" : [ "10:33", "350000", "110693" ], + "110634" : [ "10:34", "350000", "110694" ], + "110635" : [ "10:35", "350000", "110695" ], + "110636" : [ "10:36", "350000", "110696" ], + "110637" : [ "10:37", "350000", "110697" ], + "110638" : [ "10:38", "350000", "110698" ], + "110639" : [ "10:39", "350000", "110699" ], + "110640" : [ "10:40", "350000", "110700" ], + "110641" : [ "10:41", "350000", "110701" ], + "110642" : [ "10:42", "350000", "110702" ], + "110643" : [ "10:43", "350000", "110703" ], + "110644" : [ "10:44", "350000", "110704" ], + "110645" : [ "10:45", "350000", "110705" ], + "110646" : [ "10:46", "350000", "110706" ], + "110647" : [ "10:47", "350000", "110707" ], + "110648" : [ "10:48", "350000", "110708" ], + "110649" : [ "10:49", "350000", "110709" ], + "110650" : [ "10:50", "350000", "110710" ], + "110651" : [ "10:51", "350000", "110711" ], + "110652" : [ "10:52", "350000", "110712" ], + "110653" : [ "10:53", "350000", "110713" ], + "110654" : [ "10:54", "350000", "110714" ], + "110655" : [ "10:55", "350000", "110715" ], + "110656" : [ "10:56", "350000", "110716" ], + "110657" : [ "10:57", "350000", "110717" ], + "110658" : [ "10:58", "350000", "110718" ], + "110659" : [ "10:59", "350000", "110719" ], + "110660" : [ "11:00", "350000", "110720" ], + "110661" : [ "11:01", "350000", "110721" ], + "110662" : [ "11:02", "350000", "110722" ], + "110663" : [ "11:03", "350000", "110723" ], + "110664" : [ "11:04", "350000", "110724" ], + "110665" : [ "11:05", "350000", "110725" ], + "110666" : [ "11:06", "350000", "110726" ], + "110667" : [ "11:07", "350000", "110727" ], + "110668" : [ "11:08", "350000", "110728" ], + "110669" : [ "11:09", "350000", "110729" ], + "110670" : [ "11:10", "350000", "110730" ], + "110671" : [ "11:11", "350000", "110731" ], + "110672" : [ "11:12", "350000", "110732" ], + "110673" : [ "11:13", "350000", "110733" ], + "110674" : [ "11:14", "350000", "110734" ], + "110675" : [ "11:15", "350000", "110735" ], + "110676" : [ "11:16", "350000", "110736" ], + "110677" : [ "11:17", "350000", "110737" ], + "110678" : [ "11:18", "350000", "110738" ], + "110679" : [ "11:19", "350000", "110739" ], + "110680" : [ "11:20", "350000", "110740" ], + "110681" : [ "11:21", "350000", "110741" ], + "110682" : [ "11:22", "350000", "110742" ], + "110683" : [ "11:23", "350000", "110743" ], + "110684" : [ "11:24", "350000", "110744" ], + "110685" : [ "11:25", "350000", "110745" ], + "110686" : [ "11:26", "350000", "110746" ], + "110687" : [ "11:27", "350000", "110747" ], + "110688" : [ "11:28", "350000", "110748" ], + "110689" : [ "11:29", "350000", "110749" ], + "110690" : [ "11:30", "350000", "110750" ], + "110691" : [ "11:31", "350000", "110751" ], + "110692" : [ "11:32", "350000", "110752" ], + "110693" : [ "11:33", "350000", "110753" ], + "110694" : [ "11:34", "350000", "110754" ], + "110695" : [ "11:35", "350000", "110755" ], + "110696" : [ "11:36", "350000", "110756" ], + "110697" : [ "11:37", "350000", "110757" ], + "110698" : [ "11:38", "350000", "110758" ], + "110699" : [ "11:39", "350000", "110759" ], + "110700" : [ "11:40", "350000", "110760" ], + "110701" : [ "11:41", "350000", "110761" ], + "110702" : [ "11:42", "350000", "110762" ], + "110703" : [ "11:43", "350000", "110763" ], + "110704" : [ "11:44", "350000", "110764" ], + "110705" : [ "11:45", "350000", "110765" ], + "110706" : [ "11:46", "350000", "110766" ], + "110707" : [ "11:47", "350000", "110767" ], + "110708" : [ "11:48", "350000", "110768" ], + "110709" : [ "11:49", "350000", "110769" ], + "110710" : [ "11:50", "350000", "110770" ], + "110711" : [ "11:51", "350000", "110771" ], + "110712" : [ "11:52", "350000", "110772" ], + "110713" : [ "11:53", "350000", "110773" ], + "110714" : [ "11:54", "350000", "110774" ], + "110715" : [ "11:55", "350000", "110775" ], + "110716" : [ "11:56", "350000", "110776" ], + "110717" : [ "11:57", "350000", "110777" ], + "110718" : [ "11:58", "350000", "110778" ], + "110719" : [ "11:59", "350000", "110779" ], + "110720" : [ "12:00", "350000", "110780" ], + "110721" : [ "12:01", "350000", "110781" ], + "110722" : [ "12:02", "350000", "110782" ], + "110723" : [ "12:03", "350000", "110783" ], + "110724" : [ "12:04", "350000", "110784" ], + "110725" : [ "12:05", "350000", "110785" ], + "110726" : [ "12:06", "350000", "110786" ], + "110727" : [ "12:07", "350000", "110787" ], + "110728" : [ "12:08", "350000", "110788" ], + "110729" : [ "12:09", "350000", "110789" ], + "110730" : [ "12:10", "350000", "110790" ], + "110731" : [ "12:11", "350000", "110791" ], + "110732" : [ "12:12", "350000", "110792" ], + "110733" : [ "12:13", "350000", "110793" ], + "110734" : [ "12:14", "350000", "110794" ], + "110735" : [ "12:15", "350000", "110795" ], + "110736" : [ "12:16", "350000", "110796" ], + "110737" : [ "12:17", "350000", "110797" ], + "110738" : [ "12:18", "350000", "110798" ], + "110739" : [ "12:19", "350000", "110799" ], + "110740" : [ "12:20", "350000", "110800" ], + "110741" : [ "12:21", "350000", "110801" ], + "110742" : [ "12:22", "350000", "110802" ], + "110743" : [ "12:23", "350000", "110803" ], + "110744" : [ "12:24", "350000", "110804" ], + "110745" : [ "12:25", "350000", "110805" ], + "110746" : [ "12:26", "350000", "110806" ], + "110747" : [ "12:27", "350000", "110807" ], + "110748" : [ "12:28", "350000", "110808" ], + "110749" : [ "12:29", "350000", "110809" ], + "110750" : [ "12:30", "350000", "110810" ], + "110751" : [ "12:31", "350000", "110811" ], + "110752" : [ "12:32", "350000", "110812" ], + "110753" : [ "12:33", "350000", "110813" ], + "110754" : [ "12:34", "350000", "110814" ], + "110755" : [ "12:35", "350000", "110815" ], + "110756" : [ "12:36", "350000", "110816" ], + "110757" : [ "12:37", "350000", "110817" ], + "110758" : [ "12:38", "350000", "110818" ], + "110759" : [ "12:39", "350000", "110819" ], + "110760" : [ "12:40", "350000", "110820" ], + "110761" : [ "12:41", "350000", "110821" ], + "110762" : [ "12:42", "350000", "110822" ], + "110763" : [ "12:43", "350000", "110823" ], + "110764" : [ "12:44", "350000", "110824" ], + "110765" : [ "12:45", "350000", "110825" ], + "110766" : [ "12:46", "350000", "110826" ], + "110767" : [ "12:47", "350000", "110827" ], + "110768" : [ "12:48", "350000", "110828" ], + "110769" : [ "12:49", "350000", "110829" ], + "110770" : [ "12:50", "350000", "110830" ], + "110771" : [ "12:51", "350000", "110831" ], + "110772" : [ "12:52", "350000", "110832" ], + "110773" : [ "12:53", "350000", "110833" ], + "110774" : [ "12:54", "350000", "110834" ], + "110775" : [ "12:55", "350000", "110835" ], + "110776" : [ "12:56", "350000", "110836" ], + "110777" : [ "12:57", "350000", "110837" ], + "110778" : [ "12:58", "350000", "110838" ], + "110779" : [ "12:59", "350000", "110839" ], + "110780" : [ "13:00", "350000", "110840" ], + "110781" : [ "13:01", "350000", "110841" ], + "110782" : [ "13:02", "350000", "110842" ], + "110783" : [ "13:03", "350000", "110843" ], + "110784" : [ "13:04", "350000", "110844" ], + "110785" : [ "13:05", "350000", "110845" ], + "110786" : [ "13:06", "350000", "110846" ], + "110787" : [ "13:07", "350000", "110847" ], + "110788" : [ "13:08", "350000", "110848" ], + "110789" : [ "13:09", "350000", "110849" ], + "110790" : [ "13:10", "350000", "110850" ], + "110791" : [ "13:11", "350000", "110851" ], + "110792" : [ "13:12", "350000", "110852" ], + "110793" : [ "13:13", "350000", "110853" ], + "110794" : [ "13:14", "350000", "110854" ], + "110795" : [ "13:15", "350000", "110855" ], + "110796" : [ "13:16", "350000", "110856" ], + "110797" : [ "13:17", "350000", "110857" ], + "110798" : [ "13:18", "350000", "110858" ], + "110799" : [ "13:19", "350000", "110859" ], + "110800" : [ "13:20", "350000", "110860" ], + "110801" : [ "13:21", "350000", "110861" ], + "110802" : [ "13:22", "350000", "110862" ], + "110803" : [ "13:23", "350000", "110863" ], + "110804" : [ "13:24", "350000", "110864" ], + "110805" : [ "13:25", "350000", "110865" ], + "110806" : [ "13:26", "350000", "110866" ], + "110807" : [ "13:27", "350000", "110867" ], + "110808" : [ "13:28", "350000", "110868" ], + "110809" : [ "13:29", "350000", "110869" ], + "110810" : [ "13:30", "350000", "110870" ], + "110811" : [ "13:31", "350000", "110871" ], + "110812" : [ "13:32", "350000", "110872" ], + "110813" : [ "13:33", "350000", "110873" ], + "110814" : [ "13:34", "350000", "110874" ], + "110815" : [ "13:35", "350000", "110875" ], + "110816" : [ "13:36", "350000", "110876" ], + "110817" : [ "13:37", "350000", "110877" ], + "110818" : [ "13:38", "350000", "110878" ], + "110819" : [ "13:39", "350000", "110879" ], + "110820" : [ "13:40", "350000", "110880" ], + "110821" : [ "13:41", "350000", "110881" ], + "110822" : [ "13:42", "350000", "110882" ], + "110823" : [ "13:43", "350000", "110883" ], + "110824" : [ "13:44", "350000", "110884" ], + "110825" : [ "13:45", "350000", "110885" ], + "110826" : [ "13:46", "350000", "110886" ], + "110827" : [ "13:47", "350000", "110887" ], + "110828" : [ "13:48", "350000", "110888" ], + "110829" : [ "13:49", "350000", "110889" ], + "110830" : [ "13:50", "350000", "110890" ], + "110831" : [ "13:51", "350000", "110891" ], + "110832" : [ "13:52", "350000", "110892" ], + "110833" : [ "13:53", "350000", "110893" ], + "110834" : [ "13:54", "350000", "110894" ], + "110835" : [ "13:55", "350000", "110895" ], + "110836" : [ "13:56", "350000", "110896" ], + "110837" : [ "13:57", "350000", "110897" ], + "110838" : [ "13:58", "350000", "110898" ], + "110839" : [ "13:59", "350000", "110899" ], + "110840" : [ "14:00", "350000", "110900" ], + "110841" : [ "14:01", "350000", "110901" ], + "110842" : [ "14:02", "350000", "110902" ], + "110843" : [ "14:03", "350000", "110903" ], + "110844" : [ "14:04", "350000", "110904" ], + "110845" : [ "14:05", "350000", "110905" ], + "110846" : [ "14:06", "350000", "110906" ], + "110847" : [ "14:07", "350000", "110907" ], + "110848" : [ "14:08", "350000", "110908" ], + "110849" : [ "14:09", "350000", "110909" ], + "110850" : [ "14:10", "350000", "110910" ], + "110851" : [ "14:11", "350000", "110911" ], + "110852" : [ "14:12", "350000", "110912" ], + "110853" : [ "14:13", "350000", "110913" ], + "110854" : [ "14:14", "350000", "110914" ], + "110855" : [ "14:15", "350000", "110915" ], + "110856" : [ "14:16", "350000", "110916" ], + "110857" : [ "14:17", "350000", "110917" ], + "110858" : [ "14:18", "350000", "110918" ], + "110859" : [ "14:19", "350000", "110919" ], + "110860" : [ "14:20", "350000", "110920" ], + "110861" : [ "14:21", "350000", "110921" ], + "110862" : [ "14:22", "350000", "110922" ], + "110863" : [ "14:23", "350000", "110923" ], + "110864" : [ "14:24", "350000", "110924" ], + "110865" : [ "14:25", "350000", "110925" ], + "110866" : [ "14:26", "350000", "110926" ], + "110867" : [ "14:27", "350000", "110927" ], + "110868" : [ "14:28", "350000", "110928" ], + "110869" : [ "14:29", "350000", "110929" ], + "110870" : [ "14:30", "350000", "110930" ], + "110871" : [ "14:31", "350000", "110931" ], + "110872" : [ "14:32", "350000", "110932" ], + "110873" : [ "14:33", "350000", "110933" ], + "110874" : [ "14:34", "350000", "110934" ], + "110875" : [ "14:35", "350000", "110935" ], + "110876" : [ "14:36", "350000", "110936" ], + "110877" : [ "14:37", "350000", "110937" ], + "110878" : [ "14:38", "350000", "110938" ], + "110879" : [ "14:39", "350000", "110939" ], + "110880" : [ "14:40", "350000", "110940" ], + "110881" : [ "14:41", "350000", "110941" ], + "110882" : [ "14:42", "350000", "110942" ], + "110883" : [ "14:43", "350000", "110943" ], + "110884" : [ "14:44", "350000", "110944" ], + "110885" : [ "14:45", "350000", "110945" ], + "110886" : [ "14:46", "350000", "110946" ], + "110887" : [ "14:47", "350000", "110947" ], + "110888" : [ "14:48", "350000", "110948" ], + "110889" : [ "14:49", "350000", "110949" ], + "110890" : [ "14:50", "350000", "110950" ], + "110891" : [ "14:51", "350000", "110951" ], + "110892" : [ "14:52", "350000", "110952" ], + "110893" : [ "14:53", "350000", "110953" ], + "110894" : [ "14:54", "350000", "110954" ], + "110895" : [ "14:55", "350000", "110955" ], + "110896" : [ "14:56", "350000", "110956" ], + "110897" : [ "14:57", "350000", "110957" ], + "110898" : [ "14:58", "350000", "110958" ], + "110899" : [ "14:59", "350000", "110959" ], + "110900" : [ "15:00", "350000", "110960" ], + "110901" : [ "15:01", "350000", "110961" ], + "110902" : [ "15:02", "350000", "110962" ], + "110903" : [ "15:03", "350000", "110963" ], + "110904" : [ "15:04", "350000", "110964" ], + "110905" : [ "15:05", "350000", "110965" ], + "110906" : [ "15:06", "350000", "110966" ], + "110907" : [ "15:07", "350000", "110967" ], + "110908" : [ "15:08", "350000", "110968" ], + "110909" : [ "15:09", "350000", "110969" ], + "110910" : [ "15:10", "350000", "110970" ], + "110911" : [ "15:11", "350000", "110971" ], + "110912" : [ "15:12", "350000", "110972" ], + "110913" : [ "15:13", "350000", "110973" ], + "110914" : [ "15:14", "350000", "110974" ], + "110915" : [ "15:15", "350000", "110975" ], + "110916" : [ "15:16", "350000", "110976" ], + "110917" : [ "15:17", "350000", "110977" ], + "110918" : [ "15:18", "350000", "110978" ], + "110919" : [ "15:19", "350000", "110979" ], + "110920" : [ "15:20", "350000", "110980" ], + "110921" : [ "15:21", "350000", "110981" ], + "110922" : [ "15:22", "350000", "110982" ], + "110923" : [ "15:23", "350000", "110983" ], + "110924" : [ "15:24", "350000", "110984" ], + "110925" : [ "15:25", "350000", "110985" ], + "110926" : [ "15:26", "350000", "110986" ], + "110927" : [ "15:27", "350000", "110987" ], + "110928" : [ "15:28", "350000", "110988" ], + "110929" : [ "15:29", "350000", "110989" ], + "110930" : [ "15:30", "350000", "110990" ], + "110931" : [ "15:31", "350000", "110991" ], + "110932" : [ "15:32", "350000", "110992" ], + "110933" : [ "15:33", "350000", "110993" ], + "110934" : [ "15:34", "350000", "110994" ], + "110935" : [ "15:35", "350000", "110995" ], + "110936" : [ "15:36", "350000", "110996" ], + "110937" : [ "15:37", "350000", "110997" ], + "110938" : [ "15:38", "350000", "110998" ], + "110939" : [ "15:39", "350000", "110999" ], + "110940" : [ "15:40", "350000", "111000" ], + "110941" : [ "15:41", "350000", "111001" ], + "110942" : [ "15:42", "350000", "111002" ], + "110943" : [ "15:43", "350000", "111003" ], + "110944" : [ "15:44", "350000", "111004" ], + "110945" : [ "15:45", "350000", "111005" ], + "110946" : [ "15:46", "350000", "111006" ], + "110947" : [ "15:47", "350000", "111007" ], + "110948" : [ "15:48", "350000", "111008" ], + "110949" : [ "15:49", "350000", "111009" ], + "110950" : [ "15:50", "350000", "111010" ], + "110951" : [ "15:51", "350000", "111011" ], + "110952" : [ "15:52", "350000", "111012" ], + "110953" : [ "15:53", "350000", "111013" ], + "110954" : [ "15:54", "350000", "111014" ], + "110955" : [ "15:55", "350000", "111015" ], + "110956" : [ "15:56", "350000", "111016" ], + "110957" : [ "15:57", "350000", "111017" ], + "110958" : [ "15:58", "350000", "111018" ], + "110959" : [ "15:59", "350000", "111019" ], + "110960" : [ "16:00", "350000", "111020" ], + "110961" : [ "16:01", "350000", "111021" ], + "110962" : [ "16:02", "350000", "111022" ], + "110963" : [ "16:03", "350000", "111023" ], + "110964" : [ "16:04", "350000", "111024" ], + "110965" : [ "16:05", "350000", "111025" ], + "110966" : [ "16:06", "350000", "111026" ], + "110967" : [ "16:07", "350000", "111027" ], + "110968" : [ "16:08", "350000", "111028" ], + "110969" : [ "16:09", "350000", "111029" ], + "110970" : [ "16:10", "350000", "111030" ], + "110971" : [ "16:11", "350000", "111031" ], + "110972" : [ "16:12", "350000", "111032" ], + "110973" : [ "16:13", "350000", "111033" ], + "110974" : [ "16:14", "350000", "111034" ], + "110975" : [ "16:15", "350000", "111035" ], + "110976" : [ "16:16", "350000", "111036" ], + "110977" : [ "16:17", "350000", "111037" ], + "110978" : [ "16:18", "350000", "111038" ], + "110979" : [ "16:19", "350000", "111039" ], + "110980" : [ "16:20", "350000", "111040" ], + "110981" : [ "16:21", "350000", "111041" ], + "110982" : [ "16:22", "350000", "111042" ], + "110983" : [ "16:23", "350000", "111043" ], + "110984" : [ "16:24", "350000", "111044" ], + "110985" : [ "16:25", "350000", "111045" ], + "110986" : [ "16:26", "350000", "111046" ], + "110987" : [ "16:27", "350000", "111047" ], + "110988" : [ "16:28", "350000", "111048" ], + "110989" : [ "16:29", "350000", "111049" ], + "110990" : [ "16:30", "350000", "111050" ], + "110991" : [ "16:31", "350000", "111051" ], + "110992" : [ "16:32", "350000", "111052" ], + "110993" : [ "16:33", "350000", "111053" ], + "110994" : [ "16:34", "350000", "111054" ], + "110995" : [ "16:35", "350000", "111055" ], + "110996" : [ "16:36", "350000", "111056" ], + "110997" : [ "16:37", "350000", "111057" ], + "110998" : [ "16:38", "350000", "111058" ], + "110999" : [ "16:39", "350000", "111059" ], + "111000" : [ "16:40", "350000", "111060" ], + "111001" : [ "16:41", "350000", "111061" ], + "111002" : [ "16:42", "350000", "111062" ], + "111003" : [ "16:43", "350000", "111063" ], + "111004" : [ "16:44", "350000", "111064" ], + "111005" : [ "16:45", "350000", "111065" ], + "111006" : [ "16:46", "350000", "111066" ], + "111007" : [ "16:47", "350000", "111067" ], + "111008" : [ "16:48", "350000", "111068" ], + "111009" : [ "16:49", "350000", "111069" ], + "111010" : [ "16:50", "350000", "111070" ], + "111011" : [ "16:51", "350000", "111071" ], + "111012" : [ "16:52", "350000", "111072" ], + "111013" : [ "16:53", "350000", "111073" ], + "111014" : [ "16:54", "350000", "111074" ], + "111015" : [ "16:55", "350000", "111075" ], + "111016" : [ "16:56", "350000", "111076" ], + "111017" : [ "16:57", "350000", "111077" ], + "111018" : [ "16:58", "350000", "111078" ], + "111019" : [ "16:59", "350000", "111079" ], + "111020" : [ "17:00", "350000", "111080" ], + "111021" : [ "17:01", "350000", "111081" ], + "111022" : [ "17:02", "350000", "111082" ], + "111023" : [ "17:03", "350000", "111083" ], + "111024" : [ "17:04", "350000", "111084" ], + "111025" : [ "17:05", "350000", "111085" ], + "111026" : [ "17:06", "350000", "111086" ], + "111027" : [ "17:07", "350000", "111087" ], + "111028" : [ "17:08", "350000", "111088" ], + "111029" : [ "17:09", "350000", "111089" ], + "111030" : [ "17:10", "350000", "111090" ], + "111031" : [ "17:11", "350000", "111091" ], + "111032" : [ "17:12", "350000", "111092" ], + "111033" : [ "17:13", "350000", "111093" ], + "111034" : [ "17:14", "350000", "111094" ], + "111035" : [ "17:15", "350000", "111095" ], + "111036" : [ "17:16", "350000", "111096" ], + "111037" : [ "17:17", "350000", "111097" ], + "111038" : [ "17:18", "350000", "111098" ], + "111039" : [ "17:19", "350000", "111099" ], + "111040" : [ "17:20", "350000", "111100" ], + "111041" : [ "17:21", "350000", "111101" ], + "111042" : [ "17:22", "350000", "111102" ], + "111043" : [ "17:23", "350000", "111103" ], + "111044" : [ "17:24", "350000", "111104" ], + "111045" : [ "17:25", "350000", "111105" ], + "111046" : [ "17:26", "350000", "111106" ], + "111047" : [ "17:27", "350000", "111107" ], + "111048" : [ "17:28", "350000", "111108" ], + "111049" : [ "17:29", "350000", "111109" ], + "111050" : [ "17:30", "350000", "111110" ], + "111051" : [ "17:31", "350000", "111111" ], + "111052" : [ "17:32", "350000", "111112" ], + "111053" : [ "17:33", "350000", "111113" ], + "111054" : [ "17:34", "350000", "111114" ], + "111055" : [ "17:35", "350000", "111115" ], + "111056" : [ "17:36", "350000", "111116" ], + "111057" : [ "17:37", "350000", "111117" ], + "111058" : [ "17:38", "350000", "111118" ], + "111059" : [ "17:39", "350000", "111119" ], + "111060" : [ "17:40", "350000", "111120" ], + "111061" : [ "17:41", "350000", "111121" ], + "111062" : [ "17:42", "350000", "111122" ], + "111063" : [ "17:43", "350000", "111123" ], + "111064" : [ "17:44", "350000", "111124" ], + "111065" : [ "17:45", "350000", "111125" ], + "111066" : [ "17:46", "350000", "111126" ], + "111067" : [ "17:47", "350000", "111127" ], + "111068" : [ "17:48", "350000", "111128" ], + "111069" : [ "17:49", "350000", "111129" ], + "111070" : [ "17:50", "350000", "111130" ], + "111071" : [ "17:51", "350000", "111131" ], + "111072" : [ "17:52", "350000", "111132" ], + "111073" : [ "17:53", "350000", "111133" ], + "111074" : [ "17:54", "350000", "111134" ], + "111075" : [ "17:55", "350000", "111135" ], + "111076" : [ "17:56", "350000", "111136" ], + "111077" : [ "17:57", "350000", "111137" ], + "111078" : [ "17:58", "350000", "111138" ], + "111079" : [ "17:59", "350000", "111139" ], + "111080" : [ "18:00", "350000", "111140" ], + "111081" : [ "18:01", "350000", "111141" ], + "111082" : [ "18:02", "350000", "111142" ], + "111083" : [ "18:03", "350000", "111143" ], + "111084" : [ "18:04", "350000", "111144" ], + "111085" : [ "18:05", "350000", "111145" ], + "111086" : [ "18:06", "350000", "111146" ], + "111087" : [ "18:07", "350000", "111147" ], + "111088" : [ "18:08", "350000", "111148" ], + "111089" : [ "18:09", "350000", "111149" ], + "111090" : [ "18:10", "350000", "111150" ], + "111091" : [ "18:11", "350000", "111151" ], + "111092" : [ "18:12", "350000", "111152" ], + "111093" : [ "18:13", "350000", "111153" ], + "111094" : [ "18:14", "350000", "111154" ], + "111095" : [ "18:15", "350000", "111155" ], + "111096" : [ "18:16", "350000", "111156" ], + "111097" : [ "18:17", "350000", "111157" ], + "111098" : [ "18:18", "350000", "111158" ], + "111099" : [ "18:19", "350000", "111159" ], + "111100" : [ "18:20", "350000", "111160" ], + "111101" : [ "18:21", "350000", "111161" ], + "111102" : [ "18:22", "350000", "111162" ], + "111103" : [ "18:23", "350000", "111163" ], + "111104" : [ "18:24", "350000", "111164" ], + "111105" : [ "18:25", "350000", "111165" ], + "111106" : [ "18:26", "350000", "111166" ], + "111107" : [ "18:27", "350000", "111167" ], + "111108" : [ "18:28", "350000", "111168" ], + "111109" : [ "18:29", "350000", "111169" ], + "111110" : [ "18:30", "350000", "111170" ], + "111111" : [ "18:31", "350000", "111171" ], + "111112" : [ "18:32", "350000", "111172" ], + "111113" : [ "18:33", "350000", "111173" ], + "111114" : [ "18:34", "350000", "111174" ], + "111115" : [ "18:35", "350000", "111175" ], + "111116" : [ "18:36", "350000", "111176" ], + "111117" : [ "18:37", "350000", "111177" ], + "111118" : [ "18:38", "350000", "111178" ], + "111119" : [ "18:39", "350000", "111179" ], + "111120" : [ "18:40", "350000", "111180" ], + "111121" : [ "18:41", "350000", "111181" ], + "111122" : [ "18:42", "350000", "111182" ], + "111123" : [ "18:43", "350000", "111183" ], + "111124" : [ "18:44", "350000", "111184" ], + "111125" : [ "18:45", "350000", "111185" ], + "111126" : [ "18:46", "350000", "111186" ], + "111127" : [ "18:47", "350000", "111187" ], + "111128" : [ "18:48", "350000", "111188" ], + "111129" : [ "18:49", "350000", "111189" ], + "111130" : [ "18:50", "350000", "111190" ], + "111131" : [ "18:51", "350000", "111191" ], + "111132" : [ "18:52", "350000", "111192" ], + "111133" : [ "18:53", "350000", "111193" ], + "111134" : [ "18:54", "350000", "111194" ], + "111135" : [ "18:55", "350000", "111195" ], + "111136" : [ "18:56", "350000", "111196" ], + "111137" : [ "18:57", "350000", "111197" ], + "111138" : [ "18:58", "350000", "111198" ], + "111139" : [ "18:59", "350000", "111199" ], + "111140" : [ "19:00", "350000", "111200" ], + "111141" : [ "19:01", "350000", "111200" ], + "111142" : [ "19:02", "350000", "111200" ], + "111143" : [ "19:03", "350000", "111200" ], + "111144" : [ "19:04", "350000", "111200" ], + "111145" : [ "19:05", "350000", "111200" ], + "111146" : [ "19:06", "350000", "111200" ], + "111147" : [ "19:07", "350000", "111200" ], + "111148" : [ "19:08", "350000", "111200" ], + "111149" : [ "19:09", "350000", "111200" ], + "111150" : [ "19:10", "350000", "111200" ], + "111151" : [ "19:11", "350000", "111200" ], + "111152" : [ "19:12", "350000", "111200" ], + "111153" : [ "19:13", "350000", "111200" ], + "111154" : [ "19:14", "350000", "111200" ], + "111155" : [ "19:15", "350000", "111200" ], + "111156" : [ "19:16", "350000", "111200" ], + "111157" : [ "19:17", "350000", "111200" ], + "111158" : [ "19:18", "350000", "111200" ], + "111159" : [ "19:19", "350000", "111200" ], + "111160" : [ "19:20", "350000", "111200" ], + "111161" : [ "19:21", "350000", "111200" ], + "111162" : [ "19:22", "350000", "111200" ], + "111163" : [ "19:23", "350000", "111200" ], + "111164" : [ "19:24", "350000", "111200" ], + "111165" : [ "19:25", "350000", "111200" ], + "111166" : [ "19:26", "350000", "111200" ], + "111167" : [ "19:27", "350000", "111200" ], + "111168" : [ "19:28", "350000", "111200" ], + "111169" : [ "19:29", "350000", "111200" ], + "111170" : [ "19:30", "350000", "111200" ], + "111171" : [ "19:31", "350000", "111200" ], + "111172" : [ "19:32", "350000", "111200" ], + "111173" : [ "19:33", "350000", "111200" ], + "111174" : [ "19:34", "350000", "111200" ], + "111175" : [ "19:35", "350000", "111200" ], + "111176" : [ "19:36", "350000", "111200" ], + "111177" : [ "19:37", "350000", "111200" ], + "111178" : [ "19:38", "350000", "111200" ], + "111179" : [ "19:39", "350000", "111200" ], + "111180" : [ "19:40", "350000", "111200" ], + "111181" : [ "19:41", "350000", "111200" ], + "111182" : [ "19:42", "350000", "111200" ], + "111183" : [ "19:43", "350000", "111200" ], + "111184" : [ "19:44", "350000", "111200" ], + "111185" : [ "19:45", "350000", "111200" ], + "111186" : [ "19:46", "350000", "111200" ], + "111187" : [ "19:47", "350000", "111200" ], + "111188" : [ "19:48", "350000", "111200" ], + "111189" : [ "19:49", "350000", "111200" ], + "111190" : [ "19:50", "350000", "111200" ], + "111191" : [ "19:51", "350000", "111200" ], + "111192" : [ "19:52", "350000", "111200" ], + "111193" : [ "19:53", "350000", "111200" ], + "111194" : [ "19:54", "350000", "111200" ], + "111195" : [ "19:55", "350000", "111200" ], + "111196" : [ "19:56", "350000", "111200" ], + "111197" : [ "19:57", "350000", "111200" ], + "111198" : [ "19:58", "350000", "111200" ], + "111199" : [ "19:59", "350000", "111200" ], + "111200" : [ "20:00", "800000", "120420" ], + "111201" : [ "20:01", "800000", "120420" ], + "111202" : [ "20:02", "800000", "120420" ], + "111203" : [ "20:03", "800000", "120420" ], + "111204" : [ "20:04", "800000", "120420" ], + "111205" : [ "20:05", "800000", "120420" ], + "111206" : [ "20:06", "800000", "120420" ], + "111207" : [ "20:07", "800000", "120420" ], + "111208" : [ "20:08", "800000", "120420" ], + "111209" : [ "20:09", "800000", "120420" ], + "111210" : [ "20:10", "800000", "120420" ], + "111211" : [ "20:11", "800000", "120420" ], + "111212" : [ "20:12", "800000", "120420" ], + "111213" : [ "20:13", "800000", "120420" ], + "111214" : [ "20:14", "800000", "120420" ], + "111215" : [ "20:15", "800000", "120420" ], + "111216" : [ "20:16", "800000", "120420" ], + "111217" : [ "20:17", "800000", "120420" ], + "111218" : [ "20:18", "800000", "120420" ], + "111219" : [ "20:19", "800000", "120420" ], + "111220" : [ "20:20", "800000", "120420" ], + "111221" : [ "20:21", "800000", "120420" ], + "111222" : [ "20:22", "800000", "120420" ], + "111223" : [ "20:23", "800000", "120420" ], + "111224" : [ "20:24", "800000", "120420" ], + "111225" : [ "20:25", "800000", "120420" ], + "111226" : [ "20:26", "800000", "120420" ], + "111227" : [ "20:27", "800000", "120420" ], + "111228" : [ "20:28", "800000", "120420" ], + "111229" : [ "20:29", "800000", "120420" ], + "111230" : [ "20:30", "800000", "120420" ], + "111231" : [ "20:31", "800000", "120420" ], + "111232" : [ "20:32", "800000", "120420" ], + "111233" : [ "20:33", "800000", "120420" ], + "111234" : [ "20:34", "800000", "120420" ], + "111235" : [ "20:35", "800000", "120420" ], + "111236" : [ "20:36", "800000", "120420" ], + "111237" : [ "20:37", "800000", "120420" ], + "111238" : [ "20:38", "800000", "120420" ], + "111239" : [ "20:39", "800000", "120420" ], + "111240" : [ "20:40", "800000", "120420" ], + "111241" : [ "20:41", "800000", "120420" ], + "111242" : [ "20:42", "800000", "120420" ], + "111243" : [ "20:43", "800000", "120420" ], + "111244" : [ "20:44", "800000", "120420" ], + "111245" : [ "20:45", "800000", "120420" ], + "111246" : [ "20:46", "800000", "120420" ], + "111247" : [ "20:47", "800000", "120420" ], + "111248" : [ "20:48", "800000", "120420" ], + "111249" : [ "20:49", "800000", "120420" ], + "111250" : [ "20:50", "800000", "120420" ], + "111251" : [ "20:51", "800000", "120420" ], + "111252" : [ "20:52", "800000", "120420" ], + "111253" : [ "20:53", "800000", "120420" ], + "111254" : [ "20:54", "800000", "120420" ], + "111255" : [ "20:55", "800000", "120420" ], + "111256" : [ "20:56", "800000", "120420" ], + "111257" : [ "20:57", "800000", "120420" ], + "111258" : [ "20:58", "800000", "120420" ], + "111259" : [ "20:59", "800000", "120420" ], + "111260" : [ "21:00", "800000", "120420" ], + "111261" : [ "21:01", "800000", "120420" ], + "111262" : [ "21:02", "800000", "120420" ], + "111263" : [ "21:03", "800000", "120420" ], + "111264" : [ "21:04", "800000", "120420" ], + "111265" : [ "21:05", "800000", "120420" ], + "111266" : [ "21:06", "800000", "120420" ], + "111267" : [ "21:07", "800000", "120420" ], + "111268" : [ "21:08", "800000", "120420" ], + "111269" : [ "21:09", "800000", "120420" ], + "111270" : [ "21:10", "800000", "120420" ], + "111271" : [ "21:11", "800000", "120420" ], + "111272" : [ "21:12", "800000", "120420" ], + "111273" : [ "21:13", "800000", "120420" ], + "111274" : [ "21:14", "800000", "120420" ], + "111275" : [ "21:15", "800000", "120420" ], + "111276" : [ "21:16", "800000", "120420" ], + "111277" : [ "21:17", "800000", "120420" ], + "111278" : [ "21:18", "800000", "120420" ], + "111279" : [ "21:19", "800000", "120420" ], + "111280" : [ "21:20", "800000", "120420" ], + "111281" : [ "21:21", "800000", "120420" ], + "111282" : [ "21:22", "800000", "120420" ], + "111283" : [ "21:23", "800000", "120420" ], + "111284" : [ "21:24", "800000", "120420" ], + "111285" : [ "21:25", "800000", "120420" ], + "111286" : [ "21:26", "800000", "120420" ], + "111287" : [ "21:27", "800000", "120420" ], + "111288" : [ "21:28", "800000", "120420" ], + "111289" : [ "21:29", "800000", "120420" ], + "111290" : [ "21:30", "800000", "120420" ], + "111291" : [ "21:31", "800000", "120420" ], + "111292" : [ "21:32", "800000", "120420" ], + "111293" : [ "21:33", "800000", "120420" ], + "111294" : [ "21:34", "800000", "120420" ], + "111295" : [ "21:35", "800000", "120420" ], + "111296" : [ "21:36", "800000", "120420" ], + "111297" : [ "21:37", "800000", "120420" ], + "111298" : [ "21:38", "800000", "120420" ], + "111299" : [ "21:39", "800000", "120420" ], + "111300" : [ "21:40", "800000", "120420" ], + "111301" : [ "21:41", "800000", "120420" ], + "111302" : [ "21:42", "800000", "120420" ], + "111303" : [ "21:43", "800000", "120420" ], + "111304" : [ "21:44", "800000", "120420" ], + "111305" : [ "21:45", "800000", "120420" ], + "111306" : [ "21:46", "800000", "120420" ], + "111307" : [ "21:47", "800000", "120420" ], + "111308" : [ "21:48", "800000", "120420" ], + "111309" : [ "21:49", "800000", "120420" ], + "111310" : [ "21:50", "800000", "120420" ], + "111311" : [ "21:51", "800000", "120420" ], + "111312" : [ "21:52", "800000", "120420" ], + "111313" : [ "21:53", "800000", "120420" ], + "111314" : [ "21:54", "800000", "120420" ], + "111315" : [ "21:55", "800000", "120420" ], + "111316" : [ "21:56", "800000", "120420" ], + "111317" : [ "21:57", "800000", "120420" ], + "111318" : [ "21:58", "800000", "120420" ], + "111319" : [ "21:59", "800000", "120420" ], + "111320" : [ "22:00", "800000", "120420" ], + "111321" : [ "22:01", "800000", "120420" ], + "111322" : [ "22:02", "800000", "120420" ], + "111323" : [ "22:03", "800000", "120420" ], + "111324" : [ "22:04", "800000", "120420" ], + "111325" : [ "22:05", "800000", "120420" ], + "111326" : [ "22:06", "800000", "120420" ], + "111327" : [ "22:07", "800000", "120420" ], + "111328" : [ "22:08", "800000", "120420" ], + "111329" : [ "22:09", "800000", "120420" ], + "111330" : [ "22:10", "800000", "120420" ], + "111331" : [ "22:11", "800000", "120420" ], + "111332" : [ "22:12", "800000", "120420" ], + "111333" : [ "22:13", "800000", "120420" ], + "111334" : [ "22:14", "800000", "120420" ], + "111335" : [ "22:15", "800000", "120420" ], + "111336" : [ "22:16", "800000", "120420" ], + "111337" : [ "22:17", "800000", "120420" ], + "111338" : [ "22:18", "800000", "120420" ], + "111339" : [ "22:19", "800000", "120420" ], + "111340" : [ "22:20", "800000", "120420" ], + "111341" : [ "22:21", "800000", "120420" ], + "111342" : [ "22:22", "800000", "120420" ], + "111343" : [ "22:23", "800000", "120420" ], + "111344" : [ "22:24", "800000", "120420" ], + "111345" : [ "22:25", "800000", "120420" ], + "111346" : [ "22:26", "800000", "120420" ], + "111347" : [ "22:27", "800000", "120420" ], + "111348" : [ "22:28", "800000", "120420" ], + "111349" : [ "22:29", "800000", "120420" ], + "111350" : [ "22:30", "800000", "120420" ], + "111351" : [ "22:31", "800000", "120420" ], + "111352" : [ "22:32", "800000", "120420" ], + "111353" : [ "22:33", "800000", "120420" ], + "111354" : [ "22:34", "800000", "120420" ], + "111355" : [ "22:35", "800000", "120420" ], + "111356" : [ "22:36", "800000", "120420" ], + "111357" : [ "22:37", "800000", "120420" ], + "111358" : [ "22:38", "800000", "120420" ], + "111359" : [ "22:39", "800000", "120420" ], + "111360" : [ "22:40", "800000", "120420" ], + "111361" : [ "22:41", "800000", "120420" ], + "111362" : [ "22:42", "800000", "120420" ], + "111363" : [ "22:43", "800000", "120420" ], + "111364" : [ "22:44", "800000", "120420" ], + "111365" : [ "22:45", "800000", "120420" ], + "111366" : [ "22:46", "800000", "120420" ], + "111367" : [ "22:47", "800000", "120420" ], + "111368" : [ "22:48", "800000", "120420" ], + "111369" : [ "22:49", "800000", "120420" ], + "111370" : [ "22:50", "800000", "120420" ], + "111371" : [ "22:51", "800000", "120420" ], + "111372" : [ "22:52", "800000", "120420" ], + "111373" : [ "22:53", "800000", "120420" ], + "111374" : [ "22:54", "800000", "120420" ], + "111375" : [ "22:55", "800000", "120420" ], + "111376" : [ "22:56", "800000", "120420" ], + "111377" : [ "22:57", "800000", "120420" ], + "111378" : [ "22:58", "800000", "120420" ], + "111379" : [ "22:59", "800000", "120420" ], + "111380" : [ "23:00", "800000", "120420" ], + "111381" : [ "23:01", "800000", "120420" ], + "111382" : [ "23:02", "800000", "120420" ], + "111383" : [ "23:03", "800000", "120420" ], + "111384" : [ "23:04", "800000", "120420" ], + "111385" : [ "23:05", "800000", "120420" ], + "111386" : [ "23:06", "800000", "120420" ], + "111387" : [ "23:07", "800000", "120420" ], + "111388" : [ "23:08", "800000", "120420" ], + "111389" : [ "23:09", "800000", "120420" ], + "111390" : [ "23:10", "800000", "120420" ], + "111391" : [ "23:11", "800000", "120420" ], + "111392" : [ "23:12", "800000", "120420" ], + "111393" : [ "23:13", "800000", "120420" ], + "111394" : [ "23:14", "800000", "120420" ], + "111395" : [ "23:15", "800000", "120420" ], + "111396" : [ "23:16", "800000", "120420" ], + "111397" : [ "23:17", "800000", "120420" ], + "111398" : [ "23:18", "800000", "120420" ], + "111399" : [ "23:19", "800000", "120420" ], + "111400" : [ "23:20", "800000", "120420" ], + "111401" : [ "23:21", "800000", "120420" ], + "111402" : [ "23:22", "800000", "120420" ], + "111403" : [ "23:23", "800000", "120420" ], + "111404" : [ "23:24", "800000", "120420" ], + "111405" : [ "23:25", "800000", "120420" ], + "111406" : [ "23:26", "800000", "120420" ], + "111407" : [ "23:27", "800000", "120420" ], + "111408" : [ "23:28", "800000", "120420" ], + "111409" : [ "23:29", "800000", "120420" ], + "111410" : [ "23:30", "800000", "120420" ], + "111411" : [ "23:31", "800000", "120420" ], + "111412" : [ "23:32", "800000", "120420" ], + "111413" : [ "23:33", "800000", "120420" ], + "111414" : [ "23:34", "800000", "120420" ], + "111415" : [ "23:35", "800000", "120420" ], + "111416" : [ "23:36", "800000", "120420" ], + "111417" : [ "23:37", "800000", "120420" ], + "111418" : [ "23:38", "800000", "120420" ], + "111419" : [ "23:39", "800000", "120420" ], + "111420" : [ "23:40", "800000", "120420" ], + "111421" : [ "23:41", "800000", "120420" ], + "111422" : [ "23:42", "800000", "120420" ], + "111423" : [ "23:43", "800000", "120420" ], + "111424" : [ "23:44", "800000", "120420" ], + "111425" : [ "23:45", "800000", "120420" ], + "111426" : [ "23:46", "800000", "120420" ], + "111427" : [ "23:47", "800000", "120420" ], + "111428" : [ "23:48", "800000", "120420" ], + "111429" : [ "23:49", "800000", "120420" ], + "111430" : [ "23:50", "800000", "120420" ], + "111431" : [ "23:51", "800000", "120420" ], + "111432" : [ "23:52", "800000", "120420" ], + "111433" : [ "23:53", "800000", "120420" ], + "111434" : [ "23:54", "800000", "120420" ], + "111435" : [ "23:55", "800000", "120420" ], + "111436" : [ "23:56", "800000", "120420" ], + "111437" : [ "23:57", "800000", "120420" ], + "111438" : [ "23:58", "800000", "120420" ], + "111439" : [ "23:59", "800000", "120420" ] + }, + "Wednesday": { + "120000" : [ "00:00", "800000", "120420" ], + "120001" : [ "00:01", "800000", "120420" ], + "120002" : [ "00:02", "800000", "120420" ], + "120003" : [ "00:03", "800000", "120420" ], + "120004" : [ "00:04", "800000", "120420" ], + "120005" : [ "00:05", "800000", "120420" ], + "120006" : [ "00:06", "800000", "120420" ], + "120007" : [ "00:07", "800000", "120420" ], + "120008" : [ "00:08", "800000", "120420" ], + "120009" : [ "00:09", "800000", "120420" ], + "120010" : [ "00:10", "800000", "120420" ], + "120011" : [ "00:11", "800000", "120420" ], + "120012" : [ "00:12", "800000", "120420" ], + "120013" : [ "00:13", "800000", "120420" ], + "120014" : [ "00:14", "800000", "120420" ], + "120015" : [ "00:15", "800000", "120420" ], + "120016" : [ "00:16", "800000", "120420" ], + "120017" : [ "00:17", "800000", "120420" ], + "120018" : [ "00:18", "800000", "120420" ], + "120019" : [ "00:19", "800000", "120420" ], + "120020" : [ "00:20", "800000", "120420" ], + "120021" : [ "00:21", "800000", "120420" ], + "120022" : [ "00:22", "800000", "120420" ], + "120023" : [ "00:23", "800000", "120420" ], + "120024" : [ "00:24", "800000", "120420" ], + "120025" : [ "00:25", "800000", "120420" ], + "120026" : [ "00:26", "800000", "120420" ], + "120027" : [ "00:27", "800000", "120420" ], + "120028" : [ "00:28", "800000", "120420" ], + "120029" : [ "00:29", "800000", "120420" ], + "120030" : [ "00:30", "800000", "120420" ], + "120031" : [ "00:31", "800000", "120420" ], + "120032" : [ "00:32", "800000", "120420" ], + "120033" : [ "00:33", "800000", "120420" ], + "120034" : [ "00:34", "800000", "120420" ], + "120035" : [ "00:35", "800000", "120420" ], + "120036" : [ "00:36", "800000", "120420" ], + "120037" : [ "00:37", "800000", "120420" ], + "120038" : [ "00:38", "800000", "120420" ], + "120039" : [ "00:39", "800000", "120420" ], + "120040" : [ "00:40", "800000", "120420" ], + "120041" : [ "00:41", "800000", "120420" ], + "120042" : [ "00:42", "800000", "120420" ], + "120043" : [ "00:43", "800000", "120420" ], + "120044" : [ "00:44", "800000", "120420" ], + "120045" : [ "00:45", "800000", "120420" ], + "120046" : [ "00:46", "800000", "120420" ], + "120047" : [ "00:47", "800000", "120420" ], + "120048" : [ "00:48", "800000", "120420" ], + "120049" : [ "00:49", "800000", "120420" ], + "120050" : [ "00:50", "800000", "120420" ], + "120051" : [ "00:51", "800000", "120420" ], + "120052" : [ "00:52", "800000", "120420" ], + "120053" : [ "00:53", "800000", "120420" ], + "120054" : [ "00:54", "800000", "120420" ], + "120055" : [ "00:55", "800000", "120420" ], + "120056" : [ "00:56", "800000", "120420" ], + "120057" : [ "00:57", "800000", "120420" ], + "120058" : [ "00:58", "800000", "120420" ], + "120059" : [ "00:59", "800000", "120420" ], + "120060" : [ "01:00", "800000", "120420" ], + "120061" : [ "01:01", "800000", "120420" ], + "120062" : [ "01:02", "800000", "120420" ], + "120063" : [ "01:03", "800000", "120420" ], + "120064" : [ "01:04", "800000", "120420" ], + "120065" : [ "01:05", "800000", "120420" ], + "120066" : [ "01:06", "800000", "120420" ], + "120067" : [ "01:07", "800000", "120420" ], + "120068" : [ "01:08", "800000", "120420" ], + "120069" : [ "01:09", "800000", "120420" ], + "120070" : [ "01:10", "800000", "120420" ], + "120071" : [ "01:11", "800000", "120420" ], + "120072" : [ "01:12", "800000", "120420" ], + "120073" : [ "01:13", "800000", "120420" ], + "120074" : [ "01:14", "800000", "120420" ], + "120075" : [ "01:15", "800000", "120420" ], + "120076" : [ "01:16", "800000", "120420" ], + "120077" : [ "01:17", "800000", "120420" ], + "120078" : [ "01:18", "800000", "120420" ], + "120079" : [ "01:19", "800000", "120420" ], + "120080" : [ "01:20", "800000", "120420" ], + "120081" : [ "01:21", "800000", "120420" ], + "120082" : [ "01:22", "800000", "120420" ], + "120083" : [ "01:23", "800000", "120420" ], + "120084" : [ "01:24", "800000", "120420" ], + "120085" : [ "01:25", "800000", "120420" ], + "120086" : [ "01:26", "800000", "120420" ], + "120087" : [ "01:27", "800000", "120420" ], + "120088" : [ "01:28", "800000", "120420" ], + "120089" : [ "01:29", "800000", "120420" ], + "120090" : [ "01:30", "800000", "120420" ], + "120091" : [ "01:31", "800000", "120420" ], + "120092" : [ "01:32", "800000", "120420" ], + "120093" : [ "01:33", "800000", "120420" ], + "120094" : [ "01:34", "800000", "120420" ], + "120095" : [ "01:35", "800000", "120420" ], + "120096" : [ "01:36", "800000", "120420" ], + "120097" : [ "01:37", "800000", "120420" ], + "120098" : [ "01:38", "800000", "120420" ], + "120099" : [ "01:39", "800000", "120420" ], + "120100" : [ "01:40", "800000", "120420" ], + "120101" : [ "01:41", "800000", "120420" ], + "120102" : [ "01:42", "800000", "120420" ], + "120103" : [ "01:43", "800000", "120420" ], + "120104" : [ "01:44", "800000", "120420" ], + "120105" : [ "01:45", "800000", "120420" ], + "120106" : [ "01:46", "800000", "120420" ], + "120107" : [ "01:47", "800000", "120420" ], + "120108" : [ "01:48", "800000", "120420" ], + "120109" : [ "01:49", "800000", "120420" ], + "120110" : [ "01:50", "800000", "120420" ], + "120111" : [ "01:51", "800000", "120420" ], + "120112" : [ "01:52", "800000", "120420" ], + "120113" : [ "01:53", "800000", "120420" ], + "120114" : [ "01:54", "800000", "120420" ], + "120115" : [ "01:55", "800000", "120420" ], + "120116" : [ "01:56", "800000", "120420" ], + "120117" : [ "01:57", "800000", "120420" ], + "120118" : [ "01:58", "800000", "120420" ], + "120119" : [ "01:59", "800000", "120420" ], + "120120" : [ "02:00", "800000", "120420" ], + "120121" : [ "02:01", "800000", "120420" ], + "120122" : [ "02:02", "800000", "120420" ], + "120123" : [ "02:03", "800000", "120420" ], + "120124" : [ "02:04", "800000", "120420" ], + "120125" : [ "02:05", "800000", "120420" ], + "120126" : [ "02:06", "800000", "120420" ], + "120127" : [ "02:07", "800000", "120420" ], + "120128" : [ "02:08", "800000", "120420" ], + "120129" : [ "02:09", "800000", "120420" ], + "120130" : [ "02:10", "800000", "120420" ], + "120131" : [ "02:11", "800000", "120420" ], + "120132" : [ "02:12", "800000", "120420" ], + "120133" : [ "02:13", "800000", "120420" ], + "120134" : [ "02:14", "800000", "120420" ], + "120135" : [ "02:15", "800000", "120420" ], + "120136" : [ "02:16", "800000", "120420" ], + "120137" : [ "02:17", "800000", "120420" ], + "120138" : [ "02:18", "800000", "120420" ], + "120139" : [ "02:19", "800000", "120420" ], + "120140" : [ "02:20", "800000", "120420" ], + "120141" : [ "02:21", "800000", "120420" ], + "120142" : [ "02:22", "800000", "120420" ], + "120143" : [ "02:23", "800000", "120420" ], + "120144" : [ "02:24", "800000", "120420" ], + "120145" : [ "02:25", "800000", "120420" ], + "120146" : [ "02:26", "800000", "120420" ], + "120147" : [ "02:27", "800000", "120420" ], + "120148" : [ "02:28", "800000", "120420" ], + "120149" : [ "02:29", "800000", "120420" ], + "120150" : [ "02:30", "800000", "120420" ], + "120151" : [ "02:31", "800000", "120420" ], + "120152" : [ "02:32", "800000", "120420" ], + "120153" : [ "02:33", "800000", "120420" ], + "120154" : [ "02:34", "800000", "120420" ], + "120155" : [ "02:35", "800000", "120420" ], + "120156" : [ "02:36", "800000", "120420" ], + "120157" : [ "02:37", "800000", "120420" ], + "120158" : [ "02:38", "800000", "120420" ], + "120159" : [ "02:39", "800000", "120420" ], + "120160" : [ "02:40", "800000", "120420" ], + "120161" : [ "02:41", "800000", "120420" ], + "120162" : [ "02:42", "800000", "120420" ], + "120163" : [ "02:43", "800000", "120420" ], + "120164" : [ "02:44", "800000", "120420" ], + "120165" : [ "02:45", "800000", "120420" ], + "120166" : [ "02:46", "800000", "120420" ], + "120167" : [ "02:47", "800000", "120420" ], + "120168" : [ "02:48", "800000", "120420" ], + "120169" : [ "02:49", "800000", "120420" ], + "120170" : [ "02:50", "800000", "120420" ], + "120171" : [ "02:51", "800000", "120420" ], + "120172" : [ "02:52", "800000", "120420" ], + "120173" : [ "02:53", "800000", "120420" ], + "120174" : [ "02:54", "800000", "120420" ], + "120175" : [ "02:55", "800000", "120420" ], + "120176" : [ "02:56", "800000", "120420" ], + "120177" : [ "02:57", "800000", "120420" ], + "120178" : [ "02:58", "800000", "120420" ], + "120179" : [ "02:59", "800000", "120420" ], + "120180" : [ "03:00", "800000", "120420" ], + "120181" : [ "03:01", "800000", "120420" ], + "120182" : [ "03:02", "800000", "120420" ], + "120183" : [ "03:03", "800000", "120420" ], + "120184" : [ "03:04", "800000", "120420" ], + "120185" : [ "03:05", "800000", "120420" ], + "120186" : [ "03:06", "800000", "120420" ], + "120187" : [ "03:07", "800000", "120420" ], + "120188" : [ "03:08", "800000", "120420" ], + "120189" : [ "03:09", "800000", "120420" ], + "120190" : [ "03:10", "800000", "120420" ], + "120191" : [ "03:11", "800000", "120420" ], + "120192" : [ "03:12", "800000", "120420" ], + "120193" : [ "03:13", "800000", "120420" ], + "120194" : [ "03:14", "800000", "120420" ], + "120195" : [ "03:15", "800000", "120420" ], + "120196" : [ "03:16", "800000", "120420" ], + "120197" : [ "03:17", "800000", "120420" ], + "120198" : [ "03:18", "800000", "120420" ], + "120199" : [ "03:19", "800000", "120420" ], + "120200" : [ "03:20", "800000", "120420" ], + "120201" : [ "03:21", "800000", "120420" ], + "120202" : [ "03:22", "800000", "120420" ], + "120203" : [ "03:23", "800000", "120420" ], + "120204" : [ "03:24", "800000", "120420" ], + "120205" : [ "03:25", "800000", "120420" ], + "120206" : [ "03:26", "800000", "120420" ], + "120207" : [ "03:27", "800000", "120420" ], + "120208" : [ "03:28", "800000", "120420" ], + "120209" : [ "03:29", "800000", "120420" ], + "120210" : [ "03:30", "800000", "120420" ], + "120211" : [ "03:31", "800000", "120420" ], + "120212" : [ "03:32", "800000", "120420" ], + "120213" : [ "03:33", "800000", "120420" ], + "120214" : [ "03:34", "800000", "120420" ], + "120215" : [ "03:35", "800000", "120420" ], + "120216" : [ "03:36", "800000", "120420" ], + "120217" : [ "03:37", "800000", "120420" ], + "120218" : [ "03:38", "800000", "120420" ], + "120219" : [ "03:39", "800000", "120420" ], + "120220" : [ "03:40", "800000", "120420" ], + "120221" : [ "03:41", "800000", "120420" ], + "120222" : [ "03:42", "800000", "120420" ], + "120223" : [ "03:43", "800000", "120420" ], + "120224" : [ "03:44", "800000", "120420" ], + "120225" : [ "03:45", "800000", "120420" ], + "120226" : [ "03:46", "800000", "120420" ], + "120227" : [ "03:47", "800000", "120420" ], + "120228" : [ "03:48", "800000", "120420" ], + "120229" : [ "03:49", "800000", "120420" ], + "120230" : [ "03:50", "800000", "120420" ], + "120231" : [ "03:51", "800000", "120420" ], + "120232" : [ "03:52", "800000", "120420" ], + "120233" : [ "03:53", "800000", "120420" ], + "120234" : [ "03:54", "800000", "120420" ], + "120235" : [ "03:55", "800000", "120420" ], + "120236" : [ "03:56", "800000", "120420" ], + "120237" : [ "03:57", "800000", "120420" ], + "120238" : [ "03:58", "800000", "120420" ], + "120239" : [ "03:59", "800000", "120420" ], + "120240" : [ "04:00", "800000", "120420" ], + "120241" : [ "04:01", "800000", "120420" ], + "120242" : [ "04:02", "800000", "120420" ], + "120243" : [ "04:03", "800000", "120420" ], + "120244" : [ "04:04", "800000", "120420" ], + "120245" : [ "04:05", "800000", "120420" ], + "120246" : [ "04:06", "800000", "120420" ], + "120247" : [ "04:07", "800000", "120420" ], + "120248" : [ "04:08", "800000", "120420" ], + "120249" : [ "04:09", "800000", "120420" ], + "120250" : [ "04:10", "800000", "120420" ], + "120251" : [ "04:11", "800000", "120420" ], + "120252" : [ "04:12", "800000", "120420" ], + "120253" : [ "04:13", "800000", "120420" ], + "120254" : [ "04:14", "800000", "120420" ], + "120255" : [ "04:15", "800000", "120420" ], + "120256" : [ "04:16", "800000", "120420" ], + "120257" : [ "04:17", "800000", "120420" ], + "120258" : [ "04:18", "800000", "120420" ], + "120259" : [ "04:19", "800000", "120420" ], + "120260" : [ "04:20", "800000", "120420" ], + "120261" : [ "04:21", "800000", "120420" ], + "120262" : [ "04:22", "800000", "120420" ], + "120263" : [ "04:23", "800000", "120420" ], + "120264" : [ "04:24", "800000", "120420" ], + "120265" : [ "04:25", "800000", "120420" ], + "120266" : [ "04:26", "800000", "120420" ], + "120267" : [ "04:27", "800000", "120420" ], + "120268" : [ "04:28", "800000", "120420" ], + "120269" : [ "04:29", "800000", "120420" ], + "120270" : [ "04:30", "800000", "120420" ], + "120271" : [ "04:31", "800000", "120420" ], + "120272" : [ "04:32", "800000", "120420" ], + "120273" : [ "04:33", "800000", "120420" ], + "120274" : [ "04:34", "800000", "120420" ], + "120275" : [ "04:35", "800000", "120420" ], + "120276" : [ "04:36", "800000", "120420" ], + "120277" : [ "04:37", "800000", "120420" ], + "120278" : [ "04:38", "800000", "120420" ], + "120279" : [ "04:39", "800000", "120420" ], + "120280" : [ "04:40", "800000", "120420" ], + "120281" : [ "04:41", "800000", "120420" ], + "120282" : [ "04:42", "800000", "120420" ], + "120283" : [ "04:43", "800000", "120420" ], + "120284" : [ "04:44", "800000", "120420" ], + "120285" : [ "04:45", "800000", "120420" ], + "120286" : [ "04:46", "800000", "120420" ], + "120287" : [ "04:47", "800000", "120420" ], + "120288" : [ "04:48", "800000", "120420" ], + "120289" : [ "04:49", "800000", "120420" ], + "120290" : [ "04:50", "800000", "120420" ], + "120291" : [ "04:51", "800000", "120420" ], + "120292" : [ "04:52", "800000", "120420" ], + "120293" : [ "04:53", "800000", "120420" ], + "120294" : [ "04:54", "800000", "120420" ], + "120295" : [ "04:55", "800000", "120420" ], + "120296" : [ "04:56", "800000", "120420" ], + "120297" : [ "04:57", "800000", "120420" ], + "120298" : [ "04:58", "800000", "120420" ], + "120299" : [ "04:59", "800000", "120420" ], + "120300" : [ "05:00", "800000", "120420" ], + "120301" : [ "05:01", "800000", "120420" ], + "120302" : [ "05:02", "800000", "120420" ], + "120303" : [ "05:03", "800000", "120420" ], + "120304" : [ "05:04", "800000", "120420" ], + "120305" : [ "05:05", "800000", "120420" ], + "120306" : [ "05:06", "800000", "120420" ], + "120307" : [ "05:07", "800000", "120420" ], + "120308" : [ "05:08", "800000", "120420" ], + "120309" : [ "05:09", "800000", "120420" ], + "120310" : [ "05:10", "800000", "120420" ], + "120311" : [ "05:11", "800000", "120420" ], + "120312" : [ "05:12", "800000", "120420" ], + "120313" : [ "05:13", "800000", "120420" ], + "120314" : [ "05:14", "800000", "120420" ], + "120315" : [ "05:15", "800000", "120420" ], + "120316" : [ "05:16", "800000", "120420" ], + "120317" : [ "05:17", "800000", "120420" ], + "120318" : [ "05:18", "800000", "120420" ], + "120319" : [ "05:19", "800000", "120420" ], + "120320" : [ "05:20", "800000", "120420" ], + "120321" : [ "05:21", "800000", "120420" ], + "120322" : [ "05:22", "800000", "120420" ], + "120323" : [ "05:23", "800000", "120420" ], + "120324" : [ "05:24", "800000", "120420" ], + "120325" : [ "05:25", "800000", "120420" ], + "120326" : [ "05:26", "800000", "120420" ], + "120327" : [ "05:27", "800000", "120420" ], + "120328" : [ "05:28", "800000", "120420" ], + "120329" : [ "05:29", "800000", "120420" ], + "120330" : [ "05:30", "800000", "120420" ], + "120331" : [ "05:31", "800000", "120420" ], + "120332" : [ "05:32", "800000", "120420" ], + "120333" : [ "05:33", "800000", "120420" ], + "120334" : [ "05:34", "800000", "120420" ], + "120335" : [ "05:35", "800000", "120420" ], + "120336" : [ "05:36", "800000", "120420" ], + "120337" : [ "05:37", "800000", "120420" ], + "120338" : [ "05:38", "800000", "120420" ], + "120339" : [ "05:39", "800000", "120420" ], + "120340" : [ "05:40", "800000", "120420" ], + "120341" : [ "05:41", "800000", "120420" ], + "120342" : [ "05:42", "800000", "120420" ], + "120343" : [ "05:43", "800000", "120420" ], + "120344" : [ "05:44", "800000", "120420" ], + "120345" : [ "05:45", "800000", "120420" ], + "120346" : [ "05:46", "800000", "120420" ], + "120347" : [ "05:47", "800000", "120420" ], + "120348" : [ "05:48", "800000", "120420" ], + "120349" : [ "05:49", "800000", "120420" ], + "120350" : [ "05:50", "800000", "120420" ], + "120351" : [ "05:51", "800000", "120420" ], + "120352" : [ "05:52", "800000", "120420" ], + "120353" : [ "05:53", "800000", "120420" ], + "120354" : [ "05:54", "800000", "120420" ], + "120355" : [ "05:55", "800000", "120420" ], + "120356" : [ "05:56", "800000", "120420" ], + "120357" : [ "05:57", "800000", "120420" ], + "120358" : [ "05:58", "800000", "120420" ], + "120359" : [ "05:59", "800000", "120420" ], + "120360" : [ "06:00", "800000", "120420" ], + "120361" : [ "06:01", "800000", "120420" ], + "120362" : [ "06:02", "800000", "120420" ], + "120363" : [ "06:03", "800000", "120420" ], + "120364" : [ "06:04", "800000", "120420" ], + "120365" : [ "06:05", "800000", "120420" ], + "120366" : [ "06:06", "800000", "120420" ], + "120367" : [ "06:07", "800000", "120420" ], + "120368" : [ "06:08", "800000", "120420" ], + "120369" : [ "06:09", "800000", "120420" ], + "120370" : [ "06:10", "800000", "120420" ], + "120371" : [ "06:11", "800000", "120420" ], + "120372" : [ "06:12", "800000", "120420" ], + "120373" : [ "06:13", "800000", "120420" ], + "120374" : [ "06:14", "800000", "120420" ], + "120375" : [ "06:15", "800000", "120420" ], + "120376" : [ "06:16", "800000", "120420" ], + "120377" : [ "06:17", "800000", "120420" ], + "120378" : [ "06:18", "800000", "120420" ], + "120379" : [ "06:19", "800000", "120420" ], + "120380" : [ "06:20", "800000", "120420" ], + "120381" : [ "06:21", "800000", "120420" ], + "120382" : [ "06:22", "800000", "120420" ], + "120383" : [ "06:23", "800000", "120420" ], + "120384" : [ "06:24", "800000", "120420" ], + "120385" : [ "06:25", "800000", "120420" ], + "120386" : [ "06:26", "800000", "120420" ], + "120387" : [ "06:27", "800000", "120420" ], + "120388" : [ "06:28", "800000", "120420" ], + "120389" : [ "06:29", "800000", "120420" ], + "120390" : [ "06:30", "800000", "120420" ], + "120391" : [ "06:31", "800000", "120420" ], + "120392" : [ "06:32", "800000", "120420" ], + "120393" : [ "06:33", "800000", "120420" ], + "120394" : [ "06:34", "800000", "120420" ], + "120395" : [ "06:35", "800000", "120420" ], + "120396" : [ "06:36", "800000", "120420" ], + "120397" : [ "06:37", "800000", "120420" ], + "120398" : [ "06:38", "800000", "120420" ], + "120399" : [ "06:39", "800000", "120420" ], + "120400" : [ "06:40", "800000", "120420" ], + "120401" : [ "06:41", "800000", "120420" ], + "120402" : [ "06:42", "800000", "120420" ], + "120403" : [ "06:43", "800000", "120420" ], + "120404" : [ "06:44", "800000", "120420" ], + "120405" : [ "06:45", "800000", "120420" ], + "120406" : [ "06:46", "800000", "120420" ], + "120407" : [ "06:47", "800000", "120420" ], + "120408" : [ "06:48", "800000", "120420" ], + "120409" : [ "06:49", "800000", "120420" ], + "120410" : [ "06:50", "800000", "120420" ], + "120411" : [ "06:51", "800000", "120420" ], + "120412" : [ "06:52", "800000", "120420" ], + "120413" : [ "06:53", "800000", "120420" ], + "120414" : [ "06:54", "800000", "120420" ], + "120415" : [ "06:55", "800000", "120420" ], + "120416" : [ "06:56", "800000", "120420" ], + "120417" : [ "06:57", "800000", "120420" ], + "120418" : [ "06:58", "800000", "120420" ], + "120419" : [ "06:59", "800000", "120420" ], + "120420" : [ "07:00", "350000", "120480" ], + "120421" : [ "07:01", "350000", "120481" ], + "120422" : [ "07:02", "350000", "120482" ], + "120423" : [ "07:03", "350000", "120483" ], + "120424" : [ "07:04", "350000", "120484" ], + "120425" : [ "07:05", "350000", "120485" ], + "120426" : [ "07:06", "350000", "120486" ], + "120427" : [ "07:07", "350000", "120487" ], + "120428" : [ "07:08", "350000", "120488" ], + "120429" : [ "07:09", "350000", "120489" ], + "120430" : [ "07:10", "350000", "120490" ], + "120431" : [ "07:11", "350000", "120491" ], + "120432" : [ "07:12", "350000", "120492" ], + "120433" : [ "07:13", "350000", "120493" ], + "120434" : [ "07:14", "350000", "120494" ], + "120435" : [ "07:15", "350000", "120495" ], + "120436" : [ "07:16", "350000", "120496" ], + "120437" : [ "07:17", "350000", "120497" ], + "120438" : [ "07:18", "350000", "120498" ], + "120439" : [ "07:19", "350000", "120499" ], + "120440" : [ "07:20", "350000", "120500" ], + "120441" : [ "07:21", "350000", "120501" ], + "120442" : [ "07:22", "350000", "120502" ], + "120443" : [ "07:23", "350000", "120503" ], + "120444" : [ "07:24", "350000", "120504" ], + "120445" : [ "07:25", "350000", "120505" ], + "120446" : [ "07:26", "350000", "120506" ], + "120447" : [ "07:27", "350000", "120507" ], + "120448" : [ "07:28", "350000", "120508" ], + "120449" : [ "07:29", "350000", "120509" ], + "120450" : [ "07:30", "350000", "120510" ], + "120451" : [ "07:31", "350000", "120511" ], + "120452" : [ "07:32", "350000", "120512" ], + "120453" : [ "07:33", "350000", "120513" ], + "120454" : [ "07:34", "350000", "120514" ], + "120455" : [ "07:35", "350000", "120515" ], + "120456" : [ "07:36", "350000", "120516" ], + "120457" : [ "07:37", "350000", "120517" ], + "120458" : [ "07:38", "350000", "120518" ], + "120459" : [ "07:39", "350000", "120519" ], + "120460" : [ "07:40", "350000", "120520" ], + "120461" : [ "07:41", "350000", "120521" ], + "120462" : [ "07:42", "350000", "120522" ], + "120463" : [ "07:43", "350000", "120523" ], + "120464" : [ "07:44", "350000", "120524" ], + "120465" : [ "07:45", "350000", "120525" ], + "120466" : [ "07:46", "350000", "120526" ], + "120467" : [ "07:47", "350000", "120527" ], + "120468" : [ "07:48", "350000", "120528" ], + "120469" : [ "07:49", "350000", "120529" ], + "120470" : [ "07:50", "350000", "120530" ], + "120471" : [ "07:51", "350000", "120531" ], + "120472" : [ "07:52", "350000", "120532" ], + "120473" : [ "07:53", "350000", "120533" ], + "120474" : [ "07:54", "350000", "120534" ], + "120475" : [ "07:55", "350000", "120535" ], + "120476" : [ "07:56", "350000", "120536" ], + "120477" : [ "07:57", "350000", "120537" ], + "120478" : [ "07:58", "350000", "120538" ], + "120479" : [ "07:59", "350000", "120539" ], + "120480" : [ "08:00", "350000", "120540" ], + "120481" : [ "08:01", "350000", "120541" ], + "120482" : [ "08:02", "350000", "120542" ], + "120483" : [ "08:03", "350000", "120543" ], + "120484" : [ "08:04", "350000", "120544" ], + "120485" : [ "08:05", "350000", "120545" ], + "120486" : [ "08:06", "350000", "120546" ], + "120487" : [ "08:07", "350000", "120547" ], + "120488" : [ "08:08", "350000", "120548" ], + "120489" : [ "08:09", "350000", "120549" ], + "120490" : [ "08:10", "350000", "120550" ], + "120491" : [ "08:11", "350000", "120551" ], + "120492" : [ "08:12", "350000", "120552" ], + "120493" : [ "08:13", "350000", "120553" ], + "120494" : [ "08:14", "350000", "120554" ], + "120495" : [ "08:15", "350000", "120555" ], + "120496" : [ "08:16", "350000", "120556" ], + "120497" : [ "08:17", "350000", "120557" ], + "120498" : [ "08:18", "350000", "120558" ], + "120499" : [ "08:19", "350000", "120559" ], + "120500" : [ "08:20", "350000", "120560" ], + "120501" : [ "08:21", "350000", "120561" ], + "120502" : [ "08:22", "350000", "120562" ], + "120503" : [ "08:23", "350000", "120563" ], + "120504" : [ "08:24", "350000", "120564" ], + "120505" : [ "08:25", "350000", "120565" ], + "120506" : [ "08:26", "350000", "120566" ], + "120507" : [ "08:27", "350000", "120567" ], + "120508" : [ "08:28", "350000", "120568" ], + "120509" : [ "08:29", "350000", "120569" ], + "120510" : [ "08:30", "350000", "120570" ], + "120511" : [ "08:31", "350000", "120571" ], + "120512" : [ "08:32", "350000", "120572" ], + "120513" : [ "08:33", "350000", "120573" ], + "120514" : [ "08:34", "350000", "120574" ], + "120515" : [ "08:35", "350000", "120575" ], + "120516" : [ "08:36", "350000", "120576" ], + "120517" : [ "08:37", "350000", "120577" ], + "120518" : [ "08:38", "350000", "120578" ], + "120519" : [ "08:39", "350000", "120579" ], + "120520" : [ "08:40", "350000", "120580" ], + "120521" : [ "08:41", "350000", "120581" ], + "120522" : [ "08:42", "350000", "120582" ], + "120523" : [ "08:43", "350000", "120583" ], + "120524" : [ "08:44", "350000", "120584" ], + "120525" : [ "08:45", "350000", "120585" ], + "120526" : [ "08:46", "350000", "120586" ], + "120527" : [ "08:47", "350000", "120587" ], + "120528" : [ "08:48", "350000", "120588" ], + "120529" : [ "08:49", "350000", "120589" ], + "120530" : [ "08:50", "350000", "120590" ], + "120531" : [ "08:51", "350000", "120591" ], + "120532" : [ "08:52", "350000", "120592" ], + "120533" : [ "08:53", "350000", "120593" ], + "120534" : [ "08:54", "350000", "120594" ], + "120535" : [ "08:55", "350000", "120595" ], + "120536" : [ "08:56", "350000", "120596" ], + "120537" : [ "08:57", "350000", "120597" ], + "120538" : [ "08:58", "350000", "120598" ], + "120539" : [ "08:59", "350000", "120599" ], + "120540" : [ "09:00", "350000", "120600" ], + "120541" : [ "09:01", "350000", "120601" ], + "120542" : [ "09:02", "350000", "120602" ], + "120543" : [ "09:03", "350000", "120603" ], + "120544" : [ "09:04", "350000", "120604" ], + "120545" : [ "09:05", "350000", "120605" ], + "120546" : [ "09:06", "350000", "120606" ], + "120547" : [ "09:07", "350000", "120607" ], + "120548" : [ "09:08", "350000", "120608" ], + "120549" : [ "09:09", "350000", "120609" ], + "120550" : [ "09:10", "350000", "120610" ], + "120551" : [ "09:11", "350000", "120611" ], + "120552" : [ "09:12", "350000", "120612" ], + "120553" : [ "09:13", "350000", "120613" ], + "120554" : [ "09:14", "350000", "120614" ], + "120555" : [ "09:15", "350000", "120615" ], + "120556" : [ "09:16", "350000", "120616" ], + "120557" : [ "09:17", "350000", "120617" ], + "120558" : [ "09:18", "350000", "120618" ], + "120559" : [ "09:19", "350000", "120619" ], + "120560" : [ "09:20", "350000", "120620" ], + "120561" : [ "09:21", "350000", "120621" ], + "120562" : [ "09:22", "350000", "120622" ], + "120563" : [ "09:23", "350000", "120623" ], + "120564" : [ "09:24", "350000", "120624" ], + "120565" : [ "09:25", "350000", "120625" ], + "120566" : [ "09:26", "350000", "120626" ], + "120567" : [ "09:27", "350000", "120627" ], + "120568" : [ "09:28", "350000", "120628" ], + "120569" : [ "09:29", "350000", "120629" ], + "120570" : [ "09:30", "350000", "120630" ], + "120571" : [ "09:31", "350000", "120631" ], + "120572" : [ "09:32", "350000", "120632" ], + "120573" : [ "09:33", "350000", "120633" ], + "120574" : [ "09:34", "350000", "120634" ], + "120575" : [ "09:35", "350000", "120635" ], + "120576" : [ "09:36", "350000", "120636" ], + "120577" : [ "09:37", "350000", "120637" ], + "120578" : [ "09:38", "350000", "120638" ], + "120579" : [ "09:39", "350000", "120639" ], + "120580" : [ "09:40", "350000", "120640" ], + "120581" : [ "09:41", "350000", "120641" ], + "120582" : [ "09:42", "350000", "120642" ], + "120583" : [ "09:43", "350000", "120643" ], + "120584" : [ "09:44", "350000", "120644" ], + "120585" : [ "09:45", "350000", "120645" ], + "120586" : [ "09:46", "350000", "120646" ], + "120587" : [ "09:47", "350000", "120647" ], + "120588" : [ "09:48", "350000", "120648" ], + "120589" : [ "09:49", "350000", "120649" ], + "120590" : [ "09:50", "350000", "120650" ], + "120591" : [ "09:51", "350000", "120651" ], + "120592" : [ "09:52", "350000", "120652" ], + "120593" : [ "09:53", "350000", "120653" ], + "120594" : [ "09:54", "350000", "120654" ], + "120595" : [ "09:55", "350000", "120655" ], + "120596" : [ "09:56", "350000", "120656" ], + "120597" : [ "09:57", "350000", "120657" ], + "120598" : [ "09:58", "350000", "120658" ], + "120599" : [ "09:59", "350000", "120659" ], + "120600" : [ "10:00", "350000", "120660" ], + "120601" : [ "10:01", "350000", "120661" ], + "120602" : [ "10:02", "350000", "120662" ], + "120603" : [ "10:03", "350000", "120663" ], + "120604" : [ "10:04", "350000", "120664" ], + "120605" : [ "10:05", "350000", "120665" ], + "120606" : [ "10:06", "350000", "120666" ], + "120607" : [ "10:07", "350000", "120667" ], + "120608" : [ "10:08", "350000", "120668" ], + "120609" : [ "10:09", "350000", "120669" ], + "120610" : [ "10:10", "350000", "120670" ], + "120611" : [ "10:11", "350000", "120671" ], + "120612" : [ "10:12", "350000", "120672" ], + "120613" : [ "10:13", "350000", "120673" ], + "120614" : [ "10:14", "350000", "120674" ], + "120615" : [ "10:15", "350000", "120675" ], + "120616" : [ "10:16", "350000", "120676" ], + "120617" : [ "10:17", "350000", "120677" ], + "120618" : [ "10:18", "350000", "120678" ], + "120619" : [ "10:19", "350000", "120679" ], + "120620" : [ "10:20", "350000", "120680" ], + "120621" : [ "10:21", "350000", "120681" ], + "120622" : [ "10:22", "350000", "120682" ], + "120623" : [ "10:23", "350000", "120683" ], + "120624" : [ "10:24", "350000", "120684" ], + "120625" : [ "10:25", "350000", "120685" ], + "120626" : [ "10:26", "350000", "120686" ], + "120627" : [ "10:27", "350000", "120687" ], + "120628" : [ "10:28", "350000", "120688" ], + "120629" : [ "10:29", "350000", "120689" ], + "120630" : [ "10:30", "350000", "120690" ], + "120631" : [ "10:31", "350000", "120691" ], + "120632" : [ "10:32", "350000", "120692" ], + "120633" : [ "10:33", "350000", "120693" ], + "120634" : [ "10:34", "350000", "120694" ], + "120635" : [ "10:35", "350000", "120695" ], + "120636" : [ "10:36", "350000", "120696" ], + "120637" : [ "10:37", "350000", "120697" ], + "120638" : [ "10:38", "350000", "120698" ], + "120639" : [ "10:39", "350000", "120699" ], + "120640" : [ "10:40", "350000", "120700" ], + "120641" : [ "10:41", "350000", "120701" ], + "120642" : [ "10:42", "350000", "120702" ], + "120643" : [ "10:43", "350000", "120703" ], + "120644" : [ "10:44", "350000", "120704" ], + "120645" : [ "10:45", "350000", "120705" ], + "120646" : [ "10:46", "350000", "120706" ], + "120647" : [ "10:47", "350000", "120707" ], + "120648" : [ "10:48", "350000", "120708" ], + "120649" : [ "10:49", "350000", "120709" ], + "120650" : [ "10:50", "350000", "120710" ], + "120651" : [ "10:51", "350000", "120711" ], + "120652" : [ "10:52", "350000", "120712" ], + "120653" : [ "10:53", "350000", "120713" ], + "120654" : [ "10:54", "350000", "120714" ], + "120655" : [ "10:55", "350000", "120715" ], + "120656" : [ "10:56", "350000", "120716" ], + "120657" : [ "10:57", "350000", "120717" ], + "120658" : [ "10:58", "350000", "120718" ], + "120659" : [ "10:59", "350000", "120719" ], + "120660" : [ "11:00", "350000", "120720" ], + "120661" : [ "11:01", "350000", "120721" ], + "120662" : [ "11:02", "350000", "120722" ], + "120663" : [ "11:03", "350000", "120723" ], + "120664" : [ "11:04", "350000", "120724" ], + "120665" : [ "11:05", "350000", "120725" ], + "120666" : [ "11:06", "350000", "120726" ], + "120667" : [ "11:07", "350000", "120727" ], + "120668" : [ "11:08", "350000", "120728" ], + "120669" : [ "11:09", "350000", "120729" ], + "120670" : [ "11:10", "350000", "120730" ], + "120671" : [ "11:11", "350000", "120731" ], + "120672" : [ "11:12", "350000", "120732" ], + "120673" : [ "11:13", "350000", "120733" ], + "120674" : [ "11:14", "350000", "120734" ], + "120675" : [ "11:15", "350000", "120735" ], + "120676" : [ "11:16", "350000", "120736" ], + "120677" : [ "11:17", "350000", "120737" ], + "120678" : [ "11:18", "350000", "120738" ], + "120679" : [ "11:19", "350000", "120739" ], + "120680" : [ "11:20", "350000", "120740" ], + "120681" : [ "11:21", "350000", "120741" ], + "120682" : [ "11:22", "350000", "120742" ], + "120683" : [ "11:23", "350000", "120743" ], + "120684" : [ "11:24", "350000", "120744" ], + "120685" : [ "11:25", "350000", "120745" ], + "120686" : [ "11:26", "350000", "120746" ], + "120687" : [ "11:27", "350000", "120747" ], + "120688" : [ "11:28", "350000", "120748" ], + "120689" : [ "11:29", "350000", "120749" ], + "120690" : [ "11:30", "350000", "120750" ], + "120691" : [ "11:31", "350000", "120751" ], + "120692" : [ "11:32", "350000", "120752" ], + "120693" : [ "11:33", "350000", "120753" ], + "120694" : [ "11:34", "350000", "120754" ], + "120695" : [ "11:35", "350000", "120755" ], + "120696" : [ "11:36", "350000", "120756" ], + "120697" : [ "11:37", "350000", "120757" ], + "120698" : [ "11:38", "350000", "120758" ], + "120699" : [ "11:39", "350000", "120759" ], + "120700" : [ "11:40", "350000", "120760" ], + "120701" : [ "11:41", "350000", "120761" ], + "120702" : [ "11:42", "350000", "120762" ], + "120703" : [ "11:43", "350000", "120763" ], + "120704" : [ "11:44", "350000", "120764" ], + "120705" : [ "11:45", "350000", "120765" ], + "120706" : [ "11:46", "350000", "120766" ], + "120707" : [ "11:47", "350000", "120767" ], + "120708" : [ "11:48", "350000", "120768" ], + "120709" : [ "11:49", "350000", "120769" ], + "120710" : [ "11:50", "350000", "120770" ], + "120711" : [ "11:51", "350000", "120771" ], + "120712" : [ "11:52", "350000", "120772" ], + "120713" : [ "11:53", "350000", "120773" ], + "120714" : [ "11:54", "350000", "120774" ], + "120715" : [ "11:55", "350000", "120775" ], + "120716" : [ "11:56", "350000", "120776" ], + "120717" : [ "11:57", "350000", "120777" ], + "120718" : [ "11:58", "350000", "120778" ], + "120719" : [ "11:59", "350000", "120779" ], + "120720" : [ "12:00", "350000", "120780" ], + "120721" : [ "12:01", "350000", "120781" ], + "120722" : [ "12:02", "350000", "120782" ], + "120723" : [ "12:03", "350000", "120783" ], + "120724" : [ "12:04", "350000", "120784" ], + "120725" : [ "12:05", "350000", "120785" ], + "120726" : [ "12:06", "350000", "120786" ], + "120727" : [ "12:07", "350000", "120787" ], + "120728" : [ "12:08", "350000", "120788" ], + "120729" : [ "12:09", "350000", "120789" ], + "120730" : [ "12:10", "350000", "120790" ], + "120731" : [ "12:11", "350000", "120791" ], + "120732" : [ "12:12", "350000", "120792" ], + "120733" : [ "12:13", "350000", "120793" ], + "120734" : [ "12:14", "350000", "120794" ], + "120735" : [ "12:15", "350000", "120795" ], + "120736" : [ "12:16", "350000", "120796" ], + "120737" : [ "12:17", "350000", "120797" ], + "120738" : [ "12:18", "350000", "120798" ], + "120739" : [ "12:19", "350000", "120799" ], + "120740" : [ "12:20", "350000", "120800" ], + "120741" : [ "12:21", "350000", "120801" ], + "120742" : [ "12:22", "350000", "120802" ], + "120743" : [ "12:23", "350000", "120803" ], + "120744" : [ "12:24", "350000", "120804" ], + "120745" : [ "12:25", "350000", "120805" ], + "120746" : [ "12:26", "350000", "120806" ], + "120747" : [ "12:27", "350000", "120807" ], + "120748" : [ "12:28", "350000", "120808" ], + "120749" : [ "12:29", "350000", "120809" ], + "120750" : [ "12:30", "350000", "120810" ], + "120751" : [ "12:31", "350000", "120811" ], + "120752" : [ "12:32", "350000", "120812" ], + "120753" : [ "12:33", "350000", "120813" ], + "120754" : [ "12:34", "350000", "120814" ], + "120755" : [ "12:35", "350000", "120815" ], + "120756" : [ "12:36", "350000", "120816" ], + "120757" : [ "12:37", "350000", "120817" ], + "120758" : [ "12:38", "350000", "120818" ], + "120759" : [ "12:39", "350000", "120819" ], + "120760" : [ "12:40", "350000", "120820" ], + "120761" : [ "12:41", "350000", "120821" ], + "120762" : [ "12:42", "350000", "120822" ], + "120763" : [ "12:43", "350000", "120823" ], + "120764" : [ "12:44", "350000", "120824" ], + "120765" : [ "12:45", "350000", "120825" ], + "120766" : [ "12:46", "350000", "120826" ], + "120767" : [ "12:47", "350000", "120827" ], + "120768" : [ "12:48", "350000", "120828" ], + "120769" : [ "12:49", "350000", "120829" ], + "120770" : [ "12:50", "350000", "120830" ], + "120771" : [ "12:51", "350000", "120831" ], + "120772" : [ "12:52", "350000", "120832" ], + "120773" : [ "12:53", "350000", "120833" ], + "120774" : [ "12:54", "350000", "120834" ], + "120775" : [ "12:55", "350000", "120835" ], + "120776" : [ "12:56", "350000", "120836" ], + "120777" : [ "12:57", "350000", "120837" ], + "120778" : [ "12:58", "350000", "120838" ], + "120779" : [ "12:59", "350000", "120839" ], + "120780" : [ "13:00", "350000", "120840" ], + "120781" : [ "13:01", "350000", "120841" ], + "120782" : [ "13:02", "350000", "120842" ], + "120783" : [ "13:03", "350000", "120843" ], + "120784" : [ "13:04", "350000", "120844" ], + "120785" : [ "13:05", "350000", "120845" ], + "120786" : [ "13:06", "350000", "120846" ], + "120787" : [ "13:07", "350000", "120847" ], + "120788" : [ "13:08", "350000", "120848" ], + "120789" : [ "13:09", "350000", "120849" ], + "120790" : [ "13:10", "350000", "120850" ], + "120791" : [ "13:11", "350000", "120851" ], + "120792" : [ "13:12", "350000", "120852" ], + "120793" : [ "13:13", "350000", "120853" ], + "120794" : [ "13:14", "350000", "120854" ], + "120795" : [ "13:15", "350000", "120855" ], + "120796" : [ "13:16", "350000", "120856" ], + "120797" : [ "13:17", "350000", "120857" ], + "120798" : [ "13:18", "350000", "120858" ], + "120799" : [ "13:19", "350000", "120859" ], + "120800" : [ "13:20", "350000", "120860" ], + "120801" : [ "13:21", "350000", "120861" ], + "120802" : [ "13:22", "350000", "120862" ], + "120803" : [ "13:23", "350000", "120863" ], + "120804" : [ "13:24", "350000", "120864" ], + "120805" : [ "13:25", "350000", "120865" ], + "120806" : [ "13:26", "350000", "120866" ], + "120807" : [ "13:27", "350000", "120867" ], + "120808" : [ "13:28", "350000", "120868" ], + "120809" : [ "13:29", "350000", "120869" ], + "120810" : [ "13:30", "350000", "120870" ], + "120811" : [ "13:31", "350000", "120871" ], + "120812" : [ "13:32", "350000", "120872" ], + "120813" : [ "13:33", "350000", "120873" ], + "120814" : [ "13:34", "350000", "120874" ], + "120815" : [ "13:35", "350000", "120875" ], + "120816" : [ "13:36", "350000", "120876" ], + "120817" : [ "13:37", "350000", "120877" ], + "120818" : [ "13:38", "350000", "120878" ], + "120819" : [ "13:39", "350000", "120879" ], + "120820" : [ "13:40", "350000", "120880" ], + "120821" : [ "13:41", "350000", "120881" ], + "120822" : [ "13:42", "350000", "120882" ], + "120823" : [ "13:43", "350000", "120883" ], + "120824" : [ "13:44", "350000", "120884" ], + "120825" : [ "13:45", "350000", "120885" ], + "120826" : [ "13:46", "350000", "120886" ], + "120827" : [ "13:47", "350000", "120887" ], + "120828" : [ "13:48", "350000", "120888" ], + "120829" : [ "13:49", "350000", "120889" ], + "120830" : [ "13:50", "350000", "120890" ], + "120831" : [ "13:51", "350000", "120891" ], + "120832" : [ "13:52", "350000", "120892" ], + "120833" : [ "13:53", "350000", "120893" ], + "120834" : [ "13:54", "350000", "120894" ], + "120835" : [ "13:55", "350000", "120895" ], + "120836" : [ "13:56", "350000", "120896" ], + "120837" : [ "13:57", "350000", "120897" ], + "120838" : [ "13:58", "350000", "120898" ], + "120839" : [ "13:59", "350000", "120899" ], + "120840" : [ "14:00", "350000", "120900" ], + "120841" : [ "14:01", "350000", "120901" ], + "120842" : [ "14:02", "350000", "120902" ], + "120843" : [ "14:03", "350000", "120903" ], + "120844" : [ "14:04", "350000", "120904" ], + "120845" : [ "14:05", "350000", "120905" ], + "120846" : [ "14:06", "350000", "120906" ], + "120847" : [ "14:07", "350000", "120907" ], + "120848" : [ "14:08", "350000", "120908" ], + "120849" : [ "14:09", "350000", "120909" ], + "120850" : [ "14:10", "350000", "120910" ], + "120851" : [ "14:11", "350000", "120911" ], + "120852" : [ "14:12", "350000", "120912" ], + "120853" : [ "14:13", "350000", "120913" ], + "120854" : [ "14:14", "350000", "120914" ], + "120855" : [ "14:15", "350000", "120915" ], + "120856" : [ "14:16", "350000", "120916" ], + "120857" : [ "14:17", "350000", "120917" ], + "120858" : [ "14:18", "350000", "120918" ], + "120859" : [ "14:19", "350000", "120919" ], + "120860" : [ "14:20", "350000", "120920" ], + "120861" : [ "14:21", "350000", "120921" ], + "120862" : [ "14:22", "350000", "120922" ], + "120863" : [ "14:23", "350000", "120923" ], + "120864" : [ "14:24", "350000", "120924" ], + "120865" : [ "14:25", "350000", "120925" ], + "120866" : [ "14:26", "350000", "120926" ], + "120867" : [ "14:27", "350000", "120927" ], + "120868" : [ "14:28", "350000", "120928" ], + "120869" : [ "14:29", "350000", "120929" ], + "120870" : [ "14:30", "350000", "120930" ], + "120871" : [ "14:31", "350000", "120931" ], + "120872" : [ "14:32", "350000", "120932" ], + "120873" : [ "14:33", "350000", "120933" ], + "120874" : [ "14:34", "350000", "120934" ], + "120875" : [ "14:35", "350000", "120935" ], + "120876" : [ "14:36", "350000", "120936" ], + "120877" : [ "14:37", "350000", "120937" ], + "120878" : [ "14:38", "350000", "120938" ], + "120879" : [ "14:39", "350000", "120939" ], + "120880" : [ "14:40", "350000", "120940" ], + "120881" : [ "14:41", "350000", "120941" ], + "120882" : [ "14:42", "350000", "120942" ], + "120883" : [ "14:43", "350000", "120943" ], + "120884" : [ "14:44", "350000", "120944" ], + "120885" : [ "14:45", "350000", "120945" ], + "120886" : [ "14:46", "350000", "120946" ], + "120887" : [ "14:47", "350000", "120947" ], + "120888" : [ "14:48", "350000", "120948" ], + "120889" : [ "14:49", "350000", "120949" ], + "120890" : [ "14:50", "350000", "120950" ], + "120891" : [ "14:51", "350000", "120951" ], + "120892" : [ "14:52", "350000", "120952" ], + "120893" : [ "14:53", "350000", "120953" ], + "120894" : [ "14:54", "350000", "120954" ], + "120895" : [ "14:55", "350000", "120955" ], + "120896" : [ "14:56", "350000", "120956" ], + "120897" : [ "14:57", "350000", "120957" ], + "120898" : [ "14:58", "350000", "120958" ], + "120899" : [ "14:59", "350000", "120959" ], + "120900" : [ "15:00", "350000", "120960" ], + "120901" : [ "15:01", "350000", "120961" ], + "120902" : [ "15:02", "350000", "120962" ], + "120903" : [ "15:03", "350000", "120963" ], + "120904" : [ "15:04", "350000", "120964" ], + "120905" : [ "15:05", "350000", "120965" ], + "120906" : [ "15:06", "350000", "120966" ], + "120907" : [ "15:07", "350000", "120967" ], + "120908" : [ "15:08", "350000", "120968" ], + "120909" : [ "15:09", "350000", "120969" ], + "120910" : [ "15:10", "350000", "120970" ], + "120911" : [ "15:11", "350000", "120971" ], + "120912" : [ "15:12", "350000", "120972" ], + "120913" : [ "15:13", "350000", "120973" ], + "120914" : [ "15:14", "350000", "120974" ], + "120915" : [ "15:15", "350000", "120975" ], + "120916" : [ "15:16", "350000", "120976" ], + "120917" : [ "15:17", "350000", "120977" ], + "120918" : [ "15:18", "350000", "120978" ], + "120919" : [ "15:19", "350000", "120979" ], + "120920" : [ "15:20", "350000", "120980" ], + "120921" : [ "15:21", "350000", "120981" ], + "120922" : [ "15:22", "350000", "120982" ], + "120923" : [ "15:23", "350000", "120983" ], + "120924" : [ "15:24", "350000", "120984" ], + "120925" : [ "15:25", "350000", "120985" ], + "120926" : [ "15:26", "350000", "120986" ], + "120927" : [ "15:27", "350000", "120987" ], + "120928" : [ "15:28", "350000", "120988" ], + "120929" : [ "15:29", "350000", "120989" ], + "120930" : [ "15:30", "350000", "120990" ], + "120931" : [ "15:31", "350000", "120991" ], + "120932" : [ "15:32", "350000", "120992" ], + "120933" : [ "15:33", "350000", "120993" ], + "120934" : [ "15:34", "350000", "120994" ], + "120935" : [ "15:35", "350000", "120995" ], + "120936" : [ "15:36", "350000", "120996" ], + "120937" : [ "15:37", "350000", "120997" ], + "120938" : [ "15:38", "350000", "120998" ], + "120939" : [ "15:39", "350000", "120999" ], + "120940" : [ "15:40", "350000", "121000" ], + "120941" : [ "15:41", "350000", "121001" ], + "120942" : [ "15:42", "350000", "121002" ], + "120943" : [ "15:43", "350000", "121003" ], + "120944" : [ "15:44", "350000", "121004" ], + "120945" : [ "15:45", "350000", "121005" ], + "120946" : [ "15:46", "350000", "121006" ], + "120947" : [ "15:47", "350000", "121007" ], + "120948" : [ "15:48", "350000", "121008" ], + "120949" : [ "15:49", "350000", "121009" ], + "120950" : [ "15:50", "350000", "121010" ], + "120951" : [ "15:51", "350000", "121011" ], + "120952" : [ "15:52", "350000", "121012" ], + "120953" : [ "15:53", "350000", "121013" ], + "120954" : [ "15:54", "350000", "121014" ], + "120955" : [ "15:55", "350000", "121015" ], + "120956" : [ "15:56", "350000", "121016" ], + "120957" : [ "15:57", "350000", "121017" ], + "120958" : [ "15:58", "350000", "121018" ], + "120959" : [ "15:59", "350000", "121019" ], + "120960" : [ "16:00", "350000", "121020" ], + "120961" : [ "16:01", "350000", "121021" ], + "120962" : [ "16:02", "350000", "121022" ], + "120963" : [ "16:03", "350000", "121023" ], + "120964" : [ "16:04", "350000", "121024" ], + "120965" : [ "16:05", "350000", "121025" ], + "120966" : [ "16:06", "350000", "121026" ], + "120967" : [ "16:07", "350000", "121027" ], + "120968" : [ "16:08", "350000", "121028" ], + "120969" : [ "16:09", "350000", "121029" ], + "120970" : [ "16:10", "350000", "121030" ], + "120971" : [ "16:11", "350000", "121031" ], + "120972" : [ "16:12", "350000", "121032" ], + "120973" : [ "16:13", "350000", "121033" ], + "120974" : [ "16:14", "350000", "121034" ], + "120975" : [ "16:15", "350000", "121035" ], + "120976" : [ "16:16", "350000", "121036" ], + "120977" : [ "16:17", "350000", "121037" ], + "120978" : [ "16:18", "350000", "121038" ], + "120979" : [ "16:19", "350000", "121039" ], + "120980" : [ "16:20", "350000", "121040" ], + "120981" : [ "16:21", "350000", "121041" ], + "120982" : [ "16:22", "350000", "121042" ], + "120983" : [ "16:23", "350000", "121043" ], + "120984" : [ "16:24", "350000", "121044" ], + "120985" : [ "16:25", "350000", "121045" ], + "120986" : [ "16:26", "350000", "121046" ], + "120987" : [ "16:27", "350000", "121047" ], + "120988" : [ "16:28", "350000", "121048" ], + "120989" : [ "16:29", "350000", "121049" ], + "120990" : [ "16:30", "350000", "121050" ], + "120991" : [ "16:31", "350000", "121051" ], + "120992" : [ "16:32", "350000", "121052" ], + "120993" : [ "16:33", "350000", "121053" ], + "120994" : [ "16:34", "350000", "121054" ], + "120995" : [ "16:35", "350000", "121055" ], + "120996" : [ "16:36", "350000", "121056" ], + "120997" : [ "16:37", "350000", "121057" ], + "120998" : [ "16:38", "350000", "121058" ], + "120999" : [ "16:39", "350000", "121059" ], + "121000" : [ "16:40", "350000", "121060" ], + "121001" : [ "16:41", "350000", "121061" ], + "121002" : [ "16:42", "350000", "121062" ], + "121003" : [ "16:43", "350000", "121063" ], + "121004" : [ "16:44", "350000", "121064" ], + "121005" : [ "16:45", "350000", "121065" ], + "121006" : [ "16:46", "350000", "121066" ], + "121007" : [ "16:47", "350000", "121067" ], + "121008" : [ "16:48", "350000", "121068" ], + "121009" : [ "16:49", "350000", "121069" ], + "121010" : [ "16:50", "350000", "121070" ], + "121011" : [ "16:51", "350000", "121071" ], + "121012" : [ "16:52", "350000", "121072" ], + "121013" : [ "16:53", "350000", "121073" ], + "121014" : [ "16:54", "350000", "121074" ], + "121015" : [ "16:55", "350000", "121075" ], + "121016" : [ "16:56", "350000", "121076" ], + "121017" : [ "16:57", "350000", "121077" ], + "121018" : [ "16:58", "350000", "121078" ], + "121019" : [ "16:59", "350000", "121079" ], + "121020" : [ "17:00", "350000", "121080" ], + "121021" : [ "17:01", "350000", "121081" ], + "121022" : [ "17:02", "350000", "121082" ], + "121023" : [ "17:03", "350000", "121083" ], + "121024" : [ "17:04", "350000", "121084" ], + "121025" : [ "17:05", "350000", "121085" ], + "121026" : [ "17:06", "350000", "121086" ], + "121027" : [ "17:07", "350000", "121087" ], + "121028" : [ "17:08", "350000", "121088" ], + "121029" : [ "17:09", "350000", "121089" ], + "121030" : [ "17:10", "350000", "121090" ], + "121031" : [ "17:11", "350000", "121091" ], + "121032" : [ "17:12", "350000", "121092" ], + "121033" : [ "17:13", "350000", "121093" ], + "121034" : [ "17:14", "350000", "121094" ], + "121035" : [ "17:15", "350000", "121095" ], + "121036" : [ "17:16", "350000", "121096" ], + "121037" : [ "17:17", "350000", "121097" ], + "121038" : [ "17:18", "350000", "121098" ], + "121039" : [ "17:19", "350000", "121099" ], + "121040" : [ "17:20", "350000", "121100" ], + "121041" : [ "17:21", "350000", "121101" ], + "121042" : [ "17:22", "350000", "121102" ], + "121043" : [ "17:23", "350000", "121103" ], + "121044" : [ "17:24", "350000", "121104" ], + "121045" : [ "17:25", "350000", "121105" ], + "121046" : [ "17:26", "350000", "121106" ], + "121047" : [ "17:27", "350000", "121107" ], + "121048" : [ "17:28", "350000", "121108" ], + "121049" : [ "17:29", "350000", "121109" ], + "121050" : [ "17:30", "350000", "121110" ], + "121051" : [ "17:31", "350000", "121111" ], + "121052" : [ "17:32", "350000", "121112" ], + "121053" : [ "17:33", "350000", "121113" ], + "121054" : [ "17:34", "350000", "121114" ], + "121055" : [ "17:35", "350000", "121115" ], + "121056" : [ "17:36", "350000", "121116" ], + "121057" : [ "17:37", "350000", "121117" ], + "121058" : [ "17:38", "350000", "121118" ], + "121059" : [ "17:39", "350000", "121119" ], + "121060" : [ "17:40", "350000", "121120" ], + "121061" : [ "17:41", "350000", "121121" ], + "121062" : [ "17:42", "350000", "121122" ], + "121063" : [ "17:43", "350000", "121123" ], + "121064" : [ "17:44", "350000", "121124" ], + "121065" : [ "17:45", "350000", "121125" ], + "121066" : [ "17:46", "350000", "121126" ], + "121067" : [ "17:47", "350000", "121127" ], + "121068" : [ "17:48", "350000", "121128" ], + "121069" : [ "17:49", "350000", "121129" ], + "121070" : [ "17:50", "350000", "121130" ], + "121071" : [ "17:51", "350000", "121131" ], + "121072" : [ "17:52", "350000", "121132" ], + "121073" : [ "17:53", "350000", "121133" ], + "121074" : [ "17:54", "350000", "121134" ], + "121075" : [ "17:55", "350000", "121135" ], + "121076" : [ "17:56", "350000", "121136" ], + "121077" : [ "17:57", "350000", "121137" ], + "121078" : [ "17:58", "350000", "121138" ], + "121079" : [ "17:59", "350000", "121139" ], + "121080" : [ "18:00", "350000", "121140" ], + "121081" : [ "18:01", "350000", "121141" ], + "121082" : [ "18:02", "350000", "121142" ], + "121083" : [ "18:03", "350000", "121143" ], + "121084" : [ "18:04", "350000", "121144" ], + "121085" : [ "18:05", "350000", "121145" ], + "121086" : [ "18:06", "350000", "121146" ], + "121087" : [ "18:07", "350000", "121147" ], + "121088" : [ "18:08", "350000", "121148" ], + "121089" : [ "18:09", "350000", "121149" ], + "121090" : [ "18:10", "350000", "121150" ], + "121091" : [ "18:11", "350000", "121151" ], + "121092" : [ "18:12", "350000", "121152" ], + "121093" : [ "18:13", "350000", "121153" ], + "121094" : [ "18:14", "350000", "121154" ], + "121095" : [ "18:15", "350000", "121155" ], + "121096" : [ "18:16", "350000", "121156" ], + "121097" : [ "18:17", "350000", "121157" ], + "121098" : [ "18:18", "350000", "121158" ], + "121099" : [ "18:19", "350000", "121159" ], + "121100" : [ "18:20", "350000", "121160" ], + "121101" : [ "18:21", "350000", "121161" ], + "121102" : [ "18:22", "350000", "121162" ], + "121103" : [ "18:23", "350000", "121163" ], + "121104" : [ "18:24", "350000", "121164" ], + "121105" : [ "18:25", "350000", "121165" ], + "121106" : [ "18:26", "350000", "121166" ], + "121107" : [ "18:27", "350000", "121167" ], + "121108" : [ "18:28", "350000", "121168" ], + "121109" : [ "18:29", "350000", "121169" ], + "121110" : [ "18:30", "350000", "121170" ], + "121111" : [ "18:31", "350000", "121171" ], + "121112" : [ "18:32", "350000", "121172" ], + "121113" : [ "18:33", "350000", "121173" ], + "121114" : [ "18:34", "350000", "121174" ], + "121115" : [ "18:35", "350000", "121175" ], + "121116" : [ "18:36", "350000", "121176" ], + "121117" : [ "18:37", "350000", "121177" ], + "121118" : [ "18:38", "350000", "121178" ], + "121119" : [ "18:39", "350000", "121179" ], + "121120" : [ "18:40", "350000", "121180" ], + "121121" : [ "18:41", "350000", "121181" ], + "121122" : [ "18:42", "350000", "121182" ], + "121123" : [ "18:43", "350000", "121183" ], + "121124" : [ "18:44", "350000", "121184" ], + "121125" : [ "18:45", "350000", "121185" ], + "121126" : [ "18:46", "350000", "121186" ], + "121127" : [ "18:47", "350000", "121187" ], + "121128" : [ "18:48", "350000", "121188" ], + "121129" : [ "18:49", "350000", "121189" ], + "121130" : [ "18:50", "350000", "121190" ], + "121131" : [ "18:51", "350000", "121191" ], + "121132" : [ "18:52", "350000", "121192" ], + "121133" : [ "18:53", "350000", "121193" ], + "121134" : [ "18:54", "350000", "121194" ], + "121135" : [ "18:55", "350000", "121195" ], + "121136" : [ "18:56", "350000", "121196" ], + "121137" : [ "18:57", "350000", "121197" ], + "121138" : [ "18:58", "350000", "121198" ], + "121139" : [ "18:59", "350000", "121199" ], + "121140" : [ "19:00", "350000", "121200" ], + "121141" : [ "19:01", "350000", "121200" ], + "121142" : [ "19:02", "350000", "121200" ], + "121143" : [ "19:03", "350000", "121200" ], + "121144" : [ "19:04", "350000", "121200" ], + "121145" : [ "19:05", "350000", "121200" ], + "121146" : [ "19:06", "350000", "121200" ], + "121147" : [ "19:07", "350000", "121200" ], + "121148" : [ "19:08", "350000", "121200" ], + "121149" : [ "19:09", "350000", "121200" ], + "121150" : [ "19:10", "350000", "121200" ], + "121151" : [ "19:11", "350000", "121200" ], + "121152" : [ "19:12", "350000", "121200" ], + "121153" : [ "19:13", "350000", "121200" ], + "121154" : [ "19:14", "350000", "121200" ], + "121155" : [ "19:15", "350000", "121200" ], + "121156" : [ "19:16", "350000", "121200" ], + "121157" : [ "19:17", "350000", "121200" ], + "121158" : [ "19:18", "350000", "121200" ], + "121159" : [ "19:19", "350000", "121200" ], + "121160" : [ "19:20", "350000", "121200" ], + "121161" : [ "19:21", "350000", "121200" ], + "121162" : [ "19:22", "350000", "121200" ], + "121163" : [ "19:23", "350000", "121200" ], + "121164" : [ "19:24", "350000", "121200" ], + "121165" : [ "19:25", "350000", "121200" ], + "121166" : [ "19:26", "350000", "121200" ], + "121167" : [ "19:27", "350000", "121200" ], + "121168" : [ "19:28", "350000", "121200" ], + "121169" : [ "19:29", "350000", "121200" ], + "121170" : [ "19:30", "350000", "121200" ], + "121171" : [ "19:31", "350000", "121200" ], + "121172" : [ "19:32", "350000", "121200" ], + "121173" : [ "19:33", "350000", "121200" ], + "121174" : [ "19:34", "350000", "121200" ], + "121175" : [ "19:35", "350000", "121200" ], + "121176" : [ "19:36", "350000", "121200" ], + "121177" : [ "19:37", "350000", "121200" ], + "121178" : [ "19:38", "350000", "121200" ], + "121179" : [ "19:39", "350000", "121200" ], + "121180" : [ "19:40", "350000", "121200" ], + "121181" : [ "19:41", "350000", "121200" ], + "121182" : [ "19:42", "350000", "121200" ], + "121183" : [ "19:43", "350000", "121200" ], + "121184" : [ "19:44", "350000", "121200" ], + "121185" : [ "19:45", "350000", "121200" ], + "121186" : [ "19:46", "350000", "121200" ], + "121187" : [ "19:47", "350000", "121200" ], + "121188" : [ "19:48", "350000", "121200" ], + "121189" : [ "19:49", "350000", "121200" ], + "121190" : [ "19:50", "350000", "121200" ], + "121191" : [ "19:51", "350000", "121200" ], + "121192" : [ "19:52", "350000", "121200" ], + "121193" : [ "19:53", "350000", "121200" ], + "121194" : [ "19:54", "350000", "121200" ], + "121195" : [ "19:55", "350000", "121200" ], + "121196" : [ "19:56", "350000", "121200" ], + "121197" : [ "19:57", "350000", "121200" ], + "121198" : [ "19:58", "350000", "121200" ], + "121199" : [ "19:59", "350000", "121200" ], + "121200" : [ "20:00", "800000", "130420" ], + "121201" : [ "20:01", "800000", "130420" ], + "121202" : [ "20:02", "800000", "130420" ], + "121203" : [ "20:03", "800000", "130420" ], + "121204" : [ "20:04", "800000", "130420" ], + "121205" : [ "20:05", "800000", "130420" ], + "121206" : [ "20:06", "800000", "130420" ], + "121207" : [ "20:07", "800000", "130420" ], + "121208" : [ "20:08", "800000", "130420" ], + "121209" : [ "20:09", "800000", "130420" ], + "121210" : [ "20:10", "800000", "130420" ], + "121211" : [ "20:11", "800000", "130420" ], + "121212" : [ "20:12", "800000", "130420" ], + "121213" : [ "20:13", "800000", "130420" ], + "121214" : [ "20:14", "800000", "130420" ], + "121215" : [ "20:15", "800000", "130420" ], + "121216" : [ "20:16", "800000", "130420" ], + "121217" : [ "20:17", "800000", "130420" ], + "121218" : [ "20:18", "800000", "130420" ], + "121219" : [ "20:19", "800000", "130420" ], + "121220" : [ "20:20", "800000", "130420" ], + "121221" : [ "20:21", "800000", "130420" ], + "121222" : [ "20:22", "800000", "130420" ], + "121223" : [ "20:23", "800000", "130420" ], + "121224" : [ "20:24", "800000", "130420" ], + "121225" : [ "20:25", "800000", "130420" ], + "121226" : [ "20:26", "800000", "130420" ], + "121227" : [ "20:27", "800000", "130420" ], + "121228" : [ "20:28", "800000", "130420" ], + "121229" : [ "20:29", "800000", "130420" ], + "121230" : [ "20:30", "800000", "130420" ], + "121231" : [ "20:31", "800000", "130420" ], + "121232" : [ "20:32", "800000", "130420" ], + "121233" : [ "20:33", "800000", "130420" ], + "121234" : [ "20:34", "800000", "130420" ], + "121235" : [ "20:35", "800000", "130420" ], + "121236" : [ "20:36", "800000", "130420" ], + "121237" : [ "20:37", "800000", "130420" ], + "121238" : [ "20:38", "800000", "130420" ], + "121239" : [ "20:39", "800000", "130420" ], + "121240" : [ "20:40", "800000", "130420" ], + "121241" : [ "20:41", "800000", "130420" ], + "121242" : [ "20:42", "800000", "130420" ], + "121243" : [ "20:43", "800000", "130420" ], + "121244" : [ "20:44", "800000", "130420" ], + "121245" : [ "20:45", "800000", "130420" ], + "121246" : [ "20:46", "800000", "130420" ], + "121247" : [ "20:47", "800000", "130420" ], + "121248" : [ "20:48", "800000", "130420" ], + "121249" : [ "20:49", "800000", "130420" ], + "121250" : [ "20:50", "800000", "130420" ], + "121251" : [ "20:51", "800000", "130420" ], + "121252" : [ "20:52", "800000", "130420" ], + "121253" : [ "20:53", "800000", "130420" ], + "121254" : [ "20:54", "800000", "130420" ], + "121255" : [ "20:55", "800000", "130420" ], + "121256" : [ "20:56", "800000", "130420" ], + "121257" : [ "20:57", "800000", "130420" ], + "121258" : [ "20:58", "800000", "130420" ], + "121259" : [ "20:59", "800000", "130420" ], + "121260" : [ "21:00", "800000", "130420" ], + "121261" : [ "21:01", "800000", "130420" ], + "121262" : [ "21:02", "800000", "130420" ], + "121263" : [ "21:03", "800000", "130420" ], + "121264" : [ "21:04", "800000", "130420" ], + "121265" : [ "21:05", "800000", "130420" ], + "121266" : [ "21:06", "800000", "130420" ], + "121267" : [ "21:07", "800000", "130420" ], + "121268" : [ "21:08", "800000", "130420" ], + "121269" : [ "21:09", "800000", "130420" ], + "121270" : [ "21:10", "800000", "130420" ], + "121271" : [ "21:11", "800000", "130420" ], + "121272" : [ "21:12", "800000", "130420" ], + "121273" : [ "21:13", "800000", "130420" ], + "121274" : [ "21:14", "800000", "130420" ], + "121275" : [ "21:15", "800000", "130420" ], + "121276" : [ "21:16", "800000", "130420" ], + "121277" : [ "21:17", "800000", "130420" ], + "121278" : [ "21:18", "800000", "130420" ], + "121279" : [ "21:19", "800000", "130420" ], + "121280" : [ "21:20", "800000", "130420" ], + "121281" : [ "21:21", "800000", "130420" ], + "121282" : [ "21:22", "800000", "130420" ], + "121283" : [ "21:23", "800000", "130420" ], + "121284" : [ "21:24", "800000", "130420" ], + "121285" : [ "21:25", "800000", "130420" ], + "121286" : [ "21:26", "800000", "130420" ], + "121287" : [ "21:27", "800000", "130420" ], + "121288" : [ "21:28", "800000", "130420" ], + "121289" : [ "21:29", "800000", "130420" ], + "121290" : [ "21:30", "800000", "130420" ], + "121291" : [ "21:31", "800000", "130420" ], + "121292" : [ "21:32", "800000", "130420" ], + "121293" : [ "21:33", "800000", "130420" ], + "121294" : [ "21:34", "800000", "130420" ], + "121295" : [ "21:35", "800000", "130420" ], + "121296" : [ "21:36", "800000", "130420" ], + "121297" : [ "21:37", "800000", "130420" ], + "121298" : [ "21:38", "800000", "130420" ], + "121299" : [ "21:39", "800000", "130420" ], + "121300" : [ "21:40", "800000", "130420" ], + "121301" : [ "21:41", "800000", "130420" ], + "121302" : [ "21:42", "800000", "130420" ], + "121303" : [ "21:43", "800000", "130420" ], + "121304" : [ "21:44", "800000", "130420" ], + "121305" : [ "21:45", "800000", "130420" ], + "121306" : [ "21:46", "800000", "130420" ], + "121307" : [ "21:47", "800000", "130420" ], + "121308" : [ "21:48", "800000", "130420" ], + "121309" : [ "21:49", "800000", "130420" ], + "121310" : [ "21:50", "800000", "130420" ], + "121311" : [ "21:51", "800000", "130420" ], + "121312" : [ "21:52", "800000", "130420" ], + "121313" : [ "21:53", "800000", "130420" ], + "121314" : [ "21:54", "800000", "130420" ], + "121315" : [ "21:55", "800000", "130420" ], + "121316" : [ "21:56", "800000", "130420" ], + "121317" : [ "21:57", "800000", "130420" ], + "121318" : [ "21:58", "800000", "130420" ], + "121319" : [ "21:59", "800000", "130420" ], + "121320" : [ "22:00", "800000", "130420" ], + "121321" : [ "22:01", "800000", "130420" ], + "121322" : [ "22:02", "800000", "130420" ], + "121323" : [ "22:03", "800000", "130420" ], + "121324" : [ "22:04", "800000", "130420" ], + "121325" : [ "22:05", "800000", "130420" ], + "121326" : [ "22:06", "800000", "130420" ], + "121327" : [ "22:07", "800000", "130420" ], + "121328" : [ "22:08", "800000", "130420" ], + "121329" : [ "22:09", "800000", "130420" ], + "121330" : [ "22:10", "800000", "130420" ], + "121331" : [ "22:11", "800000", "130420" ], + "121332" : [ "22:12", "800000", "130420" ], + "121333" : [ "22:13", "800000", "130420" ], + "121334" : [ "22:14", "800000", "130420" ], + "121335" : [ "22:15", "800000", "130420" ], + "121336" : [ "22:16", "800000", "130420" ], + "121337" : [ "22:17", "800000", "130420" ], + "121338" : [ "22:18", "800000", "130420" ], + "121339" : [ "22:19", "800000", "130420" ], + "121340" : [ "22:20", "800000", "130420" ], + "121341" : [ "22:21", "800000", "130420" ], + "121342" : [ "22:22", "800000", "130420" ], + "121343" : [ "22:23", "800000", "130420" ], + "121344" : [ "22:24", "800000", "130420" ], + "121345" : [ "22:25", "800000", "130420" ], + "121346" : [ "22:26", "800000", "130420" ], + "121347" : [ "22:27", "800000", "130420" ], + "121348" : [ "22:28", "800000", "130420" ], + "121349" : [ "22:29", "800000", "130420" ], + "121350" : [ "22:30", "800000", "130420" ], + "121351" : [ "22:31", "800000", "130420" ], + "121352" : [ "22:32", "800000", "130420" ], + "121353" : [ "22:33", "800000", "130420" ], + "121354" : [ "22:34", "800000", "130420" ], + "121355" : [ "22:35", "800000", "130420" ], + "121356" : [ "22:36", "800000", "130420" ], + "121357" : [ "22:37", "800000", "130420" ], + "121358" : [ "22:38", "800000", "130420" ], + "121359" : [ "22:39", "800000", "130420" ], + "121360" : [ "22:40", "800000", "130420" ], + "121361" : [ "22:41", "800000", "130420" ], + "121362" : [ "22:42", "800000", "130420" ], + "121363" : [ "22:43", "800000", "130420" ], + "121364" : [ "22:44", "800000", "130420" ], + "121365" : [ "22:45", "800000", "130420" ], + "121366" : [ "22:46", "800000", "130420" ], + "121367" : [ "22:47", "800000", "130420" ], + "121368" : [ "22:48", "800000", "130420" ], + "121369" : [ "22:49", "800000", "130420" ], + "121370" : [ "22:50", "800000", "130420" ], + "121371" : [ "22:51", "800000", "130420" ], + "121372" : [ "22:52", "800000", "130420" ], + "121373" : [ "22:53", "800000", "130420" ], + "121374" : [ "22:54", "800000", "130420" ], + "121375" : [ "22:55", "800000", "130420" ], + "121376" : [ "22:56", "800000", "130420" ], + "121377" : [ "22:57", "800000", "130420" ], + "121378" : [ "22:58", "800000", "130420" ], + "121379" : [ "22:59", "800000", "130420" ], + "121380" : [ "23:00", "800000", "130420" ], + "121381" : [ "23:01", "800000", "130420" ], + "121382" : [ "23:02", "800000", "130420" ], + "121383" : [ "23:03", "800000", "130420" ], + "121384" : [ "23:04", "800000", "130420" ], + "121385" : [ "23:05", "800000", "130420" ], + "121386" : [ "23:06", "800000", "130420" ], + "121387" : [ "23:07", "800000", "130420" ], + "121388" : [ "23:08", "800000", "130420" ], + "121389" : [ "23:09", "800000", "130420" ], + "121390" : [ "23:10", "800000", "130420" ], + "121391" : [ "23:11", "800000", "130420" ], + "121392" : [ "23:12", "800000", "130420" ], + "121393" : [ "23:13", "800000", "130420" ], + "121394" : [ "23:14", "800000", "130420" ], + "121395" : [ "23:15", "800000", "130420" ], + "121396" : [ "23:16", "800000", "130420" ], + "121397" : [ "23:17", "800000", "130420" ], + "121398" : [ "23:18", "800000", "130420" ], + "121399" : [ "23:19", "800000", "130420" ], + "121400" : [ "23:20", "800000", "130420" ], + "121401" : [ "23:21", "800000", "130420" ], + "121402" : [ "23:22", "800000", "130420" ], + "121403" : [ "23:23", "800000", "130420" ], + "121404" : [ "23:24", "800000", "130420" ], + "121405" : [ "23:25", "800000", "130420" ], + "121406" : [ "23:26", "800000", "130420" ], + "121407" : [ "23:27", "800000", "130420" ], + "121408" : [ "23:28", "800000", "130420" ], + "121409" : [ "23:29", "800000", "130420" ], + "121410" : [ "23:30", "800000", "130420" ], + "121411" : [ "23:31", "800000", "130420" ], + "121412" : [ "23:32", "800000", "130420" ], + "121413" : [ "23:33", "800000", "130420" ], + "121414" : [ "23:34", "800000", "130420" ], + "121415" : [ "23:35", "800000", "130420" ], + "121416" : [ "23:36", "800000", "130420" ], + "121417" : [ "23:37", "800000", "130420" ], + "121418" : [ "23:38", "800000", "130420" ], + "121419" : [ "23:39", "800000", "130420" ], + "121420" : [ "23:40", "800000", "130420" ], + "121421" : [ "23:41", "800000", "130420" ], + "121422" : [ "23:42", "800000", "130420" ], + "121423" : [ "23:43", "800000", "130420" ], + "121424" : [ "23:44", "800000", "130420" ], + "121425" : [ "23:45", "800000", "130420" ], + "121426" : [ "23:46", "800000", "130420" ], + "121427" : [ "23:47", "800000", "130420" ], + "121428" : [ "23:48", "800000", "130420" ], + "121429" : [ "23:49", "800000", "130420" ], + "121430" : [ "23:50", "800000", "130420" ], + "121431" : [ "23:51", "800000", "130420" ], + "121432" : [ "23:52", "800000", "130420" ], + "121433" : [ "23:53", "800000", "130420" ], + "121434" : [ "23:54", "800000", "130420" ], + "121435" : [ "23:55", "800000", "130420" ], + "121436" : [ "23:56", "800000", "130420" ], + "121437" : [ "23:57", "800000", "130420" ], + "121438" : [ "23:58", "800000", "130420" ], + "121439" : [ "23:59", "800000", "130420" ] + }, + "Thursday": { + "130000" : [ "00:00", "800000", "130420" ], + "130001" : [ "00:01", "800000", "130420" ], + "130002" : [ "00:02", "800000", "130420" ], + "130003" : [ "00:03", "800000", "130420" ], + "130004" : [ "00:04", "800000", "130420" ], + "130005" : [ "00:05", "800000", "130420" ], + "130006" : [ "00:06", "800000", "130420" ], + "130007" : [ "00:07", "800000", "130420" ], + "130008" : [ "00:08", "800000", "130420" ], + "130009" : [ "00:09", "800000", "130420" ], + "130010" : [ "00:10", "800000", "130420" ], + "130011" : [ "00:11", "800000", "130420" ], + "130012" : [ "00:12", "800000", "130420" ], + "130013" : [ "00:13", "800000", "130420" ], + "130014" : [ "00:14", "800000", "130420" ], + "130015" : [ "00:15", "800000", "130420" ], + "130016" : [ "00:16", "800000", "130420" ], + "130017" : [ "00:17", "800000", "130420" ], + "130018" : [ "00:18", "800000", "130420" ], + "130019" : [ "00:19", "800000", "130420" ], + "130020" : [ "00:20", "800000", "130420" ], + "130021" : [ "00:21", "800000", "130420" ], + "130022" : [ "00:22", "800000", "130420" ], + "130023" : [ "00:23", "800000", "130420" ], + "130024" : [ "00:24", "800000", "130420" ], + "130025" : [ "00:25", "800000", "130420" ], + "130026" : [ "00:26", "800000", "130420" ], + "130027" : [ "00:27", "800000", "130420" ], + "130028" : [ "00:28", "800000", "130420" ], + "130029" : [ "00:29", "800000", "130420" ], + "130030" : [ "00:30", "800000", "130420" ], + "130031" : [ "00:31", "800000", "130420" ], + "130032" : [ "00:32", "800000", "130420" ], + "130033" : [ "00:33", "800000", "130420" ], + "130034" : [ "00:34", "800000", "130420" ], + "130035" : [ "00:35", "800000", "130420" ], + "130036" : [ "00:36", "800000", "130420" ], + "130037" : [ "00:37", "800000", "130420" ], + "130038" : [ "00:38", "800000", "130420" ], + "130039" : [ "00:39", "800000", "130420" ], + "130040" : [ "00:40", "800000", "130420" ], + "130041" : [ "00:41", "800000", "130420" ], + "130042" : [ "00:42", "800000", "130420" ], + "130043" : [ "00:43", "800000", "130420" ], + "130044" : [ "00:44", "800000", "130420" ], + "130045" : [ "00:45", "800000", "130420" ], + "130046" : [ "00:46", "800000", "130420" ], + "130047" : [ "00:47", "800000", "130420" ], + "130048" : [ "00:48", "800000", "130420" ], + "130049" : [ "00:49", "800000", "130420" ], + "130050" : [ "00:50", "800000", "130420" ], + "130051" : [ "00:51", "800000", "130420" ], + "130052" : [ "00:52", "800000", "130420" ], + "130053" : [ "00:53", "800000", "130420" ], + "130054" : [ "00:54", "800000", "130420" ], + "130055" : [ "00:55", "800000", "130420" ], + "130056" : [ "00:56", "800000", "130420" ], + "130057" : [ "00:57", "800000", "130420" ], + "130058" : [ "00:58", "800000", "130420" ], + "130059" : [ "00:59", "800000", "130420" ], + "130060" : [ "01:00", "800000", "130420" ], + "130061" : [ "01:01", "800000", "130420" ], + "130062" : [ "01:02", "800000", "130420" ], + "130063" : [ "01:03", "800000", "130420" ], + "130064" : [ "01:04", "800000", "130420" ], + "130065" : [ "01:05", "800000", "130420" ], + "130066" : [ "01:06", "800000", "130420" ], + "130067" : [ "01:07", "800000", "130420" ], + "130068" : [ "01:08", "800000", "130420" ], + "130069" : [ "01:09", "800000", "130420" ], + "130070" : [ "01:10", "800000", "130420" ], + "130071" : [ "01:11", "800000", "130420" ], + "130072" : [ "01:12", "800000", "130420" ], + "130073" : [ "01:13", "800000", "130420" ], + "130074" : [ "01:14", "800000", "130420" ], + "130075" : [ "01:15", "800000", "130420" ], + "130076" : [ "01:16", "800000", "130420" ], + "130077" : [ "01:17", "800000", "130420" ], + "130078" : [ "01:18", "800000", "130420" ], + "130079" : [ "01:19", "800000", "130420" ], + "130080" : [ "01:20", "800000", "130420" ], + "130081" : [ "01:21", "800000", "130420" ], + "130082" : [ "01:22", "800000", "130420" ], + "130083" : [ "01:23", "800000", "130420" ], + "130084" : [ "01:24", "800000", "130420" ], + "130085" : [ "01:25", "800000", "130420" ], + "130086" : [ "01:26", "800000", "130420" ], + "130087" : [ "01:27", "800000", "130420" ], + "130088" : [ "01:28", "800000", "130420" ], + "130089" : [ "01:29", "800000", "130420" ], + "130090" : [ "01:30", "800000", "130420" ], + "130091" : [ "01:31", "800000", "130420" ], + "130092" : [ "01:32", "800000", "130420" ], + "130093" : [ "01:33", "800000", "130420" ], + "130094" : [ "01:34", "800000", "130420" ], + "130095" : [ "01:35", "800000", "130420" ], + "130096" : [ "01:36", "800000", "130420" ], + "130097" : [ "01:37", "800000", "130420" ], + "130098" : [ "01:38", "800000", "130420" ], + "130099" : [ "01:39", "800000", "130420" ], + "130100" : [ "01:40", "800000", "130420" ], + "130101" : [ "01:41", "800000", "130420" ], + "130102" : [ "01:42", "800000", "130420" ], + "130103" : [ "01:43", "800000", "130420" ], + "130104" : [ "01:44", "800000", "130420" ], + "130105" : [ "01:45", "800000", "130420" ], + "130106" : [ "01:46", "800000", "130420" ], + "130107" : [ "01:47", "800000", "130420" ], + "130108" : [ "01:48", "800000", "130420" ], + "130109" : [ "01:49", "800000", "130420" ], + "130110" : [ "01:50", "800000", "130420" ], + "130111" : [ "01:51", "800000", "130420" ], + "130112" : [ "01:52", "800000", "130420" ], + "130113" : [ "01:53", "800000", "130420" ], + "130114" : [ "01:54", "800000", "130420" ], + "130115" : [ "01:55", "800000", "130420" ], + "130116" : [ "01:56", "800000", "130420" ], + "130117" : [ "01:57", "800000", "130420" ], + "130118" : [ "01:58", "800000", "130420" ], + "130119" : [ "01:59", "800000", "130420" ], + "130120" : [ "02:00", "800000", "130420" ], + "130121" : [ "02:01", "800000", "130420" ], + "130122" : [ "02:02", "800000", "130420" ], + "130123" : [ "02:03", "800000", "130420" ], + "130124" : [ "02:04", "800000", "130420" ], + "130125" : [ "02:05", "800000", "130420" ], + "130126" : [ "02:06", "800000", "130420" ], + "130127" : [ "02:07", "800000", "130420" ], + "130128" : [ "02:08", "800000", "130420" ], + "130129" : [ "02:09", "800000", "130420" ], + "130130" : [ "02:10", "800000", "130420" ], + "130131" : [ "02:11", "800000", "130420" ], + "130132" : [ "02:12", "800000", "130420" ], + "130133" : [ "02:13", "800000", "130420" ], + "130134" : [ "02:14", "800000", "130420" ], + "130135" : [ "02:15", "800000", "130420" ], + "130136" : [ "02:16", "800000", "130420" ], + "130137" : [ "02:17", "800000", "130420" ], + "130138" : [ "02:18", "800000", "130420" ], + "130139" : [ "02:19", "800000", "130420" ], + "130140" : [ "02:20", "800000", "130420" ], + "130141" : [ "02:21", "800000", "130420" ], + "130142" : [ "02:22", "800000", "130420" ], + "130143" : [ "02:23", "800000", "130420" ], + "130144" : [ "02:24", "800000", "130420" ], + "130145" : [ "02:25", "800000", "130420" ], + "130146" : [ "02:26", "800000", "130420" ], + "130147" : [ "02:27", "800000", "130420" ], + "130148" : [ "02:28", "800000", "130420" ], + "130149" : [ "02:29", "800000", "130420" ], + "130150" : [ "02:30", "800000", "130420" ], + "130151" : [ "02:31", "800000", "130420" ], + "130152" : [ "02:32", "800000", "130420" ], + "130153" : [ "02:33", "800000", "130420" ], + "130154" : [ "02:34", "800000", "130420" ], + "130155" : [ "02:35", "800000", "130420" ], + "130156" : [ "02:36", "800000", "130420" ], + "130157" : [ "02:37", "800000", "130420" ], + "130158" : [ "02:38", "800000", "130420" ], + "130159" : [ "02:39", "800000", "130420" ], + "130160" : [ "02:40", "800000", "130420" ], + "130161" : [ "02:41", "800000", "130420" ], + "130162" : [ "02:42", "800000", "130420" ], + "130163" : [ "02:43", "800000", "130420" ], + "130164" : [ "02:44", "800000", "130420" ], + "130165" : [ "02:45", "800000", "130420" ], + "130166" : [ "02:46", "800000", "130420" ], + "130167" : [ "02:47", "800000", "130420" ], + "130168" : [ "02:48", "800000", "130420" ], + "130169" : [ "02:49", "800000", "130420" ], + "130170" : [ "02:50", "800000", "130420" ], + "130171" : [ "02:51", "800000", "130420" ], + "130172" : [ "02:52", "800000", "130420" ], + "130173" : [ "02:53", "800000", "130420" ], + "130174" : [ "02:54", "800000", "130420" ], + "130175" : [ "02:55", "800000", "130420" ], + "130176" : [ "02:56", "800000", "130420" ], + "130177" : [ "02:57", "800000", "130420" ], + "130178" : [ "02:58", "800000", "130420" ], + "130179" : [ "02:59", "800000", "130420" ], + "130180" : [ "03:00", "800000", "130420" ], + "130181" : [ "03:01", "800000", "130420" ], + "130182" : [ "03:02", "800000", "130420" ], + "130183" : [ "03:03", "800000", "130420" ], + "130184" : [ "03:04", "800000", "130420" ], + "130185" : [ "03:05", "800000", "130420" ], + "130186" : [ "03:06", "800000", "130420" ], + "130187" : [ "03:07", "800000", "130420" ], + "130188" : [ "03:08", "800000", "130420" ], + "130189" : [ "03:09", "800000", "130420" ], + "130190" : [ "03:10", "800000", "130420" ], + "130191" : [ "03:11", "800000", "130420" ], + "130192" : [ "03:12", "800000", "130420" ], + "130193" : [ "03:13", "800000", "130420" ], + "130194" : [ "03:14", "800000", "130420" ], + "130195" : [ "03:15", "800000", "130420" ], + "130196" : [ "03:16", "800000", "130420" ], + "130197" : [ "03:17", "800000", "130420" ], + "130198" : [ "03:18", "800000", "130420" ], + "130199" : [ "03:19", "800000", "130420" ], + "130200" : [ "03:20", "800000", "130420" ], + "130201" : [ "03:21", "800000", "130420" ], + "130202" : [ "03:22", "800000", "130420" ], + "130203" : [ "03:23", "800000", "130420" ], + "130204" : [ "03:24", "800000", "130420" ], + "130205" : [ "03:25", "800000", "130420" ], + "130206" : [ "03:26", "800000", "130420" ], + "130207" : [ "03:27", "800000", "130420" ], + "130208" : [ "03:28", "800000", "130420" ], + "130209" : [ "03:29", "800000", "130420" ], + "130210" : [ "03:30", "800000", "130420" ], + "130211" : [ "03:31", "800000", "130420" ], + "130212" : [ "03:32", "800000", "130420" ], + "130213" : [ "03:33", "800000", "130420" ], + "130214" : [ "03:34", "800000", "130420" ], + "130215" : [ "03:35", "800000", "130420" ], + "130216" : [ "03:36", "800000", "130420" ], + "130217" : [ "03:37", "800000", "130420" ], + "130218" : [ "03:38", "800000", "130420" ], + "130219" : [ "03:39", "800000", "130420" ], + "130220" : [ "03:40", "800000", "130420" ], + "130221" : [ "03:41", "800000", "130420" ], + "130222" : [ "03:42", "800000", "130420" ], + "130223" : [ "03:43", "800000", "130420" ], + "130224" : [ "03:44", "800000", "130420" ], + "130225" : [ "03:45", "800000", "130420" ], + "130226" : [ "03:46", "800000", "130420" ], + "130227" : [ "03:47", "800000", "130420" ], + "130228" : [ "03:48", "800000", "130420" ], + "130229" : [ "03:49", "800000", "130420" ], + "130230" : [ "03:50", "800000", "130420" ], + "130231" : [ "03:51", "800000", "130420" ], + "130232" : [ "03:52", "800000", "130420" ], + "130233" : [ "03:53", "800000", "130420" ], + "130234" : [ "03:54", "800000", "130420" ], + "130235" : [ "03:55", "800000", "130420" ], + "130236" : [ "03:56", "800000", "130420" ], + "130237" : [ "03:57", "800000", "130420" ], + "130238" : [ "03:58", "800000", "130420" ], + "130239" : [ "03:59", "800000", "130420" ], + "130240" : [ "04:00", "800000", "130420" ], + "130241" : [ "04:01", "800000", "130420" ], + "130242" : [ "04:02", "800000", "130420" ], + "130243" : [ "04:03", "800000", "130420" ], + "130244" : [ "04:04", "800000", "130420" ], + "130245" : [ "04:05", "800000", "130420" ], + "130246" : [ "04:06", "800000", "130420" ], + "130247" : [ "04:07", "800000", "130420" ], + "130248" : [ "04:08", "800000", "130420" ], + "130249" : [ "04:09", "800000", "130420" ], + "130250" : [ "04:10", "800000", "130420" ], + "130251" : [ "04:11", "800000", "130420" ], + "130252" : [ "04:12", "800000", "130420" ], + "130253" : [ "04:13", "800000", "130420" ], + "130254" : [ "04:14", "800000", "130420" ], + "130255" : [ "04:15", "800000", "130420" ], + "130256" : [ "04:16", "800000", "130420" ], + "130257" : [ "04:17", "800000", "130420" ], + "130258" : [ "04:18", "800000", "130420" ], + "130259" : [ "04:19", "800000", "130420" ], + "130260" : [ "04:20", "800000", "130420" ], + "130261" : [ "04:21", "800000", "130420" ], + "130262" : [ "04:22", "800000", "130420" ], + "130263" : [ "04:23", "800000", "130420" ], + "130264" : [ "04:24", "800000", "130420" ], + "130265" : [ "04:25", "800000", "130420" ], + "130266" : [ "04:26", "800000", "130420" ], + "130267" : [ "04:27", "800000", "130420" ], + "130268" : [ "04:28", "800000", "130420" ], + "130269" : [ "04:29", "800000", "130420" ], + "130270" : [ "04:30", "800000", "130420" ], + "130271" : [ "04:31", "800000", "130420" ], + "130272" : [ "04:32", "800000", "130420" ], + "130273" : [ "04:33", "800000", "130420" ], + "130274" : [ "04:34", "800000", "130420" ], + "130275" : [ "04:35", "800000", "130420" ], + "130276" : [ "04:36", "800000", "130420" ], + "130277" : [ "04:37", "800000", "130420" ], + "130278" : [ "04:38", "800000", "130420" ], + "130279" : [ "04:39", "800000", "130420" ], + "130280" : [ "04:40", "800000", "130420" ], + "130281" : [ "04:41", "800000", "130420" ], + "130282" : [ "04:42", "800000", "130420" ], + "130283" : [ "04:43", "800000", "130420" ], + "130284" : [ "04:44", "800000", "130420" ], + "130285" : [ "04:45", "800000", "130420" ], + "130286" : [ "04:46", "800000", "130420" ], + "130287" : [ "04:47", "800000", "130420" ], + "130288" : [ "04:48", "800000", "130420" ], + "130289" : [ "04:49", "800000", "130420" ], + "130290" : [ "04:50", "800000", "130420" ], + "130291" : [ "04:51", "800000", "130420" ], + "130292" : [ "04:52", "800000", "130420" ], + "130293" : [ "04:53", "800000", "130420" ], + "130294" : [ "04:54", "800000", "130420" ], + "130295" : [ "04:55", "800000", "130420" ], + "130296" : [ "04:56", "800000", "130420" ], + "130297" : [ "04:57", "800000", "130420" ], + "130298" : [ "04:58", "800000", "130420" ], + "130299" : [ "04:59", "800000", "130420" ], + "130300" : [ "05:00", "800000", "130420" ], + "130301" : [ "05:01", "800000", "130420" ], + "130302" : [ "05:02", "800000", "130420" ], + "130303" : [ "05:03", "800000", "130420" ], + "130304" : [ "05:04", "800000", "130420" ], + "130305" : [ "05:05", "800000", "130420" ], + "130306" : [ "05:06", "800000", "130420" ], + "130307" : [ "05:07", "800000", "130420" ], + "130308" : [ "05:08", "800000", "130420" ], + "130309" : [ "05:09", "800000", "130420" ], + "130310" : [ "05:10", "800000", "130420" ], + "130311" : [ "05:11", "800000", "130420" ], + "130312" : [ "05:12", "800000", "130420" ], + "130313" : [ "05:13", "800000", "130420" ], + "130314" : [ "05:14", "800000", "130420" ], + "130315" : [ "05:15", "800000", "130420" ], + "130316" : [ "05:16", "800000", "130420" ], + "130317" : [ "05:17", "800000", "130420" ], + "130318" : [ "05:18", "800000", "130420" ], + "130319" : [ "05:19", "800000", "130420" ], + "130320" : [ "05:20", "800000", "130420" ], + "130321" : [ "05:21", "800000", "130420" ], + "130322" : [ "05:22", "800000", "130420" ], + "130323" : [ "05:23", "800000", "130420" ], + "130324" : [ "05:24", "800000", "130420" ], + "130325" : [ "05:25", "800000", "130420" ], + "130326" : [ "05:26", "800000", "130420" ], + "130327" : [ "05:27", "800000", "130420" ], + "130328" : [ "05:28", "800000", "130420" ], + "130329" : [ "05:29", "800000", "130420" ], + "130330" : [ "05:30", "800000", "130420" ], + "130331" : [ "05:31", "800000", "130420" ], + "130332" : [ "05:32", "800000", "130420" ], + "130333" : [ "05:33", "800000", "130420" ], + "130334" : [ "05:34", "800000", "130420" ], + "130335" : [ "05:35", "800000", "130420" ], + "130336" : [ "05:36", "800000", "130420" ], + "130337" : [ "05:37", "800000", "130420" ], + "130338" : [ "05:38", "800000", "130420" ], + "130339" : [ "05:39", "800000", "130420" ], + "130340" : [ "05:40", "800000", "130420" ], + "130341" : [ "05:41", "800000", "130420" ], + "130342" : [ "05:42", "800000", "130420" ], + "130343" : [ "05:43", "800000", "130420" ], + "130344" : [ "05:44", "800000", "130420" ], + "130345" : [ "05:45", "800000", "130420" ], + "130346" : [ "05:46", "800000", "130420" ], + "130347" : [ "05:47", "800000", "130420" ], + "130348" : [ "05:48", "800000", "130420" ], + "130349" : [ "05:49", "800000", "130420" ], + "130350" : [ "05:50", "800000", "130420" ], + "130351" : [ "05:51", "800000", "130420" ], + "130352" : [ "05:52", "800000", "130420" ], + "130353" : [ "05:53", "800000", "130420" ], + "130354" : [ "05:54", "800000", "130420" ], + "130355" : [ "05:55", "800000", "130420" ], + "130356" : [ "05:56", "800000", "130420" ], + "130357" : [ "05:57", "800000", "130420" ], + "130358" : [ "05:58", "800000", "130420" ], + "130359" : [ "05:59", "800000", "130420" ], + "130360" : [ "06:00", "800000", "130420" ], + "130361" : [ "06:01", "800000", "130420" ], + "130362" : [ "06:02", "800000", "130420" ], + "130363" : [ "06:03", "800000", "130420" ], + "130364" : [ "06:04", "800000", "130420" ], + "130365" : [ "06:05", "800000", "130420" ], + "130366" : [ "06:06", "800000", "130420" ], + "130367" : [ "06:07", "800000", "130420" ], + "130368" : [ "06:08", "800000", "130420" ], + "130369" : [ "06:09", "800000", "130420" ], + "130370" : [ "06:10", "800000", "130420" ], + "130371" : [ "06:11", "800000", "130420" ], + "130372" : [ "06:12", "800000", "130420" ], + "130373" : [ "06:13", "800000", "130420" ], + "130374" : [ "06:14", "800000", "130420" ], + "130375" : [ "06:15", "800000", "130420" ], + "130376" : [ "06:16", "800000", "130420" ], + "130377" : [ "06:17", "800000", "130420" ], + "130378" : [ "06:18", "800000", "130420" ], + "130379" : [ "06:19", "800000", "130420" ], + "130380" : [ "06:20", "800000", "130420" ], + "130381" : [ "06:21", "800000", "130420" ], + "130382" : [ "06:22", "800000", "130420" ], + "130383" : [ "06:23", "800000", "130420" ], + "130384" : [ "06:24", "800000", "130420" ], + "130385" : [ "06:25", "800000", "130420" ], + "130386" : [ "06:26", "800000", "130420" ], + "130387" : [ "06:27", "800000", "130420" ], + "130388" : [ "06:28", "800000", "130420" ], + "130389" : [ "06:29", "800000", "130420" ], + "130390" : [ "06:30", "800000", "130420" ], + "130391" : [ "06:31", "800000", "130420" ], + "130392" : [ "06:32", "800000", "130420" ], + "130393" : [ "06:33", "800000", "130420" ], + "130394" : [ "06:34", "800000", "130420" ], + "130395" : [ "06:35", "800000", "130420" ], + "130396" : [ "06:36", "800000", "130420" ], + "130397" : [ "06:37", "800000", "130420" ], + "130398" : [ "06:38", "800000", "130420" ], + "130399" : [ "06:39", "800000", "130420" ], + "130400" : [ "06:40", "800000", "130420" ], + "130401" : [ "06:41", "800000", "130420" ], + "130402" : [ "06:42", "800000", "130420" ], + "130403" : [ "06:43", "800000", "130420" ], + "130404" : [ "06:44", "800000", "130420" ], + "130405" : [ "06:45", "800000", "130420" ], + "130406" : [ "06:46", "800000", "130420" ], + "130407" : [ "06:47", "800000", "130420" ], + "130408" : [ "06:48", "800000", "130420" ], + "130409" : [ "06:49", "800000", "130420" ], + "130410" : [ "06:50", "800000", "130420" ], + "130411" : [ "06:51", "800000", "130420" ], + "130412" : [ "06:52", "800000", "130420" ], + "130413" : [ "06:53", "800000", "130420" ], + "130414" : [ "06:54", "800000", "130420" ], + "130415" : [ "06:55", "800000", "130420" ], + "130416" : [ "06:56", "800000", "130420" ], + "130417" : [ "06:57", "800000", "130420" ], + "130418" : [ "06:58", "800000", "130420" ], + "130419" : [ "06:59", "800000", "130420" ], + "130420" : [ "07:00", "350000", "130480" ], + "130421" : [ "07:01", "350000", "130481" ], + "130422" : [ "07:02", "350000", "130482" ], + "130423" : [ "07:03", "350000", "130483" ], + "130424" : [ "07:04", "350000", "130484" ], + "130425" : [ "07:05", "350000", "130485" ], + "130426" : [ "07:06", "350000", "130486" ], + "130427" : [ "07:07", "350000", "130487" ], + "130428" : [ "07:08", "350000", "130488" ], + "130429" : [ "07:09", "350000", "130489" ], + "130430" : [ "07:10", "350000", "130490" ], + "130431" : [ "07:11", "350000", "130491" ], + "130432" : [ "07:12", "350000", "130492" ], + "130433" : [ "07:13", "350000", "130493" ], + "130434" : [ "07:14", "350000", "130494" ], + "130435" : [ "07:15", "350000", "130495" ], + "130436" : [ "07:16", "350000", "130496" ], + "130437" : [ "07:17", "350000", "130497" ], + "130438" : [ "07:18", "350000", "130498" ], + "130439" : [ "07:19", "350000", "130499" ], + "130440" : [ "07:20", "350000", "130500" ], + "130441" : [ "07:21", "350000", "130501" ], + "130442" : [ "07:22", "350000", "130502" ], + "130443" : [ "07:23", "350000", "130503" ], + "130444" : [ "07:24", "350000", "130504" ], + "130445" : [ "07:25", "350000", "130505" ], + "130446" : [ "07:26", "350000", "130506" ], + "130447" : [ "07:27", "350000", "130507" ], + "130448" : [ "07:28", "350000", "130508" ], + "130449" : [ "07:29", "350000", "130509" ], + "130450" : [ "07:30", "350000", "130510" ], + "130451" : [ "07:31", "350000", "130511" ], + "130452" : [ "07:32", "350000", "130512" ], + "130453" : [ "07:33", "350000", "130513" ], + "130454" : [ "07:34", "350000", "130514" ], + "130455" : [ "07:35", "350000", "130515" ], + "130456" : [ "07:36", "350000", "130516" ], + "130457" : [ "07:37", "350000", "130517" ], + "130458" : [ "07:38", "350000", "130518" ], + "130459" : [ "07:39", "350000", "130519" ], + "130460" : [ "07:40", "350000", "130520" ], + "130461" : [ "07:41", "350000", "130521" ], + "130462" : [ "07:42", "350000", "130522" ], + "130463" : [ "07:43", "350000", "130523" ], + "130464" : [ "07:44", "350000", "130524" ], + "130465" : [ "07:45", "350000", "130525" ], + "130466" : [ "07:46", "350000", "130526" ], + "130467" : [ "07:47", "350000", "130527" ], + "130468" : [ "07:48", "350000", "130528" ], + "130469" : [ "07:49", "350000", "130529" ], + "130470" : [ "07:50", "350000", "130530" ], + "130471" : [ "07:51", "350000", "130531" ], + "130472" : [ "07:52", "350000", "130532" ], + "130473" : [ "07:53", "350000", "130533" ], + "130474" : [ "07:54", "350000", "130534" ], + "130475" : [ "07:55", "350000", "130535" ], + "130476" : [ "07:56", "350000", "130536" ], + "130477" : [ "07:57", "350000", "130537" ], + "130478" : [ "07:58", "350000", "130538" ], + "130479" : [ "07:59", "350000", "130539" ], + "130480" : [ "08:00", "350000", "130540" ], + "130481" : [ "08:01", "350000", "130541" ], + "130482" : [ "08:02", "350000", "130542" ], + "130483" : [ "08:03", "350000", "130543" ], + "130484" : [ "08:04", "350000", "130544" ], + "130485" : [ "08:05", "350000", "130545" ], + "130486" : [ "08:06", "350000", "130546" ], + "130487" : [ "08:07", "350000", "130547" ], + "130488" : [ "08:08", "350000", "130548" ], + "130489" : [ "08:09", "350000", "130549" ], + "130490" : [ "08:10", "350000", "130550" ], + "130491" : [ "08:11", "350000", "130551" ], + "130492" : [ "08:12", "350000", "130552" ], + "130493" : [ "08:13", "350000", "130553" ], + "130494" : [ "08:14", "350000", "130554" ], + "130495" : [ "08:15", "350000", "130555" ], + "130496" : [ "08:16", "350000", "130556" ], + "130497" : [ "08:17", "350000", "130557" ], + "130498" : [ "08:18", "350000", "130558" ], + "130499" : [ "08:19", "350000", "130559" ], + "130500" : [ "08:20", "350000", "130560" ], + "130501" : [ "08:21", "350000", "130561" ], + "130502" : [ "08:22", "350000", "130562" ], + "130503" : [ "08:23", "350000", "130563" ], + "130504" : [ "08:24", "350000", "130564" ], + "130505" : [ "08:25", "350000", "130565" ], + "130506" : [ "08:26", "350000", "130566" ], + "130507" : [ "08:27", "350000", "130567" ], + "130508" : [ "08:28", "350000", "130568" ], + "130509" : [ "08:29", "350000", "130569" ], + "130510" : [ "08:30", "350000", "130570" ], + "130511" : [ "08:31", "350000", "130571" ], + "130512" : [ "08:32", "350000", "130572" ], + "130513" : [ "08:33", "350000", "130573" ], + "130514" : [ "08:34", "350000", "130574" ], + "130515" : [ "08:35", "350000", "130575" ], + "130516" : [ "08:36", "350000", "130576" ], + "130517" : [ "08:37", "350000", "130577" ], + "130518" : [ "08:38", "350000", "130578" ], + "130519" : [ "08:39", "350000", "130579" ], + "130520" : [ "08:40", "350000", "130580" ], + "130521" : [ "08:41", "350000", "130581" ], + "130522" : [ "08:42", "350000", "130582" ], + "130523" : [ "08:43", "350000", "130583" ], + "130524" : [ "08:44", "350000", "130584" ], + "130525" : [ "08:45", "350000", "130585" ], + "130526" : [ "08:46", "350000", "130586" ], + "130527" : [ "08:47", "350000", "130587" ], + "130528" : [ "08:48", "350000", "130588" ], + "130529" : [ "08:49", "350000", "130589" ], + "130530" : [ "08:50", "350000", "130590" ], + "130531" : [ "08:51", "350000", "130591" ], + "130532" : [ "08:52", "350000", "130592" ], + "130533" : [ "08:53", "350000", "130593" ], + "130534" : [ "08:54", "350000", "130594" ], + "130535" : [ "08:55", "350000", "130595" ], + "130536" : [ "08:56", "350000", "130596" ], + "130537" : [ "08:57", "350000", "130597" ], + "130538" : [ "08:58", "350000", "130598" ], + "130539" : [ "08:59", "350000", "130599" ], + "130540" : [ "09:00", "350000", "130600" ], + "130541" : [ "09:01", "350000", "130601" ], + "130542" : [ "09:02", "350000", "130602" ], + "130543" : [ "09:03", "350000", "130603" ], + "130544" : [ "09:04", "350000", "130604" ], + "130545" : [ "09:05", "350000", "130605" ], + "130546" : [ "09:06", "350000", "130606" ], + "130547" : [ "09:07", "350000", "130607" ], + "130548" : [ "09:08", "350000", "130608" ], + "130549" : [ "09:09", "350000", "130609" ], + "130550" : [ "09:10", "350000", "130610" ], + "130551" : [ "09:11", "350000", "130611" ], + "130552" : [ "09:12", "350000", "130612" ], + "130553" : [ "09:13", "350000", "130613" ], + "130554" : [ "09:14", "350000", "130614" ], + "130555" : [ "09:15", "350000", "130615" ], + "130556" : [ "09:16", "350000", "130616" ], + "130557" : [ "09:17", "350000", "130617" ], + "130558" : [ "09:18", "350000", "130618" ], + "130559" : [ "09:19", "350000", "130619" ], + "130560" : [ "09:20", "350000", "130620" ], + "130561" : [ "09:21", "350000", "130621" ], + "130562" : [ "09:22", "350000", "130622" ], + "130563" : [ "09:23", "350000", "130623" ], + "130564" : [ "09:24", "350000", "130624" ], + "130565" : [ "09:25", "350000", "130625" ], + "130566" : [ "09:26", "350000", "130626" ], + "130567" : [ "09:27", "350000", "130627" ], + "130568" : [ "09:28", "350000", "130628" ], + "130569" : [ "09:29", "350000", "130629" ], + "130570" : [ "09:30", "350000", "130630" ], + "130571" : [ "09:31", "350000", "130631" ], + "130572" : [ "09:32", "350000", "130632" ], + "130573" : [ "09:33", "350000", "130633" ], + "130574" : [ "09:34", "350000", "130634" ], + "130575" : [ "09:35", "350000", "130635" ], + "130576" : [ "09:36", "350000", "130636" ], + "130577" : [ "09:37", "350000", "130637" ], + "130578" : [ "09:38", "350000", "130638" ], + "130579" : [ "09:39", "350000", "130639" ], + "130580" : [ "09:40", "350000", "130640" ], + "130581" : [ "09:41", "350000", "130641" ], + "130582" : [ "09:42", "350000", "130642" ], + "130583" : [ "09:43", "350000", "130643" ], + "130584" : [ "09:44", "350000", "130644" ], + "130585" : [ "09:45", "350000", "130645" ], + "130586" : [ "09:46", "350000", "130646" ], + "130587" : [ "09:47", "350000", "130647" ], + "130588" : [ "09:48", "350000", "130648" ], + "130589" : [ "09:49", "350000", "130649" ], + "130590" : [ "09:50", "350000", "130650" ], + "130591" : [ "09:51", "350000", "130651" ], + "130592" : [ "09:52", "350000", "130652" ], + "130593" : [ "09:53", "350000", "130653" ], + "130594" : [ "09:54", "350000", "130654" ], + "130595" : [ "09:55", "350000", "130655" ], + "130596" : [ "09:56", "350000", "130656" ], + "130597" : [ "09:57", "350000", "130657" ], + "130598" : [ "09:58", "350000", "130658" ], + "130599" : [ "09:59", "350000", "130659" ], + "130600" : [ "10:00", "350000", "130660" ], + "130601" : [ "10:01", "350000", "130661" ], + "130602" : [ "10:02", "350000", "130662" ], + "130603" : [ "10:03", "350000", "130663" ], + "130604" : [ "10:04", "350000", "130664" ], + "130605" : [ "10:05", "350000", "130665" ], + "130606" : [ "10:06", "350000", "130666" ], + "130607" : [ "10:07", "350000", "130667" ], + "130608" : [ "10:08", "350000", "130668" ], + "130609" : [ "10:09", "350000", "130669" ], + "130610" : [ "10:10", "350000", "130670" ], + "130611" : [ "10:11", "350000", "130671" ], + "130612" : [ "10:12", "350000", "130672" ], + "130613" : [ "10:13", "350000", "130673" ], + "130614" : [ "10:14", "350000", "130674" ], + "130615" : [ "10:15", "350000", "130675" ], + "130616" : [ "10:16", "350000", "130676" ], + "130617" : [ "10:17", "350000", "130677" ], + "130618" : [ "10:18", "350000", "130678" ], + "130619" : [ "10:19", "350000", "130679" ], + "130620" : [ "10:20", "350000", "130680" ], + "130621" : [ "10:21", "350000", "130681" ], + "130622" : [ "10:22", "350000", "130682" ], + "130623" : [ "10:23", "350000", "130683" ], + "130624" : [ "10:24", "350000", "130684" ], + "130625" : [ "10:25", "350000", "130685" ], + "130626" : [ "10:26", "350000", "130686" ], + "130627" : [ "10:27", "350000", "130687" ], + "130628" : [ "10:28", "350000", "130688" ], + "130629" : [ "10:29", "350000", "130689" ], + "130630" : [ "10:30", "350000", "130690" ], + "130631" : [ "10:31", "350000", "130691" ], + "130632" : [ "10:32", "350000", "130692" ], + "130633" : [ "10:33", "350000", "130693" ], + "130634" : [ "10:34", "350000", "130694" ], + "130635" : [ "10:35", "350000", "130695" ], + "130636" : [ "10:36", "350000", "130696" ], + "130637" : [ "10:37", "350000", "130697" ], + "130638" : [ "10:38", "350000", "130698" ], + "130639" : [ "10:39", "350000", "130699" ], + "130640" : [ "10:40", "350000", "130700" ], + "130641" : [ "10:41", "350000", "130701" ], + "130642" : [ "10:42", "350000", "130702" ], + "130643" : [ "10:43", "350000", "130703" ], + "130644" : [ "10:44", "350000", "130704" ], + "130645" : [ "10:45", "350000", "130705" ], + "130646" : [ "10:46", "350000", "130706" ], + "130647" : [ "10:47", "350000", "130707" ], + "130648" : [ "10:48", "350000", "130708" ], + "130649" : [ "10:49", "350000", "130709" ], + "130650" : [ "10:50", "350000", "130710" ], + "130651" : [ "10:51", "350000", "130711" ], + "130652" : [ "10:52", "350000", "130712" ], + "130653" : [ "10:53", "350000", "130713" ], + "130654" : [ "10:54", "350000", "130714" ], + "130655" : [ "10:55", "350000", "130715" ], + "130656" : [ "10:56", "350000", "130716" ], + "130657" : [ "10:57", "350000", "130717" ], + "130658" : [ "10:58", "350000", "130718" ], + "130659" : [ "10:59", "350000", "130719" ], + "130660" : [ "11:00", "350000", "130720" ], + "130661" : [ "11:01", "350000", "130721" ], + "130662" : [ "11:02", "350000", "130722" ], + "130663" : [ "11:03", "350000", "130723" ], + "130664" : [ "11:04", "350000", "130724" ], + "130665" : [ "11:05", "350000", "130725" ], + "130666" : [ "11:06", "350000", "130726" ], + "130667" : [ "11:07", "350000", "130727" ], + "130668" : [ "11:08", "350000", "130728" ], + "130669" : [ "11:09", "350000", "130729" ], + "130670" : [ "11:10", "350000", "130730" ], + "130671" : [ "11:11", "350000", "130731" ], + "130672" : [ "11:12", "350000", "130732" ], + "130673" : [ "11:13", "350000", "130733" ], + "130674" : [ "11:14", "350000", "130734" ], + "130675" : [ "11:15", "350000", "130735" ], + "130676" : [ "11:16", "350000", "130736" ], + "130677" : [ "11:17", "350000", "130737" ], + "130678" : [ "11:18", "350000", "130738" ], + "130679" : [ "11:19", "350000", "130739" ], + "130680" : [ "11:20", "350000", "130740" ], + "130681" : [ "11:21", "350000", "130741" ], + "130682" : [ "11:22", "350000", "130742" ], + "130683" : [ "11:23", "350000", "130743" ], + "130684" : [ "11:24", "350000", "130744" ], + "130685" : [ "11:25", "350000", "130745" ], + "130686" : [ "11:26", "350000", "130746" ], + "130687" : [ "11:27", "350000", "130747" ], + "130688" : [ "11:28", "350000", "130748" ], + "130689" : [ "11:29", "350000", "130749" ], + "130690" : [ "11:30", "350000", "130750" ], + "130691" : [ "11:31", "350000", "130751" ], + "130692" : [ "11:32", "350000", "130752" ], + "130693" : [ "11:33", "350000", "130753" ], + "130694" : [ "11:34", "350000", "130754" ], + "130695" : [ "11:35", "350000", "130755" ], + "130696" : [ "11:36", "350000", "130756" ], + "130697" : [ "11:37", "350000", "130757" ], + "130698" : [ "11:38", "350000", "130758" ], + "130699" : [ "11:39", "350000", "130759" ], + "130700" : [ "11:40", "350000", "130760" ], + "130701" : [ "11:41", "350000", "130761" ], + "130702" : [ "11:42", "350000", "130762" ], + "130703" : [ "11:43", "350000", "130763" ], + "130704" : [ "11:44", "350000", "130764" ], + "130705" : [ "11:45", "350000", "130765" ], + "130706" : [ "11:46", "350000", "130766" ], + "130707" : [ "11:47", "350000", "130767" ], + "130708" : [ "11:48", "350000", "130768" ], + "130709" : [ "11:49", "350000", "130769" ], + "130710" : [ "11:50", "350000", "130770" ], + "130711" : [ "11:51", "350000", "130771" ], + "130712" : [ "11:52", "350000", "130772" ], + "130713" : [ "11:53", "350000", "130773" ], + "130714" : [ "11:54", "350000", "130774" ], + "130715" : [ "11:55", "350000", "130775" ], + "130716" : [ "11:56", "350000", "130776" ], + "130717" : [ "11:57", "350000", "130777" ], + "130718" : [ "11:58", "350000", "130778" ], + "130719" : [ "11:59", "350000", "130779" ], + "130720" : [ "12:00", "350000", "130780" ], + "130721" : [ "12:01", "350000", "130781" ], + "130722" : [ "12:02", "350000", "130782" ], + "130723" : [ "12:03", "350000", "130783" ], + "130724" : [ "12:04", "350000", "130784" ], + "130725" : [ "12:05", "350000", "130785" ], + "130726" : [ "12:06", "350000", "130786" ], + "130727" : [ "12:07", "350000", "130787" ], + "130728" : [ "12:08", "350000", "130788" ], + "130729" : [ "12:09", "350000", "130789" ], + "130730" : [ "12:10", "350000", "130790" ], + "130731" : [ "12:11", "350000", "130791" ], + "130732" : [ "12:12", "350000", "130792" ], + "130733" : [ "12:13", "350000", "130793" ], + "130734" : [ "12:14", "350000", "130794" ], + "130735" : [ "12:15", "350000", "130795" ], + "130736" : [ "12:16", "350000", "130796" ], + "130737" : [ "12:17", "350000", "130797" ], + "130738" : [ "12:18", "350000", "130798" ], + "130739" : [ "12:19", "350000", "130799" ], + "130740" : [ "12:20", "350000", "130800" ], + "130741" : [ "12:21", "350000", "130801" ], + "130742" : [ "12:22", "350000", "130802" ], + "130743" : [ "12:23", "350000", "130803" ], + "130744" : [ "12:24", "350000", "130804" ], + "130745" : [ "12:25", "350000", "130805" ], + "130746" : [ "12:26", "350000", "130806" ], + "130747" : [ "12:27", "350000", "130807" ], + "130748" : [ "12:28", "350000", "130808" ], + "130749" : [ "12:29", "350000", "130809" ], + "130750" : [ "12:30", "350000", "130810" ], + "130751" : [ "12:31", "350000", "130811" ], + "130752" : [ "12:32", "350000", "130812" ], + "130753" : [ "12:33", "350000", "130813" ], + "130754" : [ "12:34", "350000", "130814" ], + "130755" : [ "12:35", "350000", "130815" ], + "130756" : [ "12:36", "350000", "130816" ], + "130757" : [ "12:37", "350000", "130817" ], + "130758" : [ "12:38", "350000", "130818" ], + "130759" : [ "12:39", "350000", "130819" ], + "130760" : [ "12:40", "350000", "130820" ], + "130761" : [ "12:41", "350000", "130821" ], + "130762" : [ "12:42", "350000", "130822" ], + "130763" : [ "12:43", "350000", "130823" ], + "130764" : [ "12:44", "350000", "130824" ], + "130765" : [ "12:45", "350000", "130825" ], + "130766" : [ "12:46", "350000", "130826" ], + "130767" : [ "12:47", "350000", "130827" ], + "130768" : [ "12:48", "350000", "130828" ], + "130769" : [ "12:49", "350000", "130829" ], + "130770" : [ "12:50", "350000", "130830" ], + "130771" : [ "12:51", "350000", "130831" ], + "130772" : [ "12:52", "350000", "130832" ], + "130773" : [ "12:53", "350000", "130833" ], + "130774" : [ "12:54", "350000", "130834" ], + "130775" : [ "12:55", "350000", "130835" ], + "130776" : [ "12:56", "350000", "130836" ], + "130777" : [ "12:57", "350000", "130837" ], + "130778" : [ "12:58", "350000", "130838" ], + "130779" : [ "12:59", "350000", "130839" ], + "130780" : [ "13:00", "350000", "130840" ], + "130781" : [ "13:01", "350000", "130841" ], + "130782" : [ "13:02", "350000", "130842" ], + "130783" : [ "13:03", "350000", "130843" ], + "130784" : [ "13:04", "350000", "130844" ], + "130785" : [ "13:05", "350000", "130845" ], + "130786" : [ "13:06", "350000", "130846" ], + "130787" : [ "13:07", "350000", "130847" ], + "130788" : [ "13:08", "350000", "130848" ], + "130789" : [ "13:09", "350000", "130849" ], + "130790" : [ "13:10", "350000", "130850" ], + "130791" : [ "13:11", "350000", "130851" ], + "130792" : [ "13:12", "350000", "130852" ], + "130793" : [ "13:13", "350000", "130853" ], + "130794" : [ "13:14", "350000", "130854" ], + "130795" : [ "13:15", "350000", "130855" ], + "130796" : [ "13:16", "350000", "130856" ], + "130797" : [ "13:17", "350000", "130857" ], + "130798" : [ "13:18", "350000", "130858" ], + "130799" : [ "13:19", "350000", "130859" ], + "130800" : [ "13:20", "350000", "130860" ], + "130801" : [ "13:21", "350000", "130861" ], + "130802" : [ "13:22", "350000", "130862" ], + "130803" : [ "13:23", "350000", "130863" ], + "130804" : [ "13:24", "350000", "130864" ], + "130805" : [ "13:25", "350000", "130865" ], + "130806" : [ "13:26", "350000", "130866" ], + "130807" : [ "13:27", "350000", "130867" ], + "130808" : [ "13:28", "350000", "130868" ], + "130809" : [ "13:29", "350000", "130869" ], + "130810" : [ "13:30", "350000", "130870" ], + "130811" : [ "13:31", "350000", "130871" ], + "130812" : [ "13:32", "350000", "130872" ], + "130813" : [ "13:33", "350000", "130873" ], + "130814" : [ "13:34", "350000", "130874" ], + "130815" : [ "13:35", "350000", "130875" ], + "130816" : [ "13:36", "350000", "130876" ], + "130817" : [ "13:37", "350000", "130877" ], + "130818" : [ "13:38", "350000", "130878" ], + "130819" : [ "13:39", "350000", "130879" ], + "130820" : [ "13:40", "350000", "130880" ], + "130821" : [ "13:41", "350000", "130881" ], + "130822" : [ "13:42", "350000", "130882" ], + "130823" : [ "13:43", "350000", "130883" ], + "130824" : [ "13:44", "350000", "130884" ], + "130825" : [ "13:45", "350000", "130885" ], + "130826" : [ "13:46", "350000", "130886" ], + "130827" : [ "13:47", "350000", "130887" ], + "130828" : [ "13:48", "350000", "130888" ], + "130829" : [ "13:49", "350000", "130889" ], + "130830" : [ "13:50", "350000", "130890" ], + "130831" : [ "13:51", "350000", "130891" ], + "130832" : [ "13:52", "350000", "130892" ], + "130833" : [ "13:53", "350000", "130893" ], + "130834" : [ "13:54", "350000", "130894" ], + "130835" : [ "13:55", "350000", "130895" ], + "130836" : [ "13:56", "350000", "130896" ], + "130837" : [ "13:57", "350000", "130897" ], + "130838" : [ "13:58", "350000", "130898" ], + "130839" : [ "13:59", "350000", "130899" ], + "130840" : [ "14:00", "350000", "130900" ], + "130841" : [ "14:01", "350000", "130901" ], + "130842" : [ "14:02", "350000", "130902" ], + "130843" : [ "14:03", "350000", "130903" ], + "130844" : [ "14:04", "350000", "130904" ], + "130845" : [ "14:05", "350000", "130905" ], + "130846" : [ "14:06", "350000", "130906" ], + "130847" : [ "14:07", "350000", "130907" ], + "130848" : [ "14:08", "350000", "130908" ], + "130849" : [ "14:09", "350000", "130909" ], + "130850" : [ "14:10", "350000", "130910" ], + "130851" : [ "14:11", "350000", "130911" ], + "130852" : [ "14:12", "350000", "130912" ], + "130853" : [ "14:13", "350000", "130913" ], + "130854" : [ "14:14", "350000", "130914" ], + "130855" : [ "14:15", "350000", "130915" ], + "130856" : [ "14:16", "350000", "130916" ], + "130857" : [ "14:17", "350000", "130917" ], + "130858" : [ "14:18", "350000", "130918" ], + "130859" : [ "14:19", "350000", "130919" ], + "130860" : [ "14:20", "350000", "130920" ], + "130861" : [ "14:21", "350000", "130921" ], + "130862" : [ "14:22", "350000", "130922" ], + "130863" : [ "14:23", "350000", "130923" ], + "130864" : [ "14:24", "350000", "130924" ], + "130865" : [ "14:25", "350000", "130925" ], + "130866" : [ "14:26", "350000", "130926" ], + "130867" : [ "14:27", "350000", "130927" ], + "130868" : [ "14:28", "350000", "130928" ], + "130869" : [ "14:29", "350000", "130929" ], + "130870" : [ "14:30", "350000", "130930" ], + "130871" : [ "14:31", "350000", "130931" ], + "130872" : [ "14:32", "350000", "130932" ], + "130873" : [ "14:33", "350000", "130933" ], + "130874" : [ "14:34", "350000", "130934" ], + "130875" : [ "14:35", "350000", "130935" ], + "130876" : [ "14:36", "350000", "130936" ], + "130877" : [ "14:37", "350000", "130937" ], + "130878" : [ "14:38", "350000", "130938" ], + "130879" : [ "14:39", "350000", "130939" ], + "130880" : [ "14:40", "350000", "130940" ], + "130881" : [ "14:41", "350000", "130941" ], + "130882" : [ "14:42", "350000", "130942" ], + "130883" : [ "14:43", "350000", "130943" ], + "130884" : [ "14:44", "350000", "130944" ], + "130885" : [ "14:45", "350000", "130945" ], + "130886" : [ "14:46", "350000", "130946" ], + "130887" : [ "14:47", "350000", "130947" ], + "130888" : [ "14:48", "350000", "130948" ], + "130889" : [ "14:49", "350000", "130949" ], + "130890" : [ "14:50", "350000", "130950" ], + "130891" : [ "14:51", "350000", "130951" ], + "130892" : [ "14:52", "350000", "130952" ], + "130893" : [ "14:53", "350000", "130953" ], + "130894" : [ "14:54", "350000", "130954" ], + "130895" : [ "14:55", "350000", "130955" ], + "130896" : [ "14:56", "350000", "130956" ], + "130897" : [ "14:57", "350000", "130957" ], + "130898" : [ "14:58", "350000", "130958" ], + "130899" : [ "14:59", "350000", "130959" ], + "130900" : [ "15:00", "350000", "130960" ], + "130901" : [ "15:01", "350000", "130961" ], + "130902" : [ "15:02", "350000", "130962" ], + "130903" : [ "15:03", "350000", "130963" ], + "130904" : [ "15:04", "350000", "130964" ], + "130905" : [ "15:05", "350000", "130965" ], + "130906" : [ "15:06", "350000", "130966" ], + "130907" : [ "15:07", "350000", "130967" ], + "130908" : [ "15:08", "350000", "130968" ], + "130909" : [ "15:09", "350000", "130969" ], + "130910" : [ "15:10", "350000", "130970" ], + "130911" : [ "15:11", "350000", "130971" ], + "130912" : [ "15:12", "350000", "130972" ], + "130913" : [ "15:13", "350000", "130973" ], + "130914" : [ "15:14", "350000", "130974" ], + "130915" : [ "15:15", "350000", "130975" ], + "130916" : [ "15:16", "350000", "130976" ], + "130917" : [ "15:17", "350000", "130977" ], + "130918" : [ "15:18", "350000", "130978" ], + "130919" : [ "15:19", "350000", "130979" ], + "130920" : [ "15:20", "350000", "130980" ], + "130921" : [ "15:21", "350000", "130981" ], + "130922" : [ "15:22", "350000", "130982" ], + "130923" : [ "15:23", "350000", "130983" ], + "130924" : [ "15:24", "350000", "130984" ], + "130925" : [ "15:25", "350000", "130985" ], + "130926" : [ "15:26", "350000", "130986" ], + "130927" : [ "15:27", "350000", "130987" ], + "130928" : [ "15:28", "350000", "130988" ], + "130929" : [ "15:29", "350000", "130989" ], + "130930" : [ "15:30", "350000", "130990" ], + "130931" : [ "15:31", "350000", "130991" ], + "130932" : [ "15:32", "350000", "130992" ], + "130933" : [ "15:33", "350000", "130993" ], + "130934" : [ "15:34", "350000", "130994" ], + "130935" : [ "15:35", "350000", "130995" ], + "130936" : [ "15:36", "350000", "130996" ], + "130937" : [ "15:37", "350000", "130997" ], + "130938" : [ "15:38", "350000", "130998" ], + "130939" : [ "15:39", "350000", "130999" ], + "130940" : [ "15:40", "350000", "131000" ], + "130941" : [ "15:41", "350000", "131001" ], + "130942" : [ "15:42", "350000", "131002" ], + "130943" : [ "15:43", "350000", "131003" ], + "130944" : [ "15:44", "350000", "131004" ], + "130945" : [ "15:45", "350000", "131005" ], + "130946" : [ "15:46", "350000", "131006" ], + "130947" : [ "15:47", "350000", "131007" ], + "130948" : [ "15:48", "350000", "131008" ], + "130949" : [ "15:49", "350000", "131009" ], + "130950" : [ "15:50", "350000", "131010" ], + "130951" : [ "15:51", "350000", "131011" ], + "130952" : [ "15:52", "350000", "131012" ], + "130953" : [ "15:53", "350000", "131013" ], + "130954" : [ "15:54", "350000", "131014" ], + "130955" : [ "15:55", "350000", "131015" ], + "130956" : [ "15:56", "350000", "131016" ], + "130957" : [ "15:57", "350000", "131017" ], + "130958" : [ "15:58", "350000", "131018" ], + "130959" : [ "15:59", "350000", "131019" ], + "130960" : [ "16:00", "350000", "131020" ], + "130961" : [ "16:01", "350000", "131021" ], + "130962" : [ "16:02", "350000", "131022" ], + "130963" : [ "16:03", "350000", "131023" ], + "130964" : [ "16:04", "350000", "131024" ], + "130965" : [ "16:05", "350000", "131025" ], + "130966" : [ "16:06", "350000", "131026" ], + "130967" : [ "16:07", "350000", "131027" ], + "130968" : [ "16:08", "350000", "131028" ], + "130969" : [ "16:09", "350000", "131029" ], + "130970" : [ "16:10", "350000", "131030" ], + "130971" : [ "16:11", "350000", "131031" ], + "130972" : [ "16:12", "350000", "131032" ], + "130973" : [ "16:13", "350000", "131033" ], + "130974" : [ "16:14", "350000", "131034" ], + "130975" : [ "16:15", "350000", "131035" ], + "130976" : [ "16:16", "350000", "131036" ], + "130977" : [ "16:17", "350000", "131037" ], + "130978" : [ "16:18", "350000", "131038" ], + "130979" : [ "16:19", "350000", "131039" ], + "130980" : [ "16:20", "350000", "131040" ], + "130981" : [ "16:21", "350000", "131041" ], + "130982" : [ "16:22", "350000", "131042" ], + "130983" : [ "16:23", "350000", "131043" ], + "130984" : [ "16:24", "350000", "131044" ], + "130985" : [ "16:25", "350000", "131045" ], + "130986" : [ "16:26", "350000", "131046" ], + "130987" : [ "16:27", "350000", "131047" ], + "130988" : [ "16:28", "350000", "131048" ], + "130989" : [ "16:29", "350000", "131049" ], + "130990" : [ "16:30", "350000", "131050" ], + "130991" : [ "16:31", "350000", "131051" ], + "130992" : [ "16:32", "350000", "131052" ], + "130993" : [ "16:33", "350000", "131053" ], + "130994" : [ "16:34", "350000", "131054" ], + "130995" : [ "16:35", "350000", "131055" ], + "130996" : [ "16:36", "350000", "131056" ], + "130997" : [ "16:37", "350000", "131057" ], + "130998" : [ "16:38", "350000", "131058" ], + "130999" : [ "16:39", "350000", "131059" ], + "131000" : [ "16:40", "350000", "131060" ], + "131001" : [ "16:41", "350000", "131061" ], + "131002" : [ "16:42", "350000", "131062" ], + "131003" : [ "16:43", "350000", "131063" ], + "131004" : [ "16:44", "350000", "131064" ], + "131005" : [ "16:45", "350000", "131065" ], + "131006" : [ "16:46", "350000", "131066" ], + "131007" : [ "16:47", "350000", "131067" ], + "131008" : [ "16:48", "350000", "131068" ], + "131009" : [ "16:49", "350000", "131069" ], + "131010" : [ "16:50", "350000", "131070" ], + "131011" : [ "16:51", "350000", "131071" ], + "131012" : [ "16:52", "350000", "131072" ], + "131013" : [ "16:53", "350000", "131073" ], + "131014" : [ "16:54", "350000", "131074" ], + "131015" : [ "16:55", "350000", "131075" ], + "131016" : [ "16:56", "350000", "131076" ], + "131017" : [ "16:57", "350000", "131077" ], + "131018" : [ "16:58", "350000", "131078" ], + "131019" : [ "16:59", "350000", "131079" ], + "131020" : [ "17:00", "350000", "131080" ], + "131021" : [ "17:01", "350000", "131081" ], + "131022" : [ "17:02", "350000", "131082" ], + "131023" : [ "17:03", "350000", "131083" ], + "131024" : [ "17:04", "350000", "131084" ], + "131025" : [ "17:05", "350000", "131085" ], + "131026" : [ "17:06", "350000", "131086" ], + "131027" : [ "17:07", "350000", "131087" ], + "131028" : [ "17:08", "350000", "131088" ], + "131029" : [ "17:09", "350000", "131089" ], + "131030" : [ "17:10", "350000", "131090" ], + "131031" : [ "17:11", "350000", "131091" ], + "131032" : [ "17:12", "350000", "131092" ], + "131033" : [ "17:13", "350000", "131093" ], + "131034" : [ "17:14", "350000", "131094" ], + "131035" : [ "17:15", "350000", "131095" ], + "131036" : [ "17:16", "350000", "131096" ], + "131037" : [ "17:17", "350000", "131097" ], + "131038" : [ "17:18", "350000", "131098" ], + "131039" : [ "17:19", "350000", "131099" ], + "131040" : [ "17:20", "350000", "131100" ], + "131041" : [ "17:21", "350000", "131101" ], + "131042" : [ "17:22", "350000", "131102" ], + "131043" : [ "17:23", "350000", "131103" ], + "131044" : [ "17:24", "350000", "131104" ], + "131045" : [ "17:25", "350000", "131105" ], + "131046" : [ "17:26", "350000", "131106" ], + "131047" : [ "17:27", "350000", "131107" ], + "131048" : [ "17:28", "350000", "131108" ], + "131049" : [ "17:29", "350000", "131109" ], + "131050" : [ "17:30", "350000", "131110" ], + "131051" : [ "17:31", "350000", "131111" ], + "131052" : [ "17:32", "350000", "131112" ], + "131053" : [ "17:33", "350000", "131113" ], + "131054" : [ "17:34", "350000", "131114" ], + "131055" : [ "17:35", "350000", "131115" ], + "131056" : [ "17:36", "350000", "131116" ], + "131057" : [ "17:37", "350000", "131117" ], + "131058" : [ "17:38", "350000", "131118" ], + "131059" : [ "17:39", "350000", "131119" ], + "131060" : [ "17:40", "350000", "131120" ], + "131061" : [ "17:41", "350000", "131121" ], + "131062" : [ "17:42", "350000", "131122" ], + "131063" : [ "17:43", "350000", "131123" ], + "131064" : [ "17:44", "350000", "131124" ], + "131065" : [ "17:45", "350000", "131125" ], + "131066" : [ "17:46", "350000", "131126" ], + "131067" : [ "17:47", "350000", "131127" ], + "131068" : [ "17:48", "350000", "131128" ], + "131069" : [ "17:49", "350000", "131129" ], + "131070" : [ "17:50", "350000", "131130" ], + "131071" : [ "17:51", "350000", "131131" ], + "131072" : [ "17:52", "350000", "131132" ], + "131073" : [ "17:53", "350000", "131133" ], + "131074" : [ "17:54", "350000", "131134" ], + "131075" : [ "17:55", "350000", "131135" ], + "131076" : [ "17:56", "350000", "131136" ], + "131077" : [ "17:57", "350000", "131137" ], + "131078" : [ "17:58", "350000", "131138" ], + "131079" : [ "17:59", "350000", "131139" ], + "131080" : [ "18:00", "350000", "131140" ], + "131081" : [ "18:01", "350000", "131141" ], + "131082" : [ "18:02", "350000", "131142" ], + "131083" : [ "18:03", "350000", "131143" ], + "131084" : [ "18:04", "350000", "131144" ], + "131085" : [ "18:05", "350000", "131145" ], + "131086" : [ "18:06", "350000", "131146" ], + "131087" : [ "18:07", "350000", "131147" ], + "131088" : [ "18:08", "350000", "131148" ], + "131089" : [ "18:09", "350000", "131149" ], + "131090" : [ "18:10", "350000", "131150" ], + "131091" : [ "18:11", "350000", "131151" ], + "131092" : [ "18:12", "350000", "131152" ], + "131093" : [ "18:13", "350000", "131153" ], + "131094" : [ "18:14", "350000", "131154" ], + "131095" : [ "18:15", "350000", "131155" ], + "131096" : [ "18:16", "350000", "131156" ], + "131097" : [ "18:17", "350000", "131157" ], + "131098" : [ "18:18", "350000", "131158" ], + "131099" : [ "18:19", "350000", "131159" ], + "131100" : [ "18:20", "350000", "131160" ], + "131101" : [ "18:21", "350000", "131161" ], + "131102" : [ "18:22", "350000", "131162" ], + "131103" : [ "18:23", "350000", "131163" ], + "131104" : [ "18:24", "350000", "131164" ], + "131105" : [ "18:25", "350000", "131165" ], + "131106" : [ "18:26", "350000", "131166" ], + "131107" : [ "18:27", "350000", "131167" ], + "131108" : [ "18:28", "350000", "131168" ], + "131109" : [ "18:29", "350000", "131169" ], + "131110" : [ "18:30", "350000", "131170" ], + "131111" : [ "18:31", "350000", "131171" ], + "131112" : [ "18:32", "350000", "131172" ], + "131113" : [ "18:33", "350000", "131173" ], + "131114" : [ "18:34", "350000", "131174" ], + "131115" : [ "18:35", "350000", "131175" ], + "131116" : [ "18:36", "350000", "131176" ], + "131117" : [ "18:37", "350000", "131177" ], + "131118" : [ "18:38", "350000", "131178" ], + "131119" : [ "18:39", "350000", "131179" ], + "131120" : [ "18:40", "350000", "131180" ], + "131121" : [ "18:41", "350000", "131181" ], + "131122" : [ "18:42", "350000", "131182" ], + "131123" : [ "18:43", "350000", "131183" ], + "131124" : [ "18:44", "350000", "131184" ], + "131125" : [ "18:45", "350000", "131185" ], + "131126" : [ "18:46", "350000", "131186" ], + "131127" : [ "18:47", "350000", "131187" ], + "131128" : [ "18:48", "350000", "131188" ], + "131129" : [ "18:49", "350000", "131189" ], + "131130" : [ "18:50", "350000", "131190" ], + "131131" : [ "18:51", "350000", "131191" ], + "131132" : [ "18:52", "350000", "131192" ], + "131133" : [ "18:53", "350000", "131193" ], + "131134" : [ "18:54", "350000", "131194" ], + "131135" : [ "18:55", "350000", "131195" ], + "131136" : [ "18:56", "350000", "131196" ], + "131137" : [ "18:57", "350000", "131197" ], + "131138" : [ "18:58", "350000", "131198" ], + "131139" : [ "18:59", "350000", "131199" ], + "131140" : [ "19:00", "350000", "131200" ], + "131141" : [ "19:01", "350000", "131200" ], + "131142" : [ "19:02", "350000", "131200" ], + "131143" : [ "19:03", "350000", "131200" ], + "131144" : [ "19:04", "350000", "131200" ], + "131145" : [ "19:05", "350000", "131200" ], + "131146" : [ "19:06", "350000", "131200" ], + "131147" : [ "19:07", "350000", "131200" ], + "131148" : [ "19:08", "350000", "131200" ], + "131149" : [ "19:09", "350000", "131200" ], + "131150" : [ "19:10", "350000", "131200" ], + "131151" : [ "19:11", "350000", "131200" ], + "131152" : [ "19:12", "350000", "131200" ], + "131153" : [ "19:13", "350000", "131200" ], + "131154" : [ "19:14", "350000", "131200" ], + "131155" : [ "19:15", "350000", "131200" ], + "131156" : [ "19:16", "350000", "131200" ], + "131157" : [ "19:17", "350000", "131200" ], + "131158" : [ "19:18", "350000", "131200" ], + "131159" : [ "19:19", "350000", "131200" ], + "131160" : [ "19:20", "350000", "131200" ], + "131161" : [ "19:21", "350000", "131200" ], + "131162" : [ "19:22", "350000", "131200" ], + "131163" : [ "19:23", "350000", "131200" ], + "131164" : [ "19:24", "350000", "131200" ], + "131165" : [ "19:25", "350000", "131200" ], + "131166" : [ "19:26", "350000", "131200" ], + "131167" : [ "19:27", "350000", "131200" ], + "131168" : [ "19:28", "350000", "131200" ], + "131169" : [ "19:29", "350000", "131200" ], + "131170" : [ "19:30", "350000", "131200" ], + "131171" : [ "19:31", "350000", "131200" ], + "131172" : [ "19:32", "350000", "131200" ], + "131173" : [ "19:33", "350000", "131200" ], + "131174" : [ "19:34", "350000", "131200" ], + "131175" : [ "19:35", "350000", "131200" ], + "131176" : [ "19:36", "350000", "131200" ], + "131177" : [ "19:37", "350000", "131200" ], + "131178" : [ "19:38", "350000", "131200" ], + "131179" : [ "19:39", "350000", "131200" ], + "131180" : [ "19:40", "350000", "131200" ], + "131181" : [ "19:41", "350000", "131200" ], + "131182" : [ "19:42", "350000", "131200" ], + "131183" : [ "19:43", "350000", "131200" ], + "131184" : [ "19:44", "350000", "131200" ], + "131185" : [ "19:45", "350000", "131200" ], + "131186" : [ "19:46", "350000", "131200" ], + "131187" : [ "19:47", "350000", "131200" ], + "131188" : [ "19:48", "350000", "131200" ], + "131189" : [ "19:49", "350000", "131200" ], + "131190" : [ "19:50", "350000", "131200" ], + "131191" : [ "19:51", "350000", "131200" ], + "131192" : [ "19:52", "350000", "131200" ], + "131193" : [ "19:53", "350000", "131200" ], + "131194" : [ "19:54", "350000", "131200" ], + "131195" : [ "19:55", "350000", "131200" ], + "131196" : [ "19:56", "350000", "131200" ], + "131197" : [ "19:57", "350000", "131200" ], + "131198" : [ "19:58", "350000", "131200" ], + "131199" : [ "19:59", "350000", "131200" ], + "131200" : [ "20:00", "800000", "140420" ], + "131201" : [ "20:01", "800000", "140420" ], + "131202" : [ "20:02", "800000", "140420" ], + "131203" : [ "20:03", "800000", "140420" ], + "131204" : [ "20:04", "800000", "140420" ], + "131205" : [ "20:05", "800000", "140420" ], + "131206" : [ "20:06", "800000", "140420" ], + "131207" : [ "20:07", "800000", "140420" ], + "131208" : [ "20:08", "800000", "140420" ], + "131209" : [ "20:09", "800000", "140420" ], + "131210" : [ "20:10", "800000", "140420" ], + "131211" : [ "20:11", "800000", "140420" ], + "131212" : [ "20:12", "800000", "140420" ], + "131213" : [ "20:13", "800000", "140420" ], + "131214" : [ "20:14", "800000", "140420" ], + "131215" : [ "20:15", "800000", "140420" ], + "131216" : [ "20:16", "800000", "140420" ], + "131217" : [ "20:17", "800000", "140420" ], + "131218" : [ "20:18", "800000", "140420" ], + "131219" : [ "20:19", "800000", "140420" ], + "131220" : [ "20:20", "800000", "140420" ], + "131221" : [ "20:21", "800000", "140420" ], + "131222" : [ "20:22", "800000", "140420" ], + "131223" : [ "20:23", "800000", "140420" ], + "131224" : [ "20:24", "800000", "140420" ], + "131225" : [ "20:25", "800000", "140420" ], + "131226" : [ "20:26", "800000", "140420" ], + "131227" : [ "20:27", "800000", "140420" ], + "131228" : [ "20:28", "800000", "140420" ], + "131229" : [ "20:29", "800000", "140420" ], + "131230" : [ "20:30", "800000", "140420" ], + "131231" : [ "20:31", "800000", "140420" ], + "131232" : [ "20:32", "800000", "140420" ], + "131233" : [ "20:33", "800000", "140420" ], + "131234" : [ "20:34", "800000", "140420" ], + "131235" : [ "20:35", "800000", "140420" ], + "131236" : [ "20:36", "800000", "140420" ], + "131237" : [ "20:37", "800000", "140420" ], + "131238" : [ "20:38", "800000", "140420" ], + "131239" : [ "20:39", "800000", "140420" ], + "131240" : [ "20:40", "800000", "140420" ], + "131241" : [ "20:41", "800000", "140420" ], + "131242" : [ "20:42", "800000", "140420" ], + "131243" : [ "20:43", "800000", "140420" ], + "131244" : [ "20:44", "800000", "140420" ], + "131245" : [ "20:45", "800000", "140420" ], + "131246" : [ "20:46", "800000", "140420" ], + "131247" : [ "20:47", "800000", "140420" ], + "131248" : [ "20:48", "800000", "140420" ], + "131249" : [ "20:49", "800000", "140420" ], + "131250" : [ "20:50", "800000", "140420" ], + "131251" : [ "20:51", "800000", "140420" ], + "131252" : [ "20:52", "800000", "140420" ], + "131253" : [ "20:53", "800000", "140420" ], + "131254" : [ "20:54", "800000", "140420" ], + "131255" : [ "20:55", "800000", "140420" ], + "131256" : [ "20:56", "800000", "140420" ], + "131257" : [ "20:57", "800000", "140420" ], + "131258" : [ "20:58", "800000", "140420" ], + "131259" : [ "20:59", "800000", "140420" ], + "131260" : [ "21:00", "800000", "140420" ], + "131261" : [ "21:01", "800000", "140420" ], + "131262" : [ "21:02", "800000", "140420" ], + "131263" : [ "21:03", "800000", "140420" ], + "131264" : [ "21:04", "800000", "140420" ], + "131265" : [ "21:05", "800000", "140420" ], + "131266" : [ "21:06", "800000", "140420" ], + "131267" : [ "21:07", "800000", "140420" ], + "131268" : [ "21:08", "800000", "140420" ], + "131269" : [ "21:09", "800000", "140420" ], + "131270" : [ "21:10", "800000", "140420" ], + "131271" : [ "21:11", "800000", "140420" ], + "131272" : [ "21:12", "800000", "140420" ], + "131273" : [ "21:13", "800000", "140420" ], + "131274" : [ "21:14", "800000", "140420" ], + "131275" : [ "21:15", "800000", "140420" ], + "131276" : [ "21:16", "800000", "140420" ], + "131277" : [ "21:17", "800000", "140420" ], + "131278" : [ "21:18", "800000", "140420" ], + "131279" : [ "21:19", "800000", "140420" ], + "131280" : [ "21:20", "800000", "140420" ], + "131281" : [ "21:21", "800000", "140420" ], + "131282" : [ "21:22", "800000", "140420" ], + "131283" : [ "21:23", "800000", "140420" ], + "131284" : [ "21:24", "800000", "140420" ], + "131285" : [ "21:25", "800000", "140420" ], + "131286" : [ "21:26", "800000", "140420" ], + "131287" : [ "21:27", "800000", "140420" ], + "131288" : [ "21:28", "800000", "140420" ], + "131289" : [ "21:29", "800000", "140420" ], + "131290" : [ "21:30", "800000", "140420" ], + "131291" : [ "21:31", "800000", "140420" ], + "131292" : [ "21:32", "800000", "140420" ], + "131293" : [ "21:33", "800000", "140420" ], + "131294" : [ "21:34", "800000", "140420" ], + "131295" : [ "21:35", "800000", "140420" ], + "131296" : [ "21:36", "800000", "140420" ], + "131297" : [ "21:37", "800000", "140420" ], + "131298" : [ "21:38", "800000", "140420" ], + "131299" : [ "21:39", "800000", "140420" ], + "131300" : [ "21:40", "800000", "140420" ], + "131301" : [ "21:41", "800000", "140420" ], + "131302" : [ "21:42", "800000", "140420" ], + "131303" : [ "21:43", "800000", "140420" ], + "131304" : [ "21:44", "800000", "140420" ], + "131305" : [ "21:45", "800000", "140420" ], + "131306" : [ "21:46", "800000", "140420" ], + "131307" : [ "21:47", "800000", "140420" ], + "131308" : [ "21:48", "800000", "140420" ], + "131309" : [ "21:49", "800000", "140420" ], + "131310" : [ "21:50", "800000", "140420" ], + "131311" : [ "21:51", "800000", "140420" ], + "131312" : [ "21:52", "800000", "140420" ], + "131313" : [ "21:53", "800000", "140420" ], + "131314" : [ "21:54", "800000", "140420" ], + "131315" : [ "21:55", "800000", "140420" ], + "131316" : [ "21:56", "800000", "140420" ], + "131317" : [ "21:57", "800000", "140420" ], + "131318" : [ "21:58", "800000", "140420" ], + "131319" : [ "21:59", "800000", "140420" ], + "131320" : [ "22:00", "800000", "140420" ], + "131321" : [ "22:01", "800000", "140420" ], + "131322" : [ "22:02", "800000", "140420" ], + "131323" : [ "22:03", "800000", "140420" ], + "131324" : [ "22:04", "800000", "140420" ], + "131325" : [ "22:05", "800000", "140420" ], + "131326" : [ "22:06", "800000", "140420" ], + "131327" : [ "22:07", "800000", "140420" ], + "131328" : [ "22:08", "800000", "140420" ], + "131329" : [ "22:09", "800000", "140420" ], + "131330" : [ "22:10", "800000", "140420" ], + "131331" : [ "22:11", "800000", "140420" ], + "131332" : [ "22:12", "800000", "140420" ], + "131333" : [ "22:13", "800000", "140420" ], + "131334" : [ "22:14", "800000", "140420" ], + "131335" : [ "22:15", "800000", "140420" ], + "131336" : [ "22:16", "800000", "140420" ], + "131337" : [ "22:17", "800000", "140420" ], + "131338" : [ "22:18", "800000", "140420" ], + "131339" : [ "22:19", "800000", "140420" ], + "131340" : [ "22:20", "800000", "140420" ], + "131341" : [ "22:21", "800000", "140420" ], + "131342" : [ "22:22", "800000", "140420" ], + "131343" : [ "22:23", "800000", "140420" ], + "131344" : [ "22:24", "800000", "140420" ], + "131345" : [ "22:25", "800000", "140420" ], + "131346" : [ "22:26", "800000", "140420" ], + "131347" : [ "22:27", "800000", "140420" ], + "131348" : [ "22:28", "800000", "140420" ], + "131349" : [ "22:29", "800000", "140420" ], + "131350" : [ "22:30", "800000", "140420" ], + "131351" : [ "22:31", "800000", "140420" ], + "131352" : [ "22:32", "800000", "140420" ], + "131353" : [ "22:33", "800000", "140420" ], + "131354" : [ "22:34", "800000", "140420" ], + "131355" : [ "22:35", "800000", "140420" ], + "131356" : [ "22:36", "800000", "140420" ], + "131357" : [ "22:37", "800000", "140420" ], + "131358" : [ "22:38", "800000", "140420" ], + "131359" : [ "22:39", "800000", "140420" ], + "131360" : [ "22:40", "800000", "140420" ], + "131361" : [ "22:41", "800000", "140420" ], + "131362" : [ "22:42", "800000", "140420" ], + "131363" : [ "22:43", "800000", "140420" ], + "131364" : [ "22:44", "800000", "140420" ], + "131365" : [ "22:45", "800000", "140420" ], + "131366" : [ "22:46", "800000", "140420" ], + "131367" : [ "22:47", "800000", "140420" ], + "131368" : [ "22:48", "800000", "140420" ], + "131369" : [ "22:49", "800000", "140420" ], + "131370" : [ "22:50", "800000", "140420" ], + "131371" : [ "22:51", "800000", "140420" ], + "131372" : [ "22:52", "800000", "140420" ], + "131373" : [ "22:53", "800000", "140420" ], + "131374" : [ "22:54", "800000", "140420" ], + "131375" : [ "22:55", "800000", "140420" ], + "131376" : [ "22:56", "800000", "140420" ], + "131377" : [ "22:57", "800000", "140420" ], + "131378" : [ "22:58", "800000", "140420" ], + "131379" : [ "22:59", "800000", "140420" ], + "131380" : [ "23:00", "800000", "140420" ], + "131381" : [ "23:01", "800000", "140420" ], + "131382" : [ "23:02", "800000", "140420" ], + "131383" : [ "23:03", "800000", "140420" ], + "131384" : [ "23:04", "800000", "140420" ], + "131385" : [ "23:05", "800000", "140420" ], + "131386" : [ "23:06", "800000", "140420" ], + "131387" : [ "23:07", "800000", "140420" ], + "131388" : [ "23:08", "800000", "140420" ], + "131389" : [ "23:09", "800000", "140420" ], + "131390" : [ "23:10", "800000", "140420" ], + "131391" : [ "23:11", "800000", "140420" ], + "131392" : [ "23:12", "800000", "140420" ], + "131393" : [ "23:13", "800000", "140420" ], + "131394" : [ "23:14", "800000", "140420" ], + "131395" : [ "23:15", "800000", "140420" ], + "131396" : [ "23:16", "800000", "140420" ], + "131397" : [ "23:17", "800000", "140420" ], + "131398" : [ "23:18", "800000", "140420" ], + "131399" : [ "23:19", "800000", "140420" ], + "131400" : [ "23:20", "800000", "140420" ], + "131401" : [ "23:21", "800000", "140420" ], + "131402" : [ "23:22", "800000", "140420" ], + "131403" : [ "23:23", "800000", "140420" ], + "131404" : [ "23:24", "800000", "140420" ], + "131405" : [ "23:25", "800000", "140420" ], + "131406" : [ "23:26", "800000", "140420" ], + "131407" : [ "23:27", "800000", "140420" ], + "131408" : [ "23:28", "800000", "140420" ], + "131409" : [ "23:29", "800000", "140420" ], + "131410" : [ "23:30", "800000", "140420" ], + "131411" : [ "23:31", "800000", "140420" ], + "131412" : [ "23:32", "800000", "140420" ], + "131413" : [ "23:33", "800000", "140420" ], + "131414" : [ "23:34", "800000", "140420" ], + "131415" : [ "23:35", "800000", "140420" ], + "131416" : [ "23:36", "800000", "140420" ], + "131417" : [ "23:37", "800000", "140420" ], + "131418" : [ "23:38", "800000", "140420" ], + "131419" : [ "23:39", "800000", "140420" ], + "131420" : [ "23:40", "800000", "140420" ], + "131421" : [ "23:41", "800000", "140420" ], + "131422" : [ "23:42", "800000", "140420" ], + "131423" : [ "23:43", "800000", "140420" ], + "131424" : [ "23:44", "800000", "140420" ], + "131425" : [ "23:45", "800000", "140420" ], + "131426" : [ "23:46", "800000", "140420" ], + "131427" : [ "23:47", "800000", "140420" ], + "131428" : [ "23:48", "800000", "140420" ], + "131429" : [ "23:49", "800000", "140420" ], + "131430" : [ "23:50", "800000", "140420" ], + "131431" : [ "23:51", "800000", "140420" ], + "131432" : [ "23:52", "800000", "140420" ], + "131433" : [ "23:53", "800000", "140420" ], + "131434" : [ "23:54", "800000", "140420" ], + "131435" : [ "23:55", "800000", "140420" ], + "131436" : [ "23:56", "800000", "140420" ], + "131437" : [ "23:57", "800000", "140420" ], + "131438" : [ "23:58", "800000", "140420" ], + "131439" : [ "23:59", "800000", "140420" ] + }, + "Friday": { + "140000" : [ "00:00", "800000", "140420" ], + "140001" : [ "00:01", "800000", "140420" ], + "140002" : [ "00:02", "800000", "140420" ], + "140003" : [ "00:03", "800000", "140420" ], + "140004" : [ "00:04", "800000", "140420" ], + "140005" : [ "00:05", "800000", "140420" ], + "140006" : [ "00:06", "800000", "140420" ], + "140007" : [ "00:07", "800000", "140420" ], + "140008" : [ "00:08", "800000", "140420" ], + "140009" : [ "00:09", "800000", "140420" ], + "140010" : [ "00:10", "800000", "140420" ], + "140011" : [ "00:11", "800000", "140420" ], + "140012" : [ "00:12", "800000", "140420" ], + "140013" : [ "00:13", "800000", "140420" ], + "140014" : [ "00:14", "800000", "140420" ], + "140015" : [ "00:15", "800000", "140420" ], + "140016" : [ "00:16", "800000", "140420" ], + "140017" : [ "00:17", "800000", "140420" ], + "140018" : [ "00:18", "800000", "140420" ], + "140019" : [ "00:19", "800000", "140420" ], + "140020" : [ "00:20", "800000", "140420" ], + "140021" : [ "00:21", "800000", "140420" ], + "140022" : [ "00:22", "800000", "140420" ], + "140023" : [ "00:23", "800000", "140420" ], + "140024" : [ "00:24", "800000", "140420" ], + "140025" : [ "00:25", "800000", "140420" ], + "140026" : [ "00:26", "800000", "140420" ], + "140027" : [ "00:27", "800000", "140420" ], + "140028" : [ "00:28", "800000", "140420" ], + "140029" : [ "00:29", "800000", "140420" ], + "140030" : [ "00:30", "800000", "140420" ], + "140031" : [ "00:31", "800000", "140420" ], + "140032" : [ "00:32", "800000", "140420" ], + "140033" : [ "00:33", "800000", "140420" ], + "140034" : [ "00:34", "800000", "140420" ], + "140035" : [ "00:35", "800000", "140420" ], + "140036" : [ "00:36", "800000", "140420" ], + "140037" : [ "00:37", "800000", "140420" ], + "140038" : [ "00:38", "800000", "140420" ], + "140039" : [ "00:39", "800000", "140420" ], + "140040" : [ "00:40", "800000", "140420" ], + "140041" : [ "00:41", "800000", "140420" ], + "140042" : [ "00:42", "800000", "140420" ], + "140043" : [ "00:43", "800000", "140420" ], + "140044" : [ "00:44", "800000", "140420" ], + "140045" : [ "00:45", "800000", "140420" ], + "140046" : [ "00:46", "800000", "140420" ], + "140047" : [ "00:47", "800000", "140420" ], + "140048" : [ "00:48", "800000", "140420" ], + "140049" : [ "00:49", "800000", "140420" ], + "140050" : [ "00:50", "800000", "140420" ], + "140051" : [ "00:51", "800000", "140420" ], + "140052" : [ "00:52", "800000", "140420" ], + "140053" : [ "00:53", "800000", "140420" ], + "140054" : [ "00:54", "800000", "140420" ], + "140055" : [ "00:55", "800000", "140420" ], + "140056" : [ "00:56", "800000", "140420" ], + "140057" : [ "00:57", "800000", "140420" ], + "140058" : [ "00:58", "800000", "140420" ], + "140059" : [ "00:59", "800000", "140420" ], + "140060" : [ "01:00", "800000", "140420" ], + "140061" : [ "01:01", "800000", "140420" ], + "140062" : [ "01:02", "800000", "140420" ], + "140063" : [ "01:03", "800000", "140420" ], + "140064" : [ "01:04", "800000", "140420" ], + "140065" : [ "01:05", "800000", "140420" ], + "140066" : [ "01:06", "800000", "140420" ], + "140067" : [ "01:07", "800000", "140420" ], + "140068" : [ "01:08", "800000", "140420" ], + "140069" : [ "01:09", "800000", "140420" ], + "140070" : [ "01:10", "800000", "140420" ], + "140071" : [ "01:11", "800000", "140420" ], + "140072" : [ "01:12", "800000", "140420" ], + "140073" : [ "01:13", "800000", "140420" ], + "140074" : [ "01:14", "800000", "140420" ], + "140075" : [ "01:15", "800000", "140420" ], + "140076" : [ "01:16", "800000", "140420" ], + "140077" : [ "01:17", "800000", "140420" ], + "140078" : [ "01:18", "800000", "140420" ], + "140079" : [ "01:19", "800000", "140420" ], + "140080" : [ "01:20", "800000", "140420" ], + "140081" : [ "01:21", "800000", "140420" ], + "140082" : [ "01:22", "800000", "140420" ], + "140083" : [ "01:23", "800000", "140420" ], + "140084" : [ "01:24", "800000", "140420" ], + "140085" : [ "01:25", "800000", "140420" ], + "140086" : [ "01:26", "800000", "140420" ], + "140087" : [ "01:27", "800000", "140420" ], + "140088" : [ "01:28", "800000", "140420" ], + "140089" : [ "01:29", "800000", "140420" ], + "140090" : [ "01:30", "800000", "140420" ], + "140091" : [ "01:31", "800000", "140420" ], + "140092" : [ "01:32", "800000", "140420" ], + "140093" : [ "01:33", "800000", "140420" ], + "140094" : [ "01:34", "800000", "140420" ], + "140095" : [ "01:35", "800000", "140420" ], + "140096" : [ "01:36", "800000", "140420" ], + "140097" : [ "01:37", "800000", "140420" ], + "140098" : [ "01:38", "800000", "140420" ], + "140099" : [ "01:39", "800000", "140420" ], + "140100" : [ "01:40", "800000", "140420" ], + "140101" : [ "01:41", "800000", "140420" ], + "140102" : [ "01:42", "800000", "140420" ], + "140103" : [ "01:43", "800000", "140420" ], + "140104" : [ "01:44", "800000", "140420" ], + "140105" : [ "01:45", "800000", "140420" ], + "140106" : [ "01:46", "800000", "140420" ], + "140107" : [ "01:47", "800000", "140420" ], + "140108" : [ "01:48", "800000", "140420" ], + "140109" : [ "01:49", "800000", "140420" ], + "140110" : [ "01:50", "800000", "140420" ], + "140111" : [ "01:51", "800000", "140420" ], + "140112" : [ "01:52", "800000", "140420" ], + "140113" : [ "01:53", "800000", "140420" ], + "140114" : [ "01:54", "800000", "140420" ], + "140115" : [ "01:55", "800000", "140420" ], + "140116" : [ "01:56", "800000", "140420" ], + "140117" : [ "01:57", "800000", "140420" ], + "140118" : [ "01:58", "800000", "140420" ], + "140119" : [ "01:59", "800000", "140420" ], + "140120" : [ "02:00", "800000", "140420" ], + "140121" : [ "02:01", "800000", "140420" ], + "140122" : [ "02:02", "800000", "140420" ], + "140123" : [ "02:03", "800000", "140420" ], + "140124" : [ "02:04", "800000", "140420" ], + "140125" : [ "02:05", "800000", "140420" ], + "140126" : [ "02:06", "800000", "140420" ], + "140127" : [ "02:07", "800000", "140420" ], + "140128" : [ "02:08", "800000", "140420" ], + "140129" : [ "02:09", "800000", "140420" ], + "140130" : [ "02:10", "800000", "140420" ], + "140131" : [ "02:11", "800000", "140420" ], + "140132" : [ "02:12", "800000", "140420" ], + "140133" : [ "02:13", "800000", "140420" ], + "140134" : [ "02:14", "800000", "140420" ], + "140135" : [ "02:15", "800000", "140420" ], + "140136" : [ "02:16", "800000", "140420" ], + "140137" : [ "02:17", "800000", "140420" ], + "140138" : [ "02:18", "800000", "140420" ], + "140139" : [ "02:19", "800000", "140420" ], + "140140" : [ "02:20", "800000", "140420" ], + "140141" : [ "02:21", "800000", "140420" ], + "140142" : [ "02:22", "800000", "140420" ], + "140143" : [ "02:23", "800000", "140420" ], + "140144" : [ "02:24", "800000", "140420" ], + "140145" : [ "02:25", "800000", "140420" ], + "140146" : [ "02:26", "800000", "140420" ], + "140147" : [ "02:27", "800000", "140420" ], + "140148" : [ "02:28", "800000", "140420" ], + "140149" : [ "02:29", "800000", "140420" ], + "140150" : [ "02:30", "800000", "140420" ], + "140151" : [ "02:31", "800000", "140420" ], + "140152" : [ "02:32", "800000", "140420" ], + "140153" : [ "02:33", "800000", "140420" ], + "140154" : [ "02:34", "800000", "140420" ], + "140155" : [ "02:35", "800000", "140420" ], + "140156" : [ "02:36", "800000", "140420" ], + "140157" : [ "02:37", "800000", "140420" ], + "140158" : [ "02:38", "800000", "140420" ], + "140159" : [ "02:39", "800000", "140420" ], + "140160" : [ "02:40", "800000", "140420" ], + "140161" : [ "02:41", "800000", "140420" ], + "140162" : [ "02:42", "800000", "140420" ], + "140163" : [ "02:43", "800000", "140420" ], + "140164" : [ "02:44", "800000", "140420" ], + "140165" : [ "02:45", "800000", "140420" ], + "140166" : [ "02:46", "800000", "140420" ], + "140167" : [ "02:47", "800000", "140420" ], + "140168" : [ "02:48", "800000", "140420" ], + "140169" : [ "02:49", "800000", "140420" ], + "140170" : [ "02:50", "800000", "140420" ], + "140171" : [ "02:51", "800000", "140420" ], + "140172" : [ "02:52", "800000", "140420" ], + "140173" : [ "02:53", "800000", "140420" ], + "140174" : [ "02:54", "800000", "140420" ], + "140175" : [ "02:55", "800000", "140420" ], + "140176" : [ "02:56", "800000", "140420" ], + "140177" : [ "02:57", "800000", "140420" ], + "140178" : [ "02:58", "800000", "140420" ], + "140179" : [ "02:59", "800000", "140420" ], + "140180" : [ "03:00", "800000", "140420" ], + "140181" : [ "03:01", "800000", "140420" ], + "140182" : [ "03:02", "800000", "140420" ], + "140183" : [ "03:03", "800000", "140420" ], + "140184" : [ "03:04", "800000", "140420" ], + "140185" : [ "03:05", "800000", "140420" ], + "140186" : [ "03:06", "800000", "140420" ], + "140187" : [ "03:07", "800000", "140420" ], + "140188" : [ "03:08", "800000", "140420" ], + "140189" : [ "03:09", "800000", "140420" ], + "140190" : [ "03:10", "800000", "140420" ], + "140191" : [ "03:11", "800000", "140420" ], + "140192" : [ "03:12", "800000", "140420" ], + "140193" : [ "03:13", "800000", "140420" ], + "140194" : [ "03:14", "800000", "140420" ], + "140195" : [ "03:15", "800000", "140420" ], + "140196" : [ "03:16", "800000", "140420" ], + "140197" : [ "03:17", "800000", "140420" ], + "140198" : [ "03:18", "800000", "140420" ], + "140199" : [ "03:19", "800000", "140420" ], + "140200" : [ "03:20", "800000", "140420" ], + "140201" : [ "03:21", "800000", "140420" ], + "140202" : [ "03:22", "800000", "140420" ], + "140203" : [ "03:23", "800000", "140420" ], + "140204" : [ "03:24", "800000", "140420" ], + "140205" : [ "03:25", "800000", "140420" ], + "140206" : [ "03:26", "800000", "140420" ], + "140207" : [ "03:27", "800000", "140420" ], + "140208" : [ "03:28", "800000", "140420" ], + "140209" : [ "03:29", "800000", "140420" ], + "140210" : [ "03:30", "800000", "140420" ], + "140211" : [ "03:31", "800000", "140420" ], + "140212" : [ "03:32", "800000", "140420" ], + "140213" : [ "03:33", "800000", "140420" ], + "140214" : [ "03:34", "800000", "140420" ], + "140215" : [ "03:35", "800000", "140420" ], + "140216" : [ "03:36", "800000", "140420" ], + "140217" : [ "03:37", "800000", "140420" ], + "140218" : [ "03:38", "800000", "140420" ], + "140219" : [ "03:39", "800000", "140420" ], + "140220" : [ "03:40", "800000", "140420" ], + "140221" : [ "03:41", "800000", "140420" ], + "140222" : [ "03:42", "800000", "140420" ], + "140223" : [ "03:43", "800000", "140420" ], + "140224" : [ "03:44", "800000", "140420" ], + "140225" : [ "03:45", "800000", "140420" ], + "140226" : [ "03:46", "800000", "140420" ], + "140227" : [ "03:47", "800000", "140420" ], + "140228" : [ "03:48", "800000", "140420" ], + "140229" : [ "03:49", "800000", "140420" ], + "140230" : [ "03:50", "800000", "140420" ], + "140231" : [ "03:51", "800000", "140420" ], + "140232" : [ "03:52", "800000", "140420" ], + "140233" : [ "03:53", "800000", "140420" ], + "140234" : [ "03:54", "800000", "140420" ], + "140235" : [ "03:55", "800000", "140420" ], + "140236" : [ "03:56", "800000", "140420" ], + "140237" : [ "03:57", "800000", "140420" ], + "140238" : [ "03:58", "800000", "140420" ], + "140239" : [ "03:59", "800000", "140420" ], + "140240" : [ "04:00", "800000", "140420" ], + "140241" : [ "04:01", "800000", "140420" ], + "140242" : [ "04:02", "800000", "140420" ], + "140243" : [ "04:03", "800000", "140420" ], + "140244" : [ "04:04", "800000", "140420" ], + "140245" : [ "04:05", "800000", "140420" ], + "140246" : [ "04:06", "800000", "140420" ], + "140247" : [ "04:07", "800000", "140420" ], + "140248" : [ "04:08", "800000", "140420" ], + "140249" : [ "04:09", "800000", "140420" ], + "140250" : [ "04:10", "800000", "140420" ], + "140251" : [ "04:11", "800000", "140420" ], + "140252" : [ "04:12", "800000", "140420" ], + "140253" : [ "04:13", "800000", "140420" ], + "140254" : [ "04:14", "800000", "140420" ], + "140255" : [ "04:15", "800000", "140420" ], + "140256" : [ "04:16", "800000", "140420" ], + "140257" : [ "04:17", "800000", "140420" ], + "140258" : [ "04:18", "800000", "140420" ], + "140259" : [ "04:19", "800000", "140420" ], + "140260" : [ "04:20", "800000", "140420" ], + "140261" : [ "04:21", "800000", "140420" ], + "140262" : [ "04:22", "800000", "140420" ], + "140263" : [ "04:23", "800000", "140420" ], + "140264" : [ "04:24", "800000", "140420" ], + "140265" : [ "04:25", "800000", "140420" ], + "140266" : [ "04:26", "800000", "140420" ], + "140267" : [ "04:27", "800000", "140420" ], + "140268" : [ "04:28", "800000", "140420" ], + "140269" : [ "04:29", "800000", "140420" ], + "140270" : [ "04:30", "800000", "140420" ], + "140271" : [ "04:31", "800000", "140420" ], + "140272" : [ "04:32", "800000", "140420" ], + "140273" : [ "04:33", "800000", "140420" ], + "140274" : [ "04:34", "800000", "140420" ], + "140275" : [ "04:35", "800000", "140420" ], + "140276" : [ "04:36", "800000", "140420" ], + "140277" : [ "04:37", "800000", "140420" ], + "140278" : [ "04:38", "800000", "140420" ], + "140279" : [ "04:39", "800000", "140420" ], + "140280" : [ "04:40", "800000", "140420" ], + "140281" : [ "04:41", "800000", "140420" ], + "140282" : [ "04:42", "800000", "140420" ], + "140283" : [ "04:43", "800000", "140420" ], + "140284" : [ "04:44", "800000", "140420" ], + "140285" : [ "04:45", "800000", "140420" ], + "140286" : [ "04:46", "800000", "140420" ], + "140287" : [ "04:47", "800000", "140420" ], + "140288" : [ "04:48", "800000", "140420" ], + "140289" : [ "04:49", "800000", "140420" ], + "140290" : [ "04:50", "800000", "140420" ], + "140291" : [ "04:51", "800000", "140420" ], + "140292" : [ "04:52", "800000", "140420" ], + "140293" : [ "04:53", "800000", "140420" ], + "140294" : [ "04:54", "800000", "140420" ], + "140295" : [ "04:55", "800000", "140420" ], + "140296" : [ "04:56", "800000", "140420" ], + "140297" : [ "04:57", "800000", "140420" ], + "140298" : [ "04:58", "800000", "140420" ], + "140299" : [ "04:59", "800000", "140420" ], + "140300" : [ "05:00", "800000", "140420" ], + "140301" : [ "05:01", "800000", "140420" ], + "140302" : [ "05:02", "800000", "140420" ], + "140303" : [ "05:03", "800000", "140420" ], + "140304" : [ "05:04", "800000", "140420" ], + "140305" : [ "05:05", "800000", "140420" ], + "140306" : [ "05:06", "800000", "140420" ], + "140307" : [ "05:07", "800000", "140420" ], + "140308" : [ "05:08", "800000", "140420" ], + "140309" : [ "05:09", "800000", "140420" ], + "140310" : [ "05:10", "800000", "140420" ], + "140311" : [ "05:11", "800000", "140420" ], + "140312" : [ "05:12", "800000", "140420" ], + "140313" : [ "05:13", "800000", "140420" ], + "140314" : [ "05:14", "800000", "140420" ], + "140315" : [ "05:15", "800000", "140420" ], + "140316" : [ "05:16", "800000", "140420" ], + "140317" : [ "05:17", "800000", "140420" ], + "140318" : [ "05:18", "800000", "140420" ], + "140319" : [ "05:19", "800000", "140420" ], + "140320" : [ "05:20", "800000", "140420" ], + "140321" : [ "05:21", "800000", "140420" ], + "140322" : [ "05:22", "800000", "140420" ], + "140323" : [ "05:23", "800000", "140420" ], + "140324" : [ "05:24", "800000", "140420" ], + "140325" : [ "05:25", "800000", "140420" ], + "140326" : [ "05:26", "800000", "140420" ], + "140327" : [ "05:27", "800000", "140420" ], + "140328" : [ "05:28", "800000", "140420" ], + "140329" : [ "05:29", "800000", "140420" ], + "140330" : [ "05:30", "800000", "140420" ], + "140331" : [ "05:31", "800000", "140420" ], + "140332" : [ "05:32", "800000", "140420" ], + "140333" : [ "05:33", "800000", "140420" ], + "140334" : [ "05:34", "800000", "140420" ], + "140335" : [ "05:35", "800000", "140420" ], + "140336" : [ "05:36", "800000", "140420" ], + "140337" : [ "05:37", "800000", "140420" ], + "140338" : [ "05:38", "800000", "140420" ], + "140339" : [ "05:39", "800000", "140420" ], + "140340" : [ "05:40", "800000", "140420" ], + "140341" : [ "05:41", "800000", "140420" ], + "140342" : [ "05:42", "800000", "140420" ], + "140343" : [ "05:43", "800000", "140420" ], + "140344" : [ "05:44", "800000", "140420" ], + "140345" : [ "05:45", "800000", "140420" ], + "140346" : [ "05:46", "800000", "140420" ], + "140347" : [ "05:47", "800000", "140420" ], + "140348" : [ "05:48", "800000", "140420" ], + "140349" : [ "05:49", "800000", "140420" ], + "140350" : [ "05:50", "800000", "140420" ], + "140351" : [ "05:51", "800000", "140420" ], + "140352" : [ "05:52", "800000", "140420" ], + "140353" : [ "05:53", "800000", "140420" ], + "140354" : [ "05:54", "800000", "140420" ], + "140355" : [ "05:55", "800000", "140420" ], + "140356" : [ "05:56", "800000", "140420" ], + "140357" : [ "05:57", "800000", "140420" ], + "140358" : [ "05:58", "800000", "140420" ], + "140359" : [ "05:59", "800000", "140420" ], + "140360" : [ "06:00", "800000", "140420" ], + "140361" : [ "06:01", "800000", "140420" ], + "140362" : [ "06:02", "800000", "140420" ], + "140363" : [ "06:03", "800000", "140420" ], + "140364" : [ "06:04", "800000", "140420" ], + "140365" : [ "06:05", "800000", "140420" ], + "140366" : [ "06:06", "800000", "140420" ], + "140367" : [ "06:07", "800000", "140420" ], + "140368" : [ "06:08", "800000", "140420" ], + "140369" : [ "06:09", "800000", "140420" ], + "140370" : [ "06:10", "800000", "140420" ], + "140371" : [ "06:11", "800000", "140420" ], + "140372" : [ "06:12", "800000", "140420" ], + "140373" : [ "06:13", "800000", "140420" ], + "140374" : [ "06:14", "800000", "140420" ], + "140375" : [ "06:15", "800000", "140420" ], + "140376" : [ "06:16", "800000", "140420" ], + "140377" : [ "06:17", "800000", "140420" ], + "140378" : [ "06:18", "800000", "140420" ], + "140379" : [ "06:19", "800000", "140420" ], + "140380" : [ "06:20", "800000", "140420" ], + "140381" : [ "06:21", "800000", "140420" ], + "140382" : [ "06:22", "800000", "140420" ], + "140383" : [ "06:23", "800000", "140420" ], + "140384" : [ "06:24", "800000", "140420" ], + "140385" : [ "06:25", "800000", "140420" ], + "140386" : [ "06:26", "800000", "140420" ], + "140387" : [ "06:27", "800000", "140420" ], + "140388" : [ "06:28", "800000", "140420" ], + "140389" : [ "06:29", "800000", "140420" ], + "140390" : [ "06:30", "800000", "140420" ], + "140391" : [ "06:31", "800000", "140420" ], + "140392" : [ "06:32", "800000", "140420" ], + "140393" : [ "06:33", "800000", "140420" ], + "140394" : [ "06:34", "800000", "140420" ], + "140395" : [ "06:35", "800000", "140420" ], + "140396" : [ "06:36", "800000", "140420" ], + "140397" : [ "06:37", "800000", "140420" ], + "140398" : [ "06:38", "800000", "140420" ], + "140399" : [ "06:39", "800000", "140420" ], + "140400" : [ "06:40", "800000", "140420" ], + "140401" : [ "06:41", "800000", "140420" ], + "140402" : [ "06:42", "800000", "140420" ], + "140403" : [ "06:43", "800000", "140420" ], + "140404" : [ "06:44", "800000", "140420" ], + "140405" : [ "06:45", "800000", "140420" ], + "140406" : [ "06:46", "800000", "140420" ], + "140407" : [ "06:47", "800000", "140420" ], + "140408" : [ "06:48", "800000", "140420" ], + "140409" : [ "06:49", "800000", "140420" ], + "140410" : [ "06:50", "800000", "140420" ], + "140411" : [ "06:51", "800000", "140420" ], + "140412" : [ "06:52", "800000", "140420" ], + "140413" : [ "06:53", "800000", "140420" ], + "140414" : [ "06:54", "800000", "140420" ], + "140415" : [ "06:55", "800000", "140420" ], + "140416" : [ "06:56", "800000", "140420" ], + "140417" : [ "06:57", "800000", "140420" ], + "140418" : [ "06:58", "800000", "140420" ], + "140419" : [ "06:59", "800000", "140420" ], + "140420" : [ "07:00", "350000", "140480" ], + "140421" : [ "07:01", "350000", "140481" ], + "140422" : [ "07:02", "350000", "140482" ], + "140423" : [ "07:03", "350000", "140483" ], + "140424" : [ "07:04", "350000", "140484" ], + "140425" : [ "07:05", "350000", "140485" ], + "140426" : [ "07:06", "350000", "140486" ], + "140427" : [ "07:07", "350000", "140487" ], + "140428" : [ "07:08", "350000", "140488" ], + "140429" : [ "07:09", "350000", "140489" ], + "140430" : [ "07:10", "350000", "140490" ], + "140431" : [ "07:11", "350000", "140491" ], + "140432" : [ "07:12", "350000", "140492" ], + "140433" : [ "07:13", "350000", "140493" ], + "140434" : [ "07:14", "350000", "140494" ], + "140435" : [ "07:15", "350000", "140495" ], + "140436" : [ "07:16", "350000", "140496" ], + "140437" : [ "07:17", "350000", "140497" ], + "140438" : [ "07:18", "350000", "140498" ], + "140439" : [ "07:19", "350000", "140499" ], + "140440" : [ "07:20", "350000", "140500" ], + "140441" : [ "07:21", "350000", "140501" ], + "140442" : [ "07:22", "350000", "140502" ], + "140443" : [ "07:23", "350000", "140503" ], + "140444" : [ "07:24", "350000", "140504" ], + "140445" : [ "07:25", "350000", "140505" ], + "140446" : [ "07:26", "350000", "140506" ], + "140447" : [ "07:27", "350000", "140507" ], + "140448" : [ "07:28", "350000", "140508" ], + "140449" : [ "07:29", "350000", "140509" ], + "140450" : [ "07:30", "350000", "140510" ], + "140451" : [ "07:31", "350000", "140511" ], + "140452" : [ "07:32", "350000", "140512" ], + "140453" : [ "07:33", "350000", "140513" ], + "140454" : [ "07:34", "350000", "140514" ], + "140455" : [ "07:35", "350000", "140515" ], + "140456" : [ "07:36", "350000", "140516" ], + "140457" : [ "07:37", "350000", "140517" ], + "140458" : [ "07:38", "350000", "140518" ], + "140459" : [ "07:39", "350000", "140519" ], + "140460" : [ "07:40", "350000", "140520" ], + "140461" : [ "07:41", "350000", "140521" ], + "140462" : [ "07:42", "350000", "140522" ], + "140463" : [ "07:43", "350000", "140523" ], + "140464" : [ "07:44", "350000", "140524" ], + "140465" : [ "07:45", "350000", "140525" ], + "140466" : [ "07:46", "350000", "140526" ], + "140467" : [ "07:47", "350000", "140527" ], + "140468" : [ "07:48", "350000", "140528" ], + "140469" : [ "07:49", "350000", "140529" ], + "140470" : [ "07:50", "350000", "140530" ], + "140471" : [ "07:51", "350000", "140531" ], + "140472" : [ "07:52", "350000", "140532" ], + "140473" : [ "07:53", "350000", "140533" ], + "140474" : [ "07:54", "350000", "140534" ], + "140475" : [ "07:55", "350000", "140535" ], + "140476" : [ "07:56", "350000", "140536" ], + "140477" : [ "07:57", "350000", "140537" ], + "140478" : [ "07:58", "350000", "140538" ], + "140479" : [ "07:59", "350000", "140539" ], + "140480" : [ "08:00", "350000", "140540" ], + "140481" : [ "08:01", "350000", "140541" ], + "140482" : [ "08:02", "350000", "140542" ], + "140483" : [ "08:03", "350000", "140543" ], + "140484" : [ "08:04", "350000", "140544" ], + "140485" : [ "08:05", "350000", "140545" ], + "140486" : [ "08:06", "350000", "140546" ], + "140487" : [ "08:07", "350000", "140547" ], + "140488" : [ "08:08", "350000", "140548" ], + "140489" : [ "08:09", "350000", "140549" ], + "140490" : [ "08:10", "350000", "140550" ], + "140491" : [ "08:11", "350000", "140551" ], + "140492" : [ "08:12", "350000", "140552" ], + "140493" : [ "08:13", "350000", "140553" ], + "140494" : [ "08:14", "350000", "140554" ], + "140495" : [ "08:15", "350000", "140555" ], + "140496" : [ "08:16", "350000", "140556" ], + "140497" : [ "08:17", "350000", "140557" ], + "140498" : [ "08:18", "350000", "140558" ], + "140499" : [ "08:19", "350000", "140559" ], + "140500" : [ "08:20", "350000", "140560" ], + "140501" : [ "08:21", "350000", "140561" ], + "140502" : [ "08:22", "350000", "140562" ], + "140503" : [ "08:23", "350000", "140563" ], + "140504" : [ "08:24", "350000", "140564" ], + "140505" : [ "08:25", "350000", "140565" ], + "140506" : [ "08:26", "350000", "140566" ], + "140507" : [ "08:27", "350000", "140567" ], + "140508" : [ "08:28", "350000", "140568" ], + "140509" : [ "08:29", "350000", "140569" ], + "140510" : [ "08:30", "350000", "140570" ], + "140511" : [ "08:31", "350000", "140571" ], + "140512" : [ "08:32", "350000", "140572" ], + "140513" : [ "08:33", "350000", "140573" ], + "140514" : [ "08:34", "350000", "140574" ], + "140515" : [ "08:35", "350000", "140575" ], + "140516" : [ "08:36", "350000", "140576" ], + "140517" : [ "08:37", "350000", "140577" ], + "140518" : [ "08:38", "350000", "140578" ], + "140519" : [ "08:39", "350000", "140579" ], + "140520" : [ "08:40", "350000", "140580" ], + "140521" : [ "08:41", "350000", "140581" ], + "140522" : [ "08:42", "350000", "140582" ], + "140523" : [ "08:43", "350000", "140583" ], + "140524" : [ "08:44", "350000", "140584" ], + "140525" : [ "08:45", "350000", "140585" ], + "140526" : [ "08:46", "350000", "140586" ], + "140527" : [ "08:47", "350000", "140587" ], + "140528" : [ "08:48", "350000", "140588" ], + "140529" : [ "08:49", "350000", "140589" ], + "140530" : [ "08:50", "350000", "140590" ], + "140531" : [ "08:51", "350000", "140591" ], + "140532" : [ "08:52", "350000", "140592" ], + "140533" : [ "08:53", "350000", "140593" ], + "140534" : [ "08:54", "350000", "140594" ], + "140535" : [ "08:55", "350000", "140595" ], + "140536" : [ "08:56", "350000", "140596" ], + "140537" : [ "08:57", "350000", "140597" ], + "140538" : [ "08:58", "350000", "140598" ], + "140539" : [ "08:59", "350000", "140599" ], + "140540" : [ "09:00", "350000", "140600" ], + "140541" : [ "09:01", "350000", "140601" ], + "140542" : [ "09:02", "350000", "140602" ], + "140543" : [ "09:03", "350000", "140603" ], + "140544" : [ "09:04", "350000", "140604" ], + "140545" : [ "09:05", "350000", "140605" ], + "140546" : [ "09:06", "350000", "140606" ], + "140547" : [ "09:07", "350000", "140607" ], + "140548" : [ "09:08", "350000", "140608" ], + "140549" : [ "09:09", "350000", "140609" ], + "140550" : [ "09:10", "350000", "140610" ], + "140551" : [ "09:11", "350000", "140611" ], + "140552" : [ "09:12", "350000", "140612" ], + "140553" : [ "09:13", "350000", "140613" ], + "140554" : [ "09:14", "350000", "140614" ], + "140555" : [ "09:15", "350000", "140615" ], + "140556" : [ "09:16", "350000", "140616" ], + "140557" : [ "09:17", "350000", "140617" ], + "140558" : [ "09:18", "350000", "140618" ], + "140559" : [ "09:19", "350000", "140619" ], + "140560" : [ "09:20", "350000", "140620" ], + "140561" : [ "09:21", "350000", "140621" ], + "140562" : [ "09:22", "350000", "140622" ], + "140563" : [ "09:23", "350000", "140623" ], + "140564" : [ "09:24", "350000", "140624" ], + "140565" : [ "09:25", "350000", "140625" ], + "140566" : [ "09:26", "350000", "140626" ], + "140567" : [ "09:27", "350000", "140627" ], + "140568" : [ "09:28", "350000", "140628" ], + "140569" : [ "09:29", "350000", "140629" ], + "140570" : [ "09:30", "350000", "140630" ], + "140571" : [ "09:31", "350000", "140631" ], + "140572" : [ "09:32", "350000", "140632" ], + "140573" : [ "09:33", "350000", "140633" ], + "140574" : [ "09:34", "350000", "140634" ], + "140575" : [ "09:35", "350000", "140635" ], + "140576" : [ "09:36", "350000", "140636" ], + "140577" : [ "09:37", "350000", "140637" ], + "140578" : [ "09:38", "350000", "140638" ], + "140579" : [ "09:39", "350000", "140639" ], + "140580" : [ "09:40", "350000", "140640" ], + "140581" : [ "09:41", "350000", "140641" ], + "140582" : [ "09:42", "350000", "140642" ], + "140583" : [ "09:43", "350000", "140643" ], + "140584" : [ "09:44", "350000", "140644" ], + "140585" : [ "09:45", "350000", "140645" ], + "140586" : [ "09:46", "350000", "140646" ], + "140587" : [ "09:47", "350000", "140647" ], + "140588" : [ "09:48", "350000", "140648" ], + "140589" : [ "09:49", "350000", "140649" ], + "140590" : [ "09:50", "350000", "140650" ], + "140591" : [ "09:51", "350000", "140651" ], + "140592" : [ "09:52", "350000", "140652" ], + "140593" : [ "09:53", "350000", "140653" ], + "140594" : [ "09:54", "350000", "140654" ], + "140595" : [ "09:55", "350000", "140655" ], + "140596" : [ "09:56", "350000", "140656" ], + "140597" : [ "09:57", "350000", "140657" ], + "140598" : [ "09:58", "350000", "140658" ], + "140599" : [ "09:59", "350000", "140659" ], + "140600" : [ "10:00", "350000", "140660" ], + "140601" : [ "10:01", "350000", "140661" ], + "140602" : [ "10:02", "350000", "140662" ], + "140603" : [ "10:03", "350000", "140663" ], + "140604" : [ "10:04", "350000", "140664" ], + "140605" : [ "10:05", "350000", "140665" ], + "140606" : [ "10:06", "350000", "140666" ], + "140607" : [ "10:07", "350000", "140667" ], + "140608" : [ "10:08", "350000", "140668" ], + "140609" : [ "10:09", "350000", "140669" ], + "140610" : [ "10:10", "350000", "140670" ], + "140611" : [ "10:11", "350000", "140671" ], + "140612" : [ "10:12", "350000", "140672" ], + "140613" : [ "10:13", "350000", "140673" ], + "140614" : [ "10:14", "350000", "140674" ], + "140615" : [ "10:15", "350000", "140675" ], + "140616" : [ "10:16", "350000", "140676" ], + "140617" : [ "10:17", "350000", "140677" ], + "140618" : [ "10:18", "350000", "140678" ], + "140619" : [ "10:19", "350000", "140679" ], + "140620" : [ "10:20", "350000", "140680" ], + "140621" : [ "10:21", "350000", "140681" ], + "140622" : [ "10:22", "350000", "140682" ], + "140623" : [ "10:23", "350000", "140683" ], + "140624" : [ "10:24", "350000", "140684" ], + "140625" : [ "10:25", "350000", "140685" ], + "140626" : [ "10:26", "350000", "140686" ], + "140627" : [ "10:27", "350000", "140687" ], + "140628" : [ "10:28", "350000", "140688" ], + "140629" : [ "10:29", "350000", "140689" ], + "140630" : [ "10:30", "350000", "140690" ], + "140631" : [ "10:31", "350000", "140691" ], + "140632" : [ "10:32", "350000", "140692" ], + "140633" : [ "10:33", "350000", "140693" ], + "140634" : [ "10:34", "350000", "140694" ], + "140635" : [ "10:35", "350000", "140695" ], + "140636" : [ "10:36", "350000", "140696" ], + "140637" : [ "10:37", "350000", "140697" ], + "140638" : [ "10:38", "350000", "140698" ], + "140639" : [ "10:39", "350000", "140699" ], + "140640" : [ "10:40", "350000", "140700" ], + "140641" : [ "10:41", "350000", "140701" ], + "140642" : [ "10:42", "350000", "140702" ], + "140643" : [ "10:43", "350000", "140703" ], + "140644" : [ "10:44", "350000", "140704" ], + "140645" : [ "10:45", "350000", "140705" ], + "140646" : [ "10:46", "350000", "140706" ], + "140647" : [ "10:47", "350000", "140707" ], + "140648" : [ "10:48", "350000", "140708" ], + "140649" : [ "10:49", "350000", "140709" ], + "140650" : [ "10:50", "350000", "140710" ], + "140651" : [ "10:51", "350000", "140711" ], + "140652" : [ "10:52", "350000", "140712" ], + "140653" : [ "10:53", "350000", "140713" ], + "140654" : [ "10:54", "350000", "140714" ], + "140655" : [ "10:55", "350000", "140715" ], + "140656" : [ "10:56", "350000", "140716" ], + "140657" : [ "10:57", "350000", "140717" ], + "140658" : [ "10:58", "350000", "140718" ], + "140659" : [ "10:59", "350000", "140719" ], + "140660" : [ "11:00", "350000", "140720" ], + "140661" : [ "11:01", "350000", "140721" ], + "140662" : [ "11:02", "350000", "140722" ], + "140663" : [ "11:03", "350000", "140723" ], + "140664" : [ "11:04", "350000", "140724" ], + "140665" : [ "11:05", "350000", "140725" ], + "140666" : [ "11:06", "350000", "140726" ], + "140667" : [ "11:07", "350000", "140727" ], + "140668" : [ "11:08", "350000", "140728" ], + "140669" : [ "11:09", "350000", "140729" ], + "140670" : [ "11:10", "350000", "140730" ], + "140671" : [ "11:11", "350000", "140731" ], + "140672" : [ "11:12", "350000", "140732" ], + "140673" : [ "11:13", "350000", "140733" ], + "140674" : [ "11:14", "350000", "140734" ], + "140675" : [ "11:15", "350000", "140735" ], + "140676" : [ "11:16", "350000", "140736" ], + "140677" : [ "11:17", "350000", "140737" ], + "140678" : [ "11:18", "350000", "140738" ], + "140679" : [ "11:19", "350000", "140739" ], + "140680" : [ "11:20", "350000", "140740" ], + "140681" : [ "11:21", "350000", "140741" ], + "140682" : [ "11:22", "350000", "140742" ], + "140683" : [ "11:23", "350000", "140743" ], + "140684" : [ "11:24", "350000", "140744" ], + "140685" : [ "11:25", "350000", "140745" ], + "140686" : [ "11:26", "350000", "140746" ], + "140687" : [ "11:27", "350000", "140747" ], + "140688" : [ "11:28", "350000", "140748" ], + "140689" : [ "11:29", "350000", "140749" ], + "140690" : [ "11:30", "350000", "140750" ], + "140691" : [ "11:31", "350000", "140751" ], + "140692" : [ "11:32", "350000", "140752" ], + "140693" : [ "11:33", "350000", "140753" ], + "140694" : [ "11:34", "350000", "140754" ], + "140695" : [ "11:35", "350000", "140755" ], + "140696" : [ "11:36", "350000", "140756" ], + "140697" : [ "11:37", "350000", "140757" ], + "140698" : [ "11:38", "350000", "140758" ], + "140699" : [ "11:39", "350000", "140759" ], + "140700" : [ "11:40", "350000", "140760" ], + "140701" : [ "11:41", "350000", "140761" ], + "140702" : [ "11:42", "350000", "140762" ], + "140703" : [ "11:43", "350000", "140763" ], + "140704" : [ "11:44", "350000", "140764" ], + "140705" : [ "11:45", "350000", "140765" ], + "140706" : [ "11:46", "350000", "140766" ], + "140707" : [ "11:47", "350000", "140767" ], + "140708" : [ "11:48", "350000", "140768" ], + "140709" : [ "11:49", "350000", "140769" ], + "140710" : [ "11:50", "350000", "140770" ], + "140711" : [ "11:51", "350000", "140771" ], + "140712" : [ "11:52", "350000", "140772" ], + "140713" : [ "11:53", "350000", "140773" ], + "140714" : [ "11:54", "350000", "140774" ], + "140715" : [ "11:55", "350000", "140775" ], + "140716" : [ "11:56", "350000", "140776" ], + "140717" : [ "11:57", "350000", "140777" ], + "140718" : [ "11:58", "350000", "140778" ], + "140719" : [ "11:59", "350000", "140779" ], + "140720" : [ "12:00", "350000", "140780" ], + "140721" : [ "12:01", "350000", "140781" ], + "140722" : [ "12:02", "350000", "140782" ], + "140723" : [ "12:03", "350000", "140783" ], + "140724" : [ "12:04", "350000", "140784" ], + "140725" : [ "12:05", "350000", "140785" ], + "140726" : [ "12:06", "350000", "140786" ], + "140727" : [ "12:07", "350000", "140787" ], + "140728" : [ "12:08", "350000", "140788" ], + "140729" : [ "12:09", "350000", "140789" ], + "140730" : [ "12:10", "350000", "140790" ], + "140731" : [ "12:11", "350000", "140791" ], + "140732" : [ "12:12", "350000", "140792" ], + "140733" : [ "12:13", "350000", "140793" ], + "140734" : [ "12:14", "350000", "140794" ], + "140735" : [ "12:15", "350000", "140795" ], + "140736" : [ "12:16", "350000", "140796" ], + "140737" : [ "12:17", "350000", "140797" ], + "140738" : [ "12:18", "350000", "140798" ], + "140739" : [ "12:19", "350000", "140799" ], + "140740" : [ "12:20", "350000", "140800" ], + "140741" : [ "12:21", "350000", "140801" ], + "140742" : [ "12:22", "350000", "140802" ], + "140743" : [ "12:23", "350000", "140803" ], + "140744" : [ "12:24", "350000", "140804" ], + "140745" : [ "12:25", "350000", "140805" ], + "140746" : [ "12:26", "350000", "140806" ], + "140747" : [ "12:27", "350000", "140807" ], + "140748" : [ "12:28", "350000", "140808" ], + "140749" : [ "12:29", "350000", "140809" ], + "140750" : [ "12:30", "350000", "140810" ], + "140751" : [ "12:31", "350000", "140811" ], + "140752" : [ "12:32", "350000", "140812" ], + "140753" : [ "12:33", "350000", "140813" ], + "140754" : [ "12:34", "350000", "140814" ], + "140755" : [ "12:35", "350000", "140815" ], + "140756" : [ "12:36", "350000", "140816" ], + "140757" : [ "12:37", "350000", "140817" ], + "140758" : [ "12:38", "350000", "140818" ], + "140759" : [ "12:39", "350000", "140819" ], + "140760" : [ "12:40", "350000", "140820" ], + "140761" : [ "12:41", "350000", "140821" ], + "140762" : [ "12:42", "350000", "140822" ], + "140763" : [ "12:43", "350000", "140823" ], + "140764" : [ "12:44", "350000", "140824" ], + "140765" : [ "12:45", "350000", "140825" ], + "140766" : [ "12:46", "350000", "140826" ], + "140767" : [ "12:47", "350000", "140827" ], + "140768" : [ "12:48", "350000", "140828" ], + "140769" : [ "12:49", "350000", "140829" ], + "140770" : [ "12:50", "350000", "140830" ], + "140771" : [ "12:51", "350000", "140831" ], + "140772" : [ "12:52", "350000", "140832" ], + "140773" : [ "12:53", "350000", "140833" ], + "140774" : [ "12:54", "350000", "140834" ], + "140775" : [ "12:55", "350000", "140835" ], + "140776" : [ "12:56", "350000", "140836" ], + "140777" : [ "12:57", "350000", "140837" ], + "140778" : [ "12:58", "350000", "140838" ], + "140779" : [ "12:59", "350000", "140839" ], + "140780" : [ "13:00", "350000", "140840" ], + "140781" : [ "13:01", "350000", "140841" ], + "140782" : [ "13:02", "350000", "140842" ], + "140783" : [ "13:03", "350000", "140843" ], + "140784" : [ "13:04", "350000", "140844" ], + "140785" : [ "13:05", "350000", "140845" ], + "140786" : [ "13:06", "350000", "140846" ], + "140787" : [ "13:07", "350000", "140847" ], + "140788" : [ "13:08", "350000", "140848" ], + "140789" : [ "13:09", "350000", "140849" ], + "140790" : [ "13:10", "350000", "140850" ], + "140791" : [ "13:11", "350000", "140851" ], + "140792" : [ "13:12", "350000", "140852" ], + "140793" : [ "13:13", "350000", "140853" ], + "140794" : [ "13:14", "350000", "140854" ], + "140795" : [ "13:15", "350000", "140855" ], + "140796" : [ "13:16", "350000", "140856" ], + "140797" : [ "13:17", "350000", "140857" ], + "140798" : [ "13:18", "350000", "140858" ], + "140799" : [ "13:19", "350000", "140859" ], + "140800" : [ "13:20", "350000", "140860" ], + "140801" : [ "13:21", "350000", "140861" ], + "140802" : [ "13:22", "350000", "140862" ], + "140803" : [ "13:23", "350000", "140863" ], + "140804" : [ "13:24", "350000", "140864" ], + "140805" : [ "13:25", "350000", "140865" ], + "140806" : [ "13:26", "350000", "140866" ], + "140807" : [ "13:27", "350000", "140867" ], + "140808" : [ "13:28", "350000", "140868" ], + "140809" : [ "13:29", "350000", "140869" ], + "140810" : [ "13:30", "350000", "140870" ], + "140811" : [ "13:31", "350000", "140871" ], + "140812" : [ "13:32", "350000", "140872" ], + "140813" : [ "13:33", "350000", "140873" ], + "140814" : [ "13:34", "350000", "140874" ], + "140815" : [ "13:35", "350000", "140875" ], + "140816" : [ "13:36", "350000", "140876" ], + "140817" : [ "13:37", "350000", "140877" ], + "140818" : [ "13:38", "350000", "140878" ], + "140819" : [ "13:39", "350000", "140879" ], + "140820" : [ "13:40", "350000", "140880" ], + "140821" : [ "13:41", "350000", "140881" ], + "140822" : [ "13:42", "350000", "140882" ], + "140823" : [ "13:43", "350000", "140883" ], + "140824" : [ "13:44", "350000", "140884" ], + "140825" : [ "13:45", "350000", "140885" ], + "140826" : [ "13:46", "350000", "140886" ], + "140827" : [ "13:47", "350000", "140887" ], + "140828" : [ "13:48", "350000", "140888" ], + "140829" : [ "13:49", "350000", "140889" ], + "140830" : [ "13:50", "350000", "140890" ], + "140831" : [ "13:51", "350000", "140891" ], + "140832" : [ "13:52", "350000", "140892" ], + "140833" : [ "13:53", "350000", "140893" ], + "140834" : [ "13:54", "350000", "140894" ], + "140835" : [ "13:55", "350000", "140895" ], + "140836" : [ "13:56", "350000", "140896" ], + "140837" : [ "13:57", "350000", "140897" ], + "140838" : [ "13:58", "350000", "140898" ], + "140839" : [ "13:59", "350000", "140899" ], + "140840" : [ "14:00", "350000", "140900" ], + "140841" : [ "14:01", "350000", "140901" ], + "140842" : [ "14:02", "350000", "140902" ], + "140843" : [ "14:03", "350000", "140903" ], + "140844" : [ "14:04", "350000", "140904" ], + "140845" : [ "14:05", "350000", "140905" ], + "140846" : [ "14:06", "350000", "140906" ], + "140847" : [ "14:07", "350000", "140907" ], + "140848" : [ "14:08", "350000", "140908" ], + "140849" : [ "14:09", "350000", "140909" ], + "140850" : [ "14:10", "350000", "140910" ], + "140851" : [ "14:11", "350000", "140911" ], + "140852" : [ "14:12", "350000", "140912" ], + "140853" : [ "14:13", "350000", "140913" ], + "140854" : [ "14:14", "350000", "140914" ], + "140855" : [ "14:15", "350000", "140915" ], + "140856" : [ "14:16", "350000", "140916" ], + "140857" : [ "14:17", "350000", "140917" ], + "140858" : [ "14:18", "350000", "140918" ], + "140859" : [ "14:19", "350000", "140919" ], + "140860" : [ "14:20", "350000", "140920" ], + "140861" : [ "14:21", "350000", "140921" ], + "140862" : [ "14:22", "350000", "140922" ], + "140863" : [ "14:23", "350000", "140923" ], + "140864" : [ "14:24", "350000", "140924" ], + "140865" : [ "14:25", "350000", "140925" ], + "140866" : [ "14:26", "350000", "140926" ], + "140867" : [ "14:27", "350000", "140927" ], + "140868" : [ "14:28", "350000", "140928" ], + "140869" : [ "14:29", "350000", "140929" ], + "140870" : [ "14:30", "350000", "140930" ], + "140871" : [ "14:31", "350000", "140931" ], + "140872" : [ "14:32", "350000", "140932" ], + "140873" : [ "14:33", "350000", "140933" ], + "140874" : [ "14:34", "350000", "140934" ], + "140875" : [ "14:35", "350000", "140935" ], + "140876" : [ "14:36", "350000", "140936" ], + "140877" : [ "14:37", "350000", "140937" ], + "140878" : [ "14:38", "350000", "140938" ], + "140879" : [ "14:39", "350000", "140939" ], + "140880" : [ "14:40", "350000", "140940" ], + "140881" : [ "14:41", "350000", "140941" ], + "140882" : [ "14:42", "350000", "140942" ], + "140883" : [ "14:43", "350000", "140943" ], + "140884" : [ "14:44", "350000", "140944" ], + "140885" : [ "14:45", "350000", "140945" ], + "140886" : [ "14:46", "350000", "140946" ], + "140887" : [ "14:47", "350000", "140947" ], + "140888" : [ "14:48", "350000", "140948" ], + "140889" : [ "14:49", "350000", "140949" ], + "140890" : [ "14:50", "350000", "140950" ], + "140891" : [ "14:51", "350000", "140951" ], + "140892" : [ "14:52", "350000", "140952" ], + "140893" : [ "14:53", "350000", "140953" ], + "140894" : [ "14:54", "350000", "140954" ], + "140895" : [ "14:55", "350000", "140955" ], + "140896" : [ "14:56", "350000", "140956" ], + "140897" : [ "14:57", "350000", "140957" ], + "140898" : [ "14:58", "350000", "140958" ], + "140899" : [ "14:59", "350000", "140959" ], + "140900" : [ "15:00", "350000", "140960" ], + "140901" : [ "15:01", "350000", "140961" ], + "140902" : [ "15:02", "350000", "140962" ], + "140903" : [ "15:03", "350000", "140963" ], + "140904" : [ "15:04", "350000", "140964" ], + "140905" : [ "15:05", "350000", "140965" ], + "140906" : [ "15:06", "350000", "140966" ], + "140907" : [ "15:07", "350000", "140967" ], + "140908" : [ "15:08", "350000", "140968" ], + "140909" : [ "15:09", "350000", "140969" ], + "140910" : [ "15:10", "350000", "140970" ], + "140911" : [ "15:11", "350000", "140971" ], + "140912" : [ "15:12", "350000", "140972" ], + "140913" : [ "15:13", "350000", "140973" ], + "140914" : [ "15:14", "350000", "140974" ], + "140915" : [ "15:15", "350000", "140975" ], + "140916" : [ "15:16", "350000", "140976" ], + "140917" : [ "15:17", "350000", "140977" ], + "140918" : [ "15:18", "350000", "140978" ], + "140919" : [ "15:19", "350000", "140979" ], + "140920" : [ "15:20", "350000", "140980" ], + "140921" : [ "15:21", "350000", "140981" ], + "140922" : [ "15:22", "350000", "140982" ], + "140923" : [ "15:23", "350000", "140983" ], + "140924" : [ "15:24", "350000", "140984" ], + "140925" : [ "15:25", "350000", "140985" ], + "140926" : [ "15:26", "350000", "140986" ], + "140927" : [ "15:27", "350000", "140987" ], + "140928" : [ "15:28", "350000", "140988" ], + "140929" : [ "15:29", "350000", "140989" ], + "140930" : [ "15:30", "350000", "140990" ], + "140931" : [ "15:31", "350000", "140991" ], + "140932" : [ "15:32", "350000", "140992" ], + "140933" : [ "15:33", "350000", "140993" ], + "140934" : [ "15:34", "350000", "140994" ], + "140935" : [ "15:35", "350000", "140995" ], + "140936" : [ "15:36", "350000", "140996" ], + "140937" : [ "15:37", "350000", "140997" ], + "140938" : [ "15:38", "350000", "140998" ], + "140939" : [ "15:39", "350000", "140999" ], + "140940" : [ "15:40", "350000", "141000" ], + "140941" : [ "15:41", "350000", "141001" ], + "140942" : [ "15:42", "350000", "141002" ], + "140943" : [ "15:43", "350000", "141003" ], + "140944" : [ "15:44", "350000", "141004" ], + "140945" : [ "15:45", "350000", "141005" ], + "140946" : [ "15:46", "350000", "141006" ], + "140947" : [ "15:47", "350000", "141007" ], + "140948" : [ "15:48", "350000", "141008" ], + "140949" : [ "15:49", "350000", "141009" ], + "140950" : [ "15:50", "350000", "141010" ], + "140951" : [ "15:51", "350000", "141011" ], + "140952" : [ "15:52", "350000", "141012" ], + "140953" : [ "15:53", "350000", "141013" ], + "140954" : [ "15:54", "350000", "141014" ], + "140955" : [ "15:55", "350000", "141015" ], + "140956" : [ "15:56", "350000", "141016" ], + "140957" : [ "15:57", "350000", "141017" ], + "140958" : [ "15:58", "350000", "141018" ], + "140959" : [ "15:59", "350000", "141019" ], + "140960" : [ "16:00", "350000", "141020" ], + "140961" : [ "16:01", "350000", "141021" ], + "140962" : [ "16:02", "350000", "141022" ], + "140963" : [ "16:03", "350000", "141023" ], + "140964" : [ "16:04", "350000", "141024" ], + "140965" : [ "16:05", "350000", "141025" ], + "140966" : [ "16:06", "350000", "141026" ], + "140967" : [ "16:07", "350000", "141027" ], + "140968" : [ "16:08", "350000", "141028" ], + "140969" : [ "16:09", "350000", "141029" ], + "140970" : [ "16:10", "350000", "141030" ], + "140971" : [ "16:11", "350000", "141031" ], + "140972" : [ "16:12", "350000", "141032" ], + "140973" : [ "16:13", "350000", "141033" ], + "140974" : [ "16:14", "350000", "141034" ], + "140975" : [ "16:15", "350000", "141035" ], + "140976" : [ "16:16", "350000", "141036" ], + "140977" : [ "16:17", "350000", "141037" ], + "140978" : [ "16:18", "350000", "141038" ], + "140979" : [ "16:19", "350000", "141039" ], + "140980" : [ "16:20", "350000", "141040" ], + "140981" : [ "16:21", "350000", "141041" ], + "140982" : [ "16:22", "350000", "141042" ], + "140983" : [ "16:23", "350000", "141043" ], + "140984" : [ "16:24", "350000", "141044" ], + "140985" : [ "16:25", "350000", "141045" ], + "140986" : [ "16:26", "350000", "141046" ], + "140987" : [ "16:27", "350000", "141047" ], + "140988" : [ "16:28", "350000", "141048" ], + "140989" : [ "16:29", "350000", "141049" ], + "140990" : [ "16:30", "350000", "141050" ], + "140991" : [ "16:31", "350000", "141051" ], + "140992" : [ "16:32", "350000", "141052" ], + "140993" : [ "16:33", "350000", "141053" ], + "140994" : [ "16:34", "350000", "141054" ], + "140995" : [ "16:35", "350000", "141055" ], + "140996" : [ "16:36", "350000", "141056" ], + "140997" : [ "16:37", "350000", "141057" ], + "140998" : [ "16:38", "350000", "141058" ], + "140999" : [ "16:39", "350000", "141059" ], + "141000" : [ "16:40", "350000", "141060" ], + "141001" : [ "16:41", "350000", "141061" ], + "141002" : [ "16:42", "350000", "141062" ], + "141003" : [ "16:43", "350000", "141063" ], + "141004" : [ "16:44", "350000", "141064" ], + "141005" : [ "16:45", "350000", "141065" ], + "141006" : [ "16:46", "350000", "141066" ], + "141007" : [ "16:47", "350000", "141067" ], + "141008" : [ "16:48", "350000", "141068" ], + "141009" : [ "16:49", "350000", "141069" ], + "141010" : [ "16:50", "350000", "141070" ], + "141011" : [ "16:51", "350000", "141071" ], + "141012" : [ "16:52", "350000", "141072" ], + "141013" : [ "16:53", "350000", "141073" ], + "141014" : [ "16:54", "350000", "141074" ], + "141015" : [ "16:55", "350000", "141075" ], + "141016" : [ "16:56", "350000", "141076" ], + "141017" : [ "16:57", "350000", "141077" ], + "141018" : [ "16:58", "350000", "141078" ], + "141019" : [ "16:59", "350000", "141079" ], + "141020" : [ "17:00", "350000", "141080" ], + "141021" : [ "17:01", "350000", "141081" ], + "141022" : [ "17:02", "350000", "141082" ], + "141023" : [ "17:03", "350000", "141083" ], + "141024" : [ "17:04", "350000", "141084" ], + "141025" : [ "17:05", "350000", "141085" ], + "141026" : [ "17:06", "350000", "141086" ], + "141027" : [ "17:07", "350000", "141087" ], + "141028" : [ "17:08", "350000", "141088" ], + "141029" : [ "17:09", "350000", "141089" ], + "141030" : [ "17:10", "350000", "141090" ], + "141031" : [ "17:11", "350000", "141091" ], + "141032" : [ "17:12", "350000", "141092" ], + "141033" : [ "17:13", "350000", "141093" ], + "141034" : [ "17:14", "350000", "141094" ], + "141035" : [ "17:15", "350000", "141095" ], + "141036" : [ "17:16", "350000", "141096" ], + "141037" : [ "17:17", "350000", "141097" ], + "141038" : [ "17:18", "350000", "141098" ], + "141039" : [ "17:19", "350000", "141099" ], + "141040" : [ "17:20", "350000", "141100" ], + "141041" : [ "17:21", "350000", "141101" ], + "141042" : [ "17:22", "350000", "141102" ], + "141043" : [ "17:23", "350000", "141103" ], + "141044" : [ "17:24", "350000", "141104" ], + "141045" : [ "17:25", "350000", "141105" ], + "141046" : [ "17:26", "350000", "141106" ], + "141047" : [ "17:27", "350000", "141107" ], + "141048" : [ "17:28", "350000", "141108" ], + "141049" : [ "17:29", "350000", "141109" ], + "141050" : [ "17:30", "350000", "141110" ], + "141051" : [ "17:31", "350000", "141111" ], + "141052" : [ "17:32", "350000", "141112" ], + "141053" : [ "17:33", "350000", "141113" ], + "141054" : [ "17:34", "350000", "141114" ], + "141055" : [ "17:35", "350000", "141115" ], + "141056" : [ "17:36", "350000", "141116" ], + "141057" : [ "17:37", "350000", "141117" ], + "141058" : [ "17:38", "350000", "141118" ], + "141059" : [ "17:39", "350000", "141119" ], + "141060" : [ "17:40", "350000", "141120" ], + "141061" : [ "17:41", "350000", "141121" ], + "141062" : [ "17:42", "350000", "141122" ], + "141063" : [ "17:43", "350000", "141123" ], + "141064" : [ "17:44", "350000", "141124" ], + "141065" : [ "17:45", "350000", "141125" ], + "141066" : [ "17:46", "350000", "141126" ], + "141067" : [ "17:47", "350000", "141127" ], + "141068" : [ "17:48", "350000", "141128" ], + "141069" : [ "17:49", "350000", "141129" ], + "141070" : [ "17:50", "350000", "141130" ], + "141071" : [ "17:51", "350000", "141131" ], + "141072" : [ "17:52", "350000", "141132" ], + "141073" : [ "17:53", "350000", "141133" ], + "141074" : [ "17:54", "350000", "141134" ], + "141075" : [ "17:55", "350000", "141135" ], + "141076" : [ "17:56", "350000", "141136" ], + "141077" : [ "17:57", "350000", "141137" ], + "141078" : [ "17:58", "350000", "141138" ], + "141079" : [ "17:59", "350000", "141139" ], + "141080" : [ "18:00", "350000", "141140" ], + "141081" : [ "18:01", "350000", "141141" ], + "141082" : [ "18:02", "350000", "141142" ], + "141083" : [ "18:03", "350000", "141143" ], + "141084" : [ "18:04", "350000", "141144" ], + "141085" : [ "18:05", "350000", "141145" ], + "141086" : [ "18:06", "350000", "141146" ], + "141087" : [ "18:07", "350000", "141147" ], + "141088" : [ "18:08", "350000", "141148" ], + "141089" : [ "18:09", "350000", "141149" ], + "141090" : [ "18:10", "350000", "141150" ], + "141091" : [ "18:11", "350000", "141151" ], + "141092" : [ "18:12", "350000", "141152" ], + "141093" : [ "18:13", "350000", "141153" ], + "141094" : [ "18:14", "350000", "141154" ], + "141095" : [ "18:15", "350000", "141155" ], + "141096" : [ "18:16", "350000", "141156" ], + "141097" : [ "18:17", "350000", "141157" ], + "141098" : [ "18:18", "350000", "141158" ], + "141099" : [ "18:19", "350000", "141159" ], + "141100" : [ "18:20", "350000", "141160" ], + "141101" : [ "18:21", "350000", "141161" ], + "141102" : [ "18:22", "350000", "141162" ], + "141103" : [ "18:23", "350000", "141163" ], + "141104" : [ "18:24", "350000", "141164" ], + "141105" : [ "18:25", "350000", "141165" ], + "141106" : [ "18:26", "350000", "141166" ], + "141107" : [ "18:27", "350000", "141167" ], + "141108" : [ "18:28", "350000", "141168" ], + "141109" : [ "18:29", "350000", "141169" ], + "141110" : [ "18:30", "350000", "141170" ], + "141111" : [ "18:31", "350000", "141171" ], + "141112" : [ "18:32", "350000", "141172" ], + "141113" : [ "18:33", "350000", "141173" ], + "141114" : [ "18:34", "350000", "141174" ], + "141115" : [ "18:35", "350000", "141175" ], + "141116" : [ "18:36", "350000", "141176" ], + "141117" : [ "18:37", "350000", "141177" ], + "141118" : [ "18:38", "350000", "141178" ], + "141119" : [ "18:39", "350000", "141179" ], + "141120" : [ "18:40", "350000", "141180" ], + "141121" : [ "18:41", "350000", "141181" ], + "141122" : [ "18:42", "350000", "141182" ], + "141123" : [ "18:43", "350000", "141183" ], + "141124" : [ "18:44", "350000", "141184" ], + "141125" : [ "18:45", "350000", "141185" ], + "141126" : [ "18:46", "350000", "141186" ], + "141127" : [ "18:47", "350000", "141187" ], + "141128" : [ "18:48", "350000", "141188" ], + "141129" : [ "18:49", "350000", "141189" ], + "141130" : [ "18:50", "350000", "141190" ], + "141131" : [ "18:51", "350000", "141191" ], + "141132" : [ "18:52", "350000", "141192" ], + "141133" : [ "18:53", "350000", "141193" ], + "141134" : [ "18:54", "350000", "141194" ], + "141135" : [ "18:55", "350000", "141195" ], + "141136" : [ "18:56", "350000", "141196" ], + "141137" : [ "18:57", "350000", "141197" ], + "141138" : [ "18:58", "350000", "141198" ], + "141139" : [ "18:59", "350000", "141199" ], + "141140" : [ "19:00", "350000", "141200" ], + "141141" : [ "19:01", "350000", "141200" ], + "141142" : [ "19:02", "350000", "141200" ], + "141143" : [ "19:03", "350000", "141200" ], + "141144" : [ "19:04", "350000", "141200" ], + "141145" : [ "19:05", "350000", "141200" ], + "141146" : [ "19:06", "350000", "141200" ], + "141147" : [ "19:07", "350000", "141200" ], + "141148" : [ "19:08", "350000", "141200" ], + "141149" : [ "19:09", "350000", "141200" ], + "141150" : [ "19:10", "350000", "141200" ], + "141151" : [ "19:11", "350000", "141200" ], + "141152" : [ "19:12", "350000", "141200" ], + "141153" : [ "19:13", "350000", "141200" ], + "141154" : [ "19:14", "350000", "141200" ], + "141155" : [ "19:15", "350000", "141200" ], + "141156" : [ "19:16", "350000", "141200" ], + "141157" : [ "19:17", "350000", "141200" ], + "141158" : [ "19:18", "350000", "141200" ], + "141159" : [ "19:19", "350000", "141200" ], + "141160" : [ "19:20", "350000", "141200" ], + "141161" : [ "19:21", "350000", "141200" ], + "141162" : [ "19:22", "350000", "141200" ], + "141163" : [ "19:23", "350000", "141200" ], + "141164" : [ "19:24", "350000", "141200" ], + "141165" : [ "19:25", "350000", "141200" ], + "141166" : [ "19:26", "350000", "141200" ], + "141167" : [ "19:27", "350000", "141200" ], + "141168" : [ "19:28", "350000", "141200" ], + "141169" : [ "19:29", "350000", "141200" ], + "141170" : [ "19:30", "350000", "141200" ], + "141171" : [ "19:31", "350000", "141200" ], + "141172" : [ "19:32", "350000", "141200" ], + "141173" : [ "19:33", "350000", "141200" ], + "141174" : [ "19:34", "350000", "141200" ], + "141175" : [ "19:35", "350000", "141200" ], + "141176" : [ "19:36", "350000", "141200" ], + "141177" : [ "19:37", "350000", "141200" ], + "141178" : [ "19:38", "350000", "141200" ], + "141179" : [ "19:39", "350000", "141200" ], + "141180" : [ "19:40", "350000", "141200" ], + "141181" : [ "19:41", "350000", "141200" ], + "141182" : [ "19:42", "350000", "141200" ], + "141183" : [ "19:43", "350000", "141200" ], + "141184" : [ "19:44", "350000", "141200" ], + "141185" : [ "19:45", "350000", "141200" ], + "141186" : [ "19:46", "350000", "141200" ], + "141187" : [ "19:47", "350000", "141200" ], + "141188" : [ "19:48", "350000", "141200" ], + "141189" : [ "19:49", "350000", "141200" ], + "141190" : [ "19:50", "350000", "141200" ], + "141191" : [ "19:51", "350000", "141200" ], + "141192" : [ "19:52", "350000", "141200" ], + "141193" : [ "19:53", "350000", "141200" ], + "141194" : [ "19:54", "350000", "141200" ], + "141195" : [ "19:55", "350000", "141200" ], + "141196" : [ "19:56", "350000", "141200" ], + "141197" : [ "19:57", "350000", "141200" ], + "141198" : [ "19:58", "350000", "141200" ], + "141199" : [ "19:59", "350000", "141200" ], + "141200" : [ "20:00", "800000", "150420" ], + "141201" : [ "20:01", "800000", "150420" ], + "141202" : [ "20:02", "800000", "150420" ], + "141203" : [ "20:03", "800000", "150420" ], + "141204" : [ "20:04", "800000", "150420" ], + "141205" : [ "20:05", "800000", "150420" ], + "141206" : [ "20:06", "800000", "150420" ], + "141207" : [ "20:07", "800000", "150420" ], + "141208" : [ "20:08", "800000", "150420" ], + "141209" : [ "20:09", "800000", "150420" ], + "141210" : [ "20:10", "800000", "150420" ], + "141211" : [ "20:11", "800000", "150420" ], + "141212" : [ "20:12", "800000", "150420" ], + "141213" : [ "20:13", "800000", "150420" ], + "141214" : [ "20:14", "800000", "150420" ], + "141215" : [ "20:15", "800000", "150420" ], + "141216" : [ "20:16", "800000", "150420" ], + "141217" : [ "20:17", "800000", "150420" ], + "141218" : [ "20:18", "800000", "150420" ], + "141219" : [ "20:19", "800000", "150420" ], + "141220" : [ "20:20", "800000", "150420" ], + "141221" : [ "20:21", "800000", "150420" ], + "141222" : [ "20:22", "800000", "150420" ], + "141223" : [ "20:23", "800000", "150420" ], + "141224" : [ "20:24", "800000", "150420" ], + "141225" : [ "20:25", "800000", "150420" ], + "141226" : [ "20:26", "800000", "150420" ], + "141227" : [ "20:27", "800000", "150420" ], + "141228" : [ "20:28", "800000", "150420" ], + "141229" : [ "20:29", "800000", "150420" ], + "141230" : [ "20:30", "800000", "150420" ], + "141231" : [ "20:31", "800000", "150420" ], + "141232" : [ "20:32", "800000", "150420" ], + "141233" : [ "20:33", "800000", "150420" ], + "141234" : [ "20:34", "800000", "150420" ], + "141235" : [ "20:35", "800000", "150420" ], + "141236" : [ "20:36", "800000", "150420" ], + "141237" : [ "20:37", "800000", "150420" ], + "141238" : [ "20:38", "800000", "150420" ], + "141239" : [ "20:39", "800000", "150420" ], + "141240" : [ "20:40", "800000", "150420" ], + "141241" : [ "20:41", "800000", "150420" ], + "141242" : [ "20:42", "800000", "150420" ], + "141243" : [ "20:43", "800000", "150420" ], + "141244" : [ "20:44", "800000", "150420" ], + "141245" : [ "20:45", "800000", "150420" ], + "141246" : [ "20:46", "800000", "150420" ], + "141247" : [ "20:47", "800000", "150420" ], + "141248" : [ "20:48", "800000", "150420" ], + "141249" : [ "20:49", "800000", "150420" ], + "141250" : [ "20:50", "800000", "150420" ], + "141251" : [ "20:51", "800000", "150420" ], + "141252" : [ "20:52", "800000", "150420" ], + "141253" : [ "20:53", "800000", "150420" ], + "141254" : [ "20:54", "800000", "150420" ], + "141255" : [ "20:55", "800000", "150420" ], + "141256" : [ "20:56", "800000", "150420" ], + "141257" : [ "20:57", "800000", "150420" ], + "141258" : [ "20:58", "800000", "150420" ], + "141259" : [ "20:59", "800000", "150420" ], + "141260" : [ "21:00", "800000", "150420" ], + "141261" : [ "21:01", "800000", "150420" ], + "141262" : [ "21:02", "800000", "150420" ], + "141263" : [ "21:03", "800000", "150420" ], + "141264" : [ "21:04", "800000", "150420" ], + "141265" : [ "21:05", "800000", "150420" ], + "141266" : [ "21:06", "800000", "150420" ], + "141267" : [ "21:07", "800000", "150420" ], + "141268" : [ "21:08", "800000", "150420" ], + "141269" : [ "21:09", "800000", "150420" ], + "141270" : [ "21:10", "800000", "150420" ], + "141271" : [ "21:11", "800000", "150420" ], + "141272" : [ "21:12", "800000", "150420" ], + "141273" : [ "21:13", "800000", "150420" ], + "141274" : [ "21:14", "800000", "150420" ], + "141275" : [ "21:15", "800000", "150420" ], + "141276" : [ "21:16", "800000", "150420" ], + "141277" : [ "21:17", "800000", "150420" ], + "141278" : [ "21:18", "800000", "150420" ], + "141279" : [ "21:19", "800000", "150420" ], + "141280" : [ "21:20", "800000", "150420" ], + "141281" : [ "21:21", "800000", "150420" ], + "141282" : [ "21:22", "800000", "150420" ], + "141283" : [ "21:23", "800000", "150420" ], + "141284" : [ "21:24", "800000", "150420" ], + "141285" : [ "21:25", "800000", "150420" ], + "141286" : [ "21:26", "800000", "150420" ], + "141287" : [ "21:27", "800000", "150420" ], + "141288" : [ "21:28", "800000", "150420" ], + "141289" : [ "21:29", "800000", "150420" ], + "141290" : [ "21:30", "800000", "150420" ], + "141291" : [ "21:31", "800000", "150420" ], + "141292" : [ "21:32", "800000", "150420" ], + "141293" : [ "21:33", "800000", "150420" ], + "141294" : [ "21:34", "800000", "150420" ], + "141295" : [ "21:35", "800000", "150420" ], + "141296" : [ "21:36", "800000", "150420" ], + "141297" : [ "21:37", "800000", "150420" ], + "141298" : [ "21:38", "800000", "150420" ], + "141299" : [ "21:39", "800000", "150420" ], + "141300" : [ "21:40", "800000", "150420" ], + "141301" : [ "21:41", "800000", "150420" ], + "141302" : [ "21:42", "800000", "150420" ], + "141303" : [ "21:43", "800000", "150420" ], + "141304" : [ "21:44", "800000", "150420" ], + "141305" : [ "21:45", "800000", "150420" ], + "141306" : [ "21:46", "800000", "150420" ], + "141307" : [ "21:47", "800000", "150420" ], + "141308" : [ "21:48", "800000", "150420" ], + "141309" : [ "21:49", "800000", "150420" ], + "141310" : [ "21:50", "800000", "150420" ], + "141311" : [ "21:51", "800000", "150420" ], + "141312" : [ "21:52", "800000", "150420" ], + "141313" : [ "21:53", "800000", "150420" ], + "141314" : [ "21:54", "800000", "150420" ], + "141315" : [ "21:55", "800000", "150420" ], + "141316" : [ "21:56", "800000", "150420" ], + "141317" : [ "21:57", "800000", "150420" ], + "141318" : [ "21:58", "800000", "150420" ], + "141319" : [ "21:59", "800000", "150420" ], + "141320" : [ "22:00", "800000", "150420" ], + "141321" : [ "22:01", "800000", "150420" ], + "141322" : [ "22:02", "800000", "150420" ], + "141323" : [ "22:03", "800000", "150420" ], + "141324" : [ "22:04", "800000", "150420" ], + "141325" : [ "22:05", "800000", "150420" ], + "141326" : [ "22:06", "800000", "150420" ], + "141327" : [ "22:07", "800000", "150420" ], + "141328" : [ "22:08", "800000", "150420" ], + "141329" : [ "22:09", "800000", "150420" ], + "141330" : [ "22:10", "800000", "150420" ], + "141331" : [ "22:11", "800000", "150420" ], + "141332" : [ "22:12", "800000", "150420" ], + "141333" : [ "22:13", "800000", "150420" ], + "141334" : [ "22:14", "800000", "150420" ], + "141335" : [ "22:15", "800000", "150420" ], + "141336" : [ "22:16", "800000", "150420" ], + "141337" : [ "22:17", "800000", "150420" ], + "141338" : [ "22:18", "800000", "150420" ], + "141339" : [ "22:19", "800000", "150420" ], + "141340" : [ "22:20", "800000", "150420" ], + "141341" : [ "22:21", "800000", "150420" ], + "141342" : [ "22:22", "800000", "150420" ], + "141343" : [ "22:23", "800000", "150420" ], + "141344" : [ "22:24", "800000", "150420" ], + "141345" : [ "22:25", "800000", "150420" ], + "141346" : [ "22:26", "800000", "150420" ], + "141347" : [ "22:27", "800000", "150420" ], + "141348" : [ "22:28", "800000", "150420" ], + "141349" : [ "22:29", "800000", "150420" ], + "141350" : [ "22:30", "800000", "150420" ], + "141351" : [ "22:31", "800000", "150420" ], + "141352" : [ "22:32", "800000", "150420" ], + "141353" : [ "22:33", "800000", "150420" ], + "141354" : [ "22:34", "800000", "150420" ], + "141355" : [ "22:35", "800000", "150420" ], + "141356" : [ "22:36", "800000", "150420" ], + "141357" : [ "22:37", "800000", "150420" ], + "141358" : [ "22:38", "800000", "150420" ], + "141359" : [ "22:39", "800000", "150420" ], + "141360" : [ "22:40", "800000", "150420" ], + "141361" : [ "22:41", "800000", "150420" ], + "141362" : [ "22:42", "800000", "150420" ], + "141363" : [ "22:43", "800000", "150420" ], + "141364" : [ "22:44", "800000", "150420" ], + "141365" : [ "22:45", "800000", "150420" ], + "141366" : [ "22:46", "800000", "150420" ], + "141367" : [ "22:47", "800000", "150420" ], + "141368" : [ "22:48", "800000", "150420" ], + "141369" : [ "22:49", "800000", "150420" ], + "141370" : [ "22:50", "800000", "150420" ], + "141371" : [ "22:51", "800000", "150420" ], + "141372" : [ "22:52", "800000", "150420" ], + "141373" : [ "22:53", "800000", "150420" ], + "141374" : [ "22:54", "800000", "150420" ], + "141375" : [ "22:55", "800000", "150420" ], + "141376" : [ "22:56", "800000", "150420" ], + "141377" : [ "22:57", "800000", "150420" ], + "141378" : [ "22:58", "800000", "150420" ], + "141379" : [ "22:59", "800000", "150420" ], + "141380" : [ "23:00", "800000", "150420" ], + "141381" : [ "23:01", "800000", "150420" ], + "141382" : [ "23:02", "800000", "150420" ], + "141383" : [ "23:03", "800000", "150420" ], + "141384" : [ "23:04", "800000", "150420" ], + "141385" : [ "23:05", "800000", "150420" ], + "141386" : [ "23:06", "800000", "150420" ], + "141387" : [ "23:07", "800000", "150420" ], + "141388" : [ "23:08", "800000", "150420" ], + "141389" : [ "23:09", "800000", "150420" ], + "141390" : [ "23:10", "800000", "150420" ], + "141391" : [ "23:11", "800000", "150420" ], + "141392" : [ "23:12", "800000", "150420" ], + "141393" : [ "23:13", "800000", "150420" ], + "141394" : [ "23:14", "800000", "150420" ], + "141395" : [ "23:15", "800000", "150420" ], + "141396" : [ "23:16", "800000", "150420" ], + "141397" : [ "23:17", "800000", "150420" ], + "141398" : [ "23:18", "800000", "150420" ], + "141399" : [ "23:19", "800000", "150420" ], + "141400" : [ "23:20", "800000", "150420" ], + "141401" : [ "23:21", "800000", "150420" ], + "141402" : [ "23:22", "800000", "150420" ], + "141403" : [ "23:23", "800000", "150420" ], + "141404" : [ "23:24", "800000", "150420" ], + "141405" : [ "23:25", "800000", "150420" ], + "141406" : [ "23:26", "800000", "150420" ], + "141407" : [ "23:27", "800000", "150420" ], + "141408" : [ "23:28", "800000", "150420" ], + "141409" : [ "23:29", "800000", "150420" ], + "141410" : [ "23:30", "800000", "150420" ], + "141411" : [ "23:31", "800000", "150420" ], + "141412" : [ "23:32", "800000", "150420" ], + "141413" : [ "23:33", "800000", "150420" ], + "141414" : [ "23:34", "800000", "150420" ], + "141415" : [ "23:35", "800000", "150420" ], + "141416" : [ "23:36", "800000", "150420" ], + "141417" : [ "23:37", "800000", "150420" ], + "141418" : [ "23:38", "800000", "150420" ], + "141419" : [ "23:39", "800000", "150420" ], + "141420" : [ "23:40", "800000", "150420" ], + "141421" : [ "23:41", "800000", "150420" ], + "141422" : [ "23:42", "800000", "150420" ], + "141423" : [ "23:43", "800000", "150420" ], + "141424" : [ "23:44", "800000", "150420" ], + "141425" : [ "23:45", "800000", "150420" ], + "141426" : [ "23:46", "800000", "150420" ], + "141427" : [ "23:47", "800000", "150420" ], + "141428" : [ "23:48", "800000", "150420" ], + "141429" : [ "23:49", "800000", "150420" ], + "141430" : [ "23:50", "800000", "150420" ], + "141431" : [ "23:51", "800000", "150420" ], + "141432" : [ "23:52", "800000", "150420" ], + "141433" : [ "23:53", "800000", "150420" ], + "141434" : [ "23:54", "800000", "150420" ], + "141435" : [ "23:55", "800000", "150420" ], + "141436" : [ "23:56", "800000", "150420" ], + "141437" : [ "23:57", "800000", "150420" ], + "141438" : [ "23:58", "800000", "150420" ], + "141439" : [ "23:59", "800000", "150420" ] + }, + "Saturday": { + "150000" : [ "00:00", "800000", "150420" ], + "150001" : [ "00:01", "800000", "150420" ], + "150002" : [ "00:02", "800000", "150420" ], + "150003" : [ "00:03", "800000", "150420" ], + "150004" : [ "00:04", "800000", "150420" ], + "150005" : [ "00:05", "800000", "150420" ], + "150006" : [ "00:06", "800000", "150420" ], + "150007" : [ "00:07", "800000", "150420" ], + "150008" : [ "00:08", "800000", "150420" ], + "150009" : [ "00:09", "800000", "150420" ], + "150010" : [ "00:10", "800000", "150420" ], + "150011" : [ "00:11", "800000", "150420" ], + "150012" : [ "00:12", "800000", "150420" ], + "150013" : [ "00:13", "800000", "150420" ], + "150014" : [ "00:14", "800000", "150420" ], + "150015" : [ "00:15", "800000", "150420" ], + "150016" : [ "00:16", "800000", "150420" ], + "150017" : [ "00:17", "800000", "150420" ], + "150018" : [ "00:18", "800000", "150420" ], + "150019" : [ "00:19", "800000", "150420" ], + "150020" : [ "00:20", "800000", "150420" ], + "150021" : [ "00:21", "800000", "150420" ], + "150022" : [ "00:22", "800000", "150420" ], + "150023" : [ "00:23", "800000", "150420" ], + "150024" : [ "00:24", "800000", "150420" ], + "150025" : [ "00:25", "800000", "150420" ], + "150026" : [ "00:26", "800000", "150420" ], + "150027" : [ "00:27", "800000", "150420" ], + "150028" : [ "00:28", "800000", "150420" ], + "150029" : [ "00:29", "800000", "150420" ], + "150030" : [ "00:30", "800000", "150420" ], + "150031" : [ "00:31", "800000", "150420" ], + "150032" : [ "00:32", "800000", "150420" ], + "150033" : [ "00:33", "800000", "150420" ], + "150034" : [ "00:34", "800000", "150420" ], + "150035" : [ "00:35", "800000", "150420" ], + "150036" : [ "00:36", "800000", "150420" ], + "150037" : [ "00:37", "800000", "150420" ], + "150038" : [ "00:38", "800000", "150420" ], + "150039" : [ "00:39", "800000", "150420" ], + "150040" : [ "00:40", "800000", "150420" ], + "150041" : [ "00:41", "800000", "150420" ], + "150042" : [ "00:42", "800000", "150420" ], + "150043" : [ "00:43", "800000", "150420" ], + "150044" : [ "00:44", "800000", "150420" ], + "150045" : [ "00:45", "800000", "150420" ], + "150046" : [ "00:46", "800000", "150420" ], + "150047" : [ "00:47", "800000", "150420" ], + "150048" : [ "00:48", "800000", "150420" ], + "150049" : [ "00:49", "800000", "150420" ], + "150050" : [ "00:50", "800000", "150420" ], + "150051" : [ "00:51", "800000", "150420" ], + "150052" : [ "00:52", "800000", "150420" ], + "150053" : [ "00:53", "800000", "150420" ], + "150054" : [ "00:54", "800000", "150420" ], + "150055" : [ "00:55", "800000", "150420" ], + "150056" : [ "00:56", "800000", "150420" ], + "150057" : [ "00:57", "800000", "150420" ], + "150058" : [ "00:58", "800000", "150420" ], + "150059" : [ "00:59", "800000", "150420" ], + "150060" : [ "01:00", "800000", "150420" ], + "150061" : [ "01:01", "800000", "150420" ], + "150062" : [ "01:02", "800000", "150420" ], + "150063" : [ "01:03", "800000", "150420" ], + "150064" : [ "01:04", "800000", "150420" ], + "150065" : [ "01:05", "800000", "150420" ], + "150066" : [ "01:06", "800000", "150420" ], + "150067" : [ "01:07", "800000", "150420" ], + "150068" : [ "01:08", "800000", "150420" ], + "150069" : [ "01:09", "800000", "150420" ], + "150070" : [ "01:10", "800000", "150420" ], + "150071" : [ "01:11", "800000", "150420" ], + "150072" : [ "01:12", "800000", "150420" ], + "150073" : [ "01:13", "800000", "150420" ], + "150074" : [ "01:14", "800000", "150420" ], + "150075" : [ "01:15", "800000", "150420" ], + "150076" : [ "01:16", "800000", "150420" ], + "150077" : [ "01:17", "800000", "150420" ], + "150078" : [ "01:18", "800000", "150420" ], + "150079" : [ "01:19", "800000", "150420" ], + "150080" : [ "01:20", "800000", "150420" ], + "150081" : [ "01:21", "800000", "150420" ], + "150082" : [ "01:22", "800000", "150420" ], + "150083" : [ "01:23", "800000", "150420" ], + "150084" : [ "01:24", "800000", "150420" ], + "150085" : [ "01:25", "800000", "150420" ], + "150086" : [ "01:26", "800000", "150420" ], + "150087" : [ "01:27", "800000", "150420" ], + "150088" : [ "01:28", "800000", "150420" ], + "150089" : [ "01:29", "800000", "150420" ], + "150090" : [ "01:30", "800000", "150420" ], + "150091" : [ "01:31", "800000", "150420" ], + "150092" : [ "01:32", "800000", "150420" ], + "150093" : [ "01:33", "800000", "150420" ], + "150094" : [ "01:34", "800000", "150420" ], + "150095" : [ "01:35", "800000", "150420" ], + "150096" : [ "01:36", "800000", "150420" ], + "150097" : [ "01:37", "800000", "150420" ], + "150098" : [ "01:38", "800000", "150420" ], + "150099" : [ "01:39", "800000", "150420" ], + "150100" : [ "01:40", "800000", "150420" ], + "150101" : [ "01:41", "800000", "150420" ], + "150102" : [ "01:42", "800000", "150420" ], + "150103" : [ "01:43", "800000", "150420" ], + "150104" : [ "01:44", "800000", "150420" ], + "150105" : [ "01:45", "800000", "150420" ], + "150106" : [ "01:46", "800000", "150420" ], + "150107" : [ "01:47", "800000", "150420" ], + "150108" : [ "01:48", "800000", "150420" ], + "150109" : [ "01:49", "800000", "150420" ], + "150110" : [ "01:50", "800000", "150420" ], + "150111" : [ "01:51", "800000", "150420" ], + "150112" : [ "01:52", "800000", "150420" ], + "150113" : [ "01:53", "800000", "150420" ], + "150114" : [ "01:54", "800000", "150420" ], + "150115" : [ "01:55", "800000", "150420" ], + "150116" : [ "01:56", "800000", "150420" ], + "150117" : [ "01:57", "800000", "150420" ], + "150118" : [ "01:58", "800000", "150420" ], + "150119" : [ "01:59", "800000", "150420" ], + "150120" : [ "02:00", "800000", "150420" ], + "150121" : [ "02:01", "800000", "150420" ], + "150122" : [ "02:02", "800000", "150420" ], + "150123" : [ "02:03", "800000", "150420" ], + "150124" : [ "02:04", "800000", "150420" ], + "150125" : [ "02:05", "800000", "150420" ], + "150126" : [ "02:06", "800000", "150420" ], + "150127" : [ "02:07", "800000", "150420" ], + "150128" : [ "02:08", "800000", "150420" ], + "150129" : [ "02:09", "800000", "150420" ], + "150130" : [ "02:10", "800000", "150420" ], + "150131" : [ "02:11", "800000", "150420" ], + "150132" : [ "02:12", "800000", "150420" ], + "150133" : [ "02:13", "800000", "150420" ], + "150134" : [ "02:14", "800000", "150420" ], + "150135" : [ "02:15", "800000", "150420" ], + "150136" : [ "02:16", "800000", "150420" ], + "150137" : [ "02:17", "800000", "150420" ], + "150138" : [ "02:18", "800000", "150420" ], + "150139" : [ "02:19", "800000", "150420" ], + "150140" : [ "02:20", "800000", "150420" ], + "150141" : [ "02:21", "800000", "150420" ], + "150142" : [ "02:22", "800000", "150420" ], + "150143" : [ "02:23", "800000", "150420" ], + "150144" : [ "02:24", "800000", "150420" ], + "150145" : [ "02:25", "800000", "150420" ], + "150146" : [ "02:26", "800000", "150420" ], + "150147" : [ "02:27", "800000", "150420" ], + "150148" : [ "02:28", "800000", "150420" ], + "150149" : [ "02:29", "800000", "150420" ], + "150150" : [ "02:30", "800000", "150420" ], + "150151" : [ "02:31", "800000", "150420" ], + "150152" : [ "02:32", "800000", "150420" ], + "150153" : [ "02:33", "800000", "150420" ], + "150154" : [ "02:34", "800000", "150420" ], + "150155" : [ "02:35", "800000", "150420" ], + "150156" : [ "02:36", "800000", "150420" ], + "150157" : [ "02:37", "800000", "150420" ], + "150158" : [ "02:38", "800000", "150420" ], + "150159" : [ "02:39", "800000", "150420" ], + "150160" : [ "02:40", "800000", "150420" ], + "150161" : [ "02:41", "800000", "150420" ], + "150162" : [ "02:42", "800000", "150420" ], + "150163" : [ "02:43", "800000", "150420" ], + "150164" : [ "02:44", "800000", "150420" ], + "150165" : [ "02:45", "800000", "150420" ], + "150166" : [ "02:46", "800000", "150420" ], + "150167" : [ "02:47", "800000", "150420" ], + "150168" : [ "02:48", "800000", "150420" ], + "150169" : [ "02:49", "800000", "150420" ], + "150170" : [ "02:50", "800000", "150420" ], + "150171" : [ "02:51", "800000", "150420" ], + "150172" : [ "02:52", "800000", "150420" ], + "150173" : [ "02:53", "800000", "150420" ], + "150174" : [ "02:54", "800000", "150420" ], + "150175" : [ "02:55", "800000", "150420" ], + "150176" : [ "02:56", "800000", "150420" ], + "150177" : [ "02:57", "800000", "150420" ], + "150178" : [ "02:58", "800000", "150420" ], + "150179" : [ "02:59", "800000", "150420" ], + "150180" : [ "03:00", "800000", "150420" ], + "150181" : [ "03:01", "800000", "150420" ], + "150182" : [ "03:02", "800000", "150420" ], + "150183" : [ "03:03", "800000", "150420" ], + "150184" : [ "03:04", "800000", "150420" ], + "150185" : [ "03:05", "800000", "150420" ], + "150186" : [ "03:06", "800000", "150420" ], + "150187" : [ "03:07", "800000", "150420" ], + "150188" : [ "03:08", "800000", "150420" ], + "150189" : [ "03:09", "800000", "150420" ], + "150190" : [ "03:10", "800000", "150420" ], + "150191" : [ "03:11", "800000", "150420" ], + "150192" : [ "03:12", "800000", "150420" ], + "150193" : [ "03:13", "800000", "150420" ], + "150194" : [ "03:14", "800000", "150420" ], + "150195" : [ "03:15", "800000", "150420" ], + "150196" : [ "03:16", "800000", "150420" ], + "150197" : [ "03:17", "800000", "150420" ], + "150198" : [ "03:18", "800000", "150420" ], + "150199" : [ "03:19", "800000", "150420" ], + "150200" : [ "03:20", "800000", "150420" ], + "150201" : [ "03:21", "800000", "150420" ], + "150202" : [ "03:22", "800000", "150420" ], + "150203" : [ "03:23", "800000", "150420" ], + "150204" : [ "03:24", "800000", "150420" ], + "150205" : [ "03:25", "800000", "150420" ], + "150206" : [ "03:26", "800000", "150420" ], + "150207" : [ "03:27", "800000", "150420" ], + "150208" : [ "03:28", "800000", "150420" ], + "150209" : [ "03:29", "800000", "150420" ], + "150210" : [ "03:30", "800000", "150420" ], + "150211" : [ "03:31", "800000", "150420" ], + "150212" : [ "03:32", "800000", "150420" ], + "150213" : [ "03:33", "800000", "150420" ], + "150214" : [ "03:34", "800000", "150420" ], + "150215" : [ "03:35", "800000", "150420" ], + "150216" : [ "03:36", "800000", "150420" ], + "150217" : [ "03:37", "800000", "150420" ], + "150218" : [ "03:38", "800000", "150420" ], + "150219" : [ "03:39", "800000", "150420" ], + "150220" : [ "03:40", "800000", "150420" ], + "150221" : [ "03:41", "800000", "150420" ], + "150222" : [ "03:42", "800000", "150420" ], + "150223" : [ "03:43", "800000", "150420" ], + "150224" : [ "03:44", "800000", "150420" ], + "150225" : [ "03:45", "800000", "150420" ], + "150226" : [ "03:46", "800000", "150420" ], + "150227" : [ "03:47", "800000", "150420" ], + "150228" : [ "03:48", "800000", "150420" ], + "150229" : [ "03:49", "800000", "150420" ], + "150230" : [ "03:50", "800000", "150420" ], + "150231" : [ "03:51", "800000", "150420" ], + "150232" : [ "03:52", "800000", "150420" ], + "150233" : [ "03:53", "800000", "150420" ], + "150234" : [ "03:54", "800000", "150420" ], + "150235" : [ "03:55", "800000", "150420" ], + "150236" : [ "03:56", "800000", "150420" ], + "150237" : [ "03:57", "800000", "150420" ], + "150238" : [ "03:58", "800000", "150420" ], + "150239" : [ "03:59", "800000", "150420" ], + "150240" : [ "04:00", "800000", "150420" ], + "150241" : [ "04:01", "800000", "150420" ], + "150242" : [ "04:02", "800000", "150420" ], + "150243" : [ "04:03", "800000", "150420" ], + "150244" : [ "04:04", "800000", "150420" ], + "150245" : [ "04:05", "800000", "150420" ], + "150246" : [ "04:06", "800000", "150420" ], + "150247" : [ "04:07", "800000", "150420" ], + "150248" : [ "04:08", "800000", "150420" ], + "150249" : [ "04:09", "800000", "150420" ], + "150250" : [ "04:10", "800000", "150420" ], + "150251" : [ "04:11", "800000", "150420" ], + "150252" : [ "04:12", "800000", "150420" ], + "150253" : [ "04:13", "800000", "150420" ], + "150254" : [ "04:14", "800000", "150420" ], + "150255" : [ "04:15", "800000", "150420" ], + "150256" : [ "04:16", "800000", "150420" ], + "150257" : [ "04:17", "800000", "150420" ], + "150258" : [ "04:18", "800000", "150420" ], + "150259" : [ "04:19", "800000", "150420" ], + "150260" : [ "04:20", "800000", "150420" ], + "150261" : [ "04:21", "800000", "150420" ], + "150262" : [ "04:22", "800000", "150420" ], + "150263" : [ "04:23", "800000", "150420" ], + "150264" : [ "04:24", "800000", "150420" ], + "150265" : [ "04:25", "800000", "150420" ], + "150266" : [ "04:26", "800000", "150420" ], + "150267" : [ "04:27", "800000", "150420" ], + "150268" : [ "04:28", "800000", "150420" ], + "150269" : [ "04:29", "800000", "150420" ], + "150270" : [ "04:30", "800000", "150420" ], + "150271" : [ "04:31", "800000", "150420" ], + "150272" : [ "04:32", "800000", "150420" ], + "150273" : [ "04:33", "800000", "150420" ], + "150274" : [ "04:34", "800000", "150420" ], + "150275" : [ "04:35", "800000", "150420" ], + "150276" : [ "04:36", "800000", "150420" ], + "150277" : [ "04:37", "800000", "150420" ], + "150278" : [ "04:38", "800000", "150420" ], + "150279" : [ "04:39", "800000", "150420" ], + "150280" : [ "04:40", "800000", "150420" ], + "150281" : [ "04:41", "800000", "150420" ], + "150282" : [ "04:42", "800000", "150420" ], + "150283" : [ "04:43", "800000", "150420" ], + "150284" : [ "04:44", "800000", "150420" ], + "150285" : [ "04:45", "800000", "150420" ], + "150286" : [ "04:46", "800000", "150420" ], + "150287" : [ "04:47", "800000", "150420" ], + "150288" : [ "04:48", "800000", "150420" ], + "150289" : [ "04:49", "800000", "150420" ], + "150290" : [ "04:50", "800000", "150420" ], + "150291" : [ "04:51", "800000", "150420" ], + "150292" : [ "04:52", "800000", "150420" ], + "150293" : [ "04:53", "800000", "150420" ], + "150294" : [ "04:54", "800000", "150420" ], + "150295" : [ "04:55", "800000", "150420" ], + "150296" : [ "04:56", "800000", "150420" ], + "150297" : [ "04:57", "800000", "150420" ], + "150298" : [ "04:58", "800000", "150420" ], + "150299" : [ "04:59", "800000", "150420" ], + "150300" : [ "05:00", "800000", "150420" ], + "150301" : [ "05:01", "800000", "150420" ], + "150302" : [ "05:02", "800000", "150420" ], + "150303" : [ "05:03", "800000", "150420" ], + "150304" : [ "05:04", "800000", "150420" ], + "150305" : [ "05:05", "800000", "150420" ], + "150306" : [ "05:06", "800000", "150420" ], + "150307" : [ "05:07", "800000", "150420" ], + "150308" : [ "05:08", "800000", "150420" ], + "150309" : [ "05:09", "800000", "150420" ], + "150310" : [ "05:10", "800000", "150420" ], + "150311" : [ "05:11", "800000", "150420" ], + "150312" : [ "05:12", "800000", "150420" ], + "150313" : [ "05:13", "800000", "150420" ], + "150314" : [ "05:14", "800000", "150420" ], + "150315" : [ "05:15", "800000", "150420" ], + "150316" : [ "05:16", "800000", "150420" ], + "150317" : [ "05:17", "800000", "150420" ], + "150318" : [ "05:18", "800000", "150420" ], + "150319" : [ "05:19", "800000", "150420" ], + "150320" : [ "05:20", "800000", "150420" ], + "150321" : [ "05:21", "800000", "150420" ], + "150322" : [ "05:22", "800000", "150420" ], + "150323" : [ "05:23", "800000", "150420" ], + "150324" : [ "05:24", "800000", "150420" ], + "150325" : [ "05:25", "800000", "150420" ], + "150326" : [ "05:26", "800000", "150420" ], + "150327" : [ "05:27", "800000", "150420" ], + "150328" : [ "05:28", "800000", "150420" ], + "150329" : [ "05:29", "800000", "150420" ], + "150330" : [ "05:30", "800000", "150420" ], + "150331" : [ "05:31", "800000", "150420" ], + "150332" : [ "05:32", "800000", "150420" ], + "150333" : [ "05:33", "800000", "150420" ], + "150334" : [ "05:34", "800000", "150420" ], + "150335" : [ "05:35", "800000", "150420" ], + "150336" : [ "05:36", "800000", "150420" ], + "150337" : [ "05:37", "800000", "150420" ], + "150338" : [ "05:38", "800000", "150420" ], + "150339" : [ "05:39", "800000", "150420" ], + "150340" : [ "05:40", "800000", "150420" ], + "150341" : [ "05:41", "800000", "150420" ], + "150342" : [ "05:42", "800000", "150420" ], + "150343" : [ "05:43", "800000", "150420" ], + "150344" : [ "05:44", "800000", "150420" ], + "150345" : [ "05:45", "800000", "150420" ], + "150346" : [ "05:46", "800000", "150420" ], + "150347" : [ "05:47", "800000", "150420" ], + "150348" : [ "05:48", "800000", "150420" ], + "150349" : [ "05:49", "800000", "150420" ], + "150350" : [ "05:50", "800000", "150420" ], + "150351" : [ "05:51", "800000", "150420" ], + "150352" : [ "05:52", "800000", "150420" ], + "150353" : [ "05:53", "800000", "150420" ], + "150354" : [ "05:54", "800000", "150420" ], + "150355" : [ "05:55", "800000", "150420" ], + "150356" : [ "05:56", "800000", "150420" ], + "150357" : [ "05:57", "800000", "150420" ], + "150358" : [ "05:58", "800000", "150420" ], + "150359" : [ "05:59", "800000", "150420" ], + "150360" : [ "06:00", "800000", "150420" ], + "150361" : [ "06:01", "800000", "150420" ], + "150362" : [ "06:02", "800000", "150420" ], + "150363" : [ "06:03", "800000", "150420" ], + "150364" : [ "06:04", "800000", "150420" ], + "150365" : [ "06:05", "800000", "150420" ], + "150366" : [ "06:06", "800000", "150420" ], + "150367" : [ "06:07", "800000", "150420" ], + "150368" : [ "06:08", "800000", "150420" ], + "150369" : [ "06:09", "800000", "150420" ], + "150370" : [ "06:10", "800000", "150420" ], + "150371" : [ "06:11", "800000", "150420" ], + "150372" : [ "06:12", "800000", "150420" ], + "150373" : [ "06:13", "800000", "150420" ], + "150374" : [ "06:14", "800000", "150420" ], + "150375" : [ "06:15", "800000", "150420" ], + "150376" : [ "06:16", "800000", "150420" ], + "150377" : [ "06:17", "800000", "150420" ], + "150378" : [ "06:18", "800000", "150420" ], + "150379" : [ "06:19", "800000", "150420" ], + "150380" : [ "06:20", "800000", "150420" ], + "150381" : [ "06:21", "800000", "150420" ], + "150382" : [ "06:22", "800000", "150420" ], + "150383" : [ "06:23", "800000", "150420" ], + "150384" : [ "06:24", "800000", "150420" ], + "150385" : [ "06:25", "800000", "150420" ], + "150386" : [ "06:26", "800000", "150420" ], + "150387" : [ "06:27", "800000", "150420" ], + "150388" : [ "06:28", "800000", "150420" ], + "150389" : [ "06:29", "800000", "150420" ], + "150390" : [ "06:30", "800000", "150420" ], + "150391" : [ "06:31", "800000", "150420" ], + "150392" : [ "06:32", "800000", "150420" ], + "150393" : [ "06:33", "800000", "150420" ], + "150394" : [ "06:34", "800000", "150420" ], + "150395" : [ "06:35", "800000", "150420" ], + "150396" : [ "06:36", "800000", "150420" ], + "150397" : [ "06:37", "800000", "150420" ], + "150398" : [ "06:38", "800000", "150420" ], + "150399" : [ "06:39", "800000", "150420" ], + "150400" : [ "06:40", "800000", "150420" ], + "150401" : [ "06:41", "800000", "150420" ], + "150402" : [ "06:42", "800000", "150420" ], + "150403" : [ "06:43", "800000", "150420" ], + "150404" : [ "06:44", "800000", "150420" ], + "150405" : [ "06:45", "800000", "150420" ], + "150406" : [ "06:46", "800000", "150420" ], + "150407" : [ "06:47", "800000", "150420" ], + "150408" : [ "06:48", "800000", "150420" ], + "150409" : [ "06:49", "800000", "150420" ], + "150410" : [ "06:50", "800000", "150420" ], + "150411" : [ "06:51", "800000", "150420" ], + "150412" : [ "06:52", "800000", "150420" ], + "150413" : [ "06:53", "800000", "150420" ], + "150414" : [ "06:54", "800000", "150420" ], + "150415" : [ "06:55", "800000", "150420" ], + "150416" : [ "06:56", "800000", "150420" ], + "150417" : [ "06:57", "800000", "150420" ], + "150418" : [ "06:58", "800000", "150420" ], + "150419" : [ "06:59", "800000", "150420" ], + "150420" : [ "07:00", "350000", "150480" ], + "150421" : [ "07:01", "350000", "150481" ], + "150422" : [ "07:02", "350000", "150482" ], + "150423" : [ "07:03", "350000", "150483" ], + "150424" : [ "07:04", "350000", "150484" ], + "150425" : [ "07:05", "350000", "150485" ], + "150426" : [ "07:06", "350000", "150486" ], + "150427" : [ "07:07", "350000", "150487" ], + "150428" : [ "07:08", "350000", "150488" ], + "150429" : [ "07:09", "350000", "150489" ], + "150430" : [ "07:10", "350000", "150490" ], + "150431" : [ "07:11", "350000", "150491" ], + "150432" : [ "07:12", "350000", "150492" ], + "150433" : [ "07:13", "350000", "150493" ], + "150434" : [ "07:14", "350000", "150494" ], + "150435" : [ "07:15", "350000", "150495" ], + "150436" : [ "07:16", "350000", "150496" ], + "150437" : [ "07:17", "350000", "150497" ], + "150438" : [ "07:18", "350000", "150498" ], + "150439" : [ "07:19", "350000", "150499" ], + "150440" : [ "07:20", "350000", "150500" ], + "150441" : [ "07:21", "350000", "150501" ], + "150442" : [ "07:22", "350000", "150502" ], + "150443" : [ "07:23", "350000", "150503" ], + "150444" : [ "07:24", "350000", "150504" ], + "150445" : [ "07:25", "350000", "150505" ], + "150446" : [ "07:26", "350000", "150506" ], + "150447" : [ "07:27", "350000", "150507" ], + "150448" : [ "07:28", "350000", "150508" ], + "150449" : [ "07:29", "350000", "150509" ], + "150450" : [ "07:30", "350000", "150510" ], + "150451" : [ "07:31", "350000", "150511" ], + "150452" : [ "07:32", "350000", "150512" ], + "150453" : [ "07:33", "350000", "150513" ], + "150454" : [ "07:34", "350000", "150514" ], + "150455" : [ "07:35", "350000", "150515" ], + "150456" : [ "07:36", "350000", "150516" ], + "150457" : [ "07:37", "350000", "150517" ], + "150458" : [ "07:38", "350000", "150518" ], + "150459" : [ "07:39", "350000", "150519" ], + "150460" : [ "07:40", "350000", "150520" ], + "150461" : [ "07:41", "350000", "150521" ], + "150462" : [ "07:42", "350000", "150522" ], + "150463" : [ "07:43", "350000", "150523" ], + "150464" : [ "07:44", "350000", "150524" ], + "150465" : [ "07:45", "350000", "150525" ], + "150466" : [ "07:46", "350000", "150526" ], + "150467" : [ "07:47", "350000", "150527" ], + "150468" : [ "07:48", "350000", "150528" ], + "150469" : [ "07:49", "350000", "150529" ], + "150470" : [ "07:50", "350000", "150530" ], + "150471" : [ "07:51", "350000", "150531" ], + "150472" : [ "07:52", "350000", "150532" ], + "150473" : [ "07:53", "350000", "150533" ], + "150474" : [ "07:54", "350000", "150534" ], + "150475" : [ "07:55", "350000", "150535" ], + "150476" : [ "07:56", "350000", "150536" ], + "150477" : [ "07:57", "350000", "150537" ], + "150478" : [ "07:58", "350000", "150538" ], + "150479" : [ "07:59", "350000", "150539" ], + "150480" : [ "08:00", "350000", "150540" ], + "150481" : [ "08:01", "350000", "150541" ], + "150482" : [ "08:02", "350000", "150542" ], + "150483" : [ "08:03", "350000", "150543" ], + "150484" : [ "08:04", "350000", "150544" ], + "150485" : [ "08:05", "350000", "150545" ], + "150486" : [ "08:06", "350000", "150546" ], + "150487" : [ "08:07", "350000", "150547" ], + "150488" : [ "08:08", "350000", "150548" ], + "150489" : [ "08:09", "350000", "150549" ], + "150490" : [ "08:10", "350000", "150550" ], + "150491" : [ "08:11", "350000", "150551" ], + "150492" : [ "08:12", "350000", "150552" ], + "150493" : [ "08:13", "350000", "150553" ], + "150494" : [ "08:14", "350000", "150554" ], + "150495" : [ "08:15", "350000", "150555" ], + "150496" : [ "08:16", "350000", "150556" ], + "150497" : [ "08:17", "350000", "150557" ], + "150498" : [ "08:18", "350000", "150558" ], + "150499" : [ "08:19", "350000", "150559" ], + "150500" : [ "08:20", "350000", "150560" ], + "150501" : [ "08:21", "350000", "150561" ], + "150502" : [ "08:22", "350000", "150562" ], + "150503" : [ "08:23", "350000", "150563" ], + "150504" : [ "08:24", "350000", "150564" ], + "150505" : [ "08:25", "350000", "150565" ], + "150506" : [ "08:26", "350000", "150566" ], + "150507" : [ "08:27", "350000", "150567" ], + "150508" : [ "08:28", "350000", "150568" ], + "150509" : [ "08:29", "350000", "150569" ], + "150510" : [ "08:30", "350000", "150570" ], + "150511" : [ "08:31", "350000", "150571" ], + "150512" : [ "08:32", "350000", "150572" ], + "150513" : [ "08:33", "350000", "150573" ], + "150514" : [ "08:34", "350000", "150574" ], + "150515" : [ "08:35", "350000", "150575" ], + "150516" : [ "08:36", "350000", "150576" ], + "150517" : [ "08:37", "350000", "150577" ], + "150518" : [ "08:38", "350000", "150578" ], + "150519" : [ "08:39", "350000", "150579" ], + "150520" : [ "08:40", "350000", "150580" ], + "150521" : [ "08:41", "350000", "150581" ], + "150522" : [ "08:42", "350000", "150582" ], + "150523" : [ "08:43", "350000", "150583" ], + "150524" : [ "08:44", "350000", "150584" ], + "150525" : [ "08:45", "350000", "150585" ], + "150526" : [ "08:46", "350000", "150586" ], + "150527" : [ "08:47", "350000", "150587" ], + "150528" : [ "08:48", "350000", "150588" ], + "150529" : [ "08:49", "350000", "150589" ], + "150530" : [ "08:50", "350000", "150590" ], + "150531" : [ "08:51", "350000", "150591" ], + "150532" : [ "08:52", "350000", "150592" ], + "150533" : [ "08:53", "350000", "150593" ], + "150534" : [ "08:54", "350000", "150594" ], + "150535" : [ "08:55", "350000", "150595" ], + "150536" : [ "08:56", "350000", "150596" ], + "150537" : [ "08:57", "350000", "150597" ], + "150538" : [ "08:58", "350000", "150598" ], + "150539" : [ "08:59", "350000", "150599" ], + "150540" : [ "09:00", "350000", "150600" ], + "150541" : [ "09:01", "350000", "150601" ], + "150542" : [ "09:02", "350000", "150602" ], + "150543" : [ "09:03", "350000", "150603" ], + "150544" : [ "09:04", "350000", "150604" ], + "150545" : [ "09:05", "350000", "150605" ], + "150546" : [ "09:06", "350000", "150606" ], + "150547" : [ "09:07", "350000", "150607" ], + "150548" : [ "09:08", "350000", "150608" ], + "150549" : [ "09:09", "350000", "150609" ], + "150550" : [ "09:10", "350000", "150610" ], + "150551" : [ "09:11", "350000", "150611" ], + "150552" : [ "09:12", "350000", "150612" ], + "150553" : [ "09:13", "350000", "150613" ], + "150554" : [ "09:14", "350000", "150614" ], + "150555" : [ "09:15", "350000", "150615" ], + "150556" : [ "09:16", "350000", "150616" ], + "150557" : [ "09:17", "350000", "150617" ], + "150558" : [ "09:18", "350000", "150618" ], + "150559" : [ "09:19", "350000", "150619" ], + "150560" : [ "09:20", "350000", "150620" ], + "150561" : [ "09:21", "350000", "150621" ], + "150562" : [ "09:22", "350000", "150622" ], + "150563" : [ "09:23", "350000", "150623" ], + "150564" : [ "09:24", "350000", "150624" ], + "150565" : [ "09:25", "350000", "150625" ], + "150566" : [ "09:26", "350000", "150626" ], + "150567" : [ "09:27", "350000", "150627" ], + "150568" : [ "09:28", "350000", "150628" ], + "150569" : [ "09:29", "350000", "150629" ], + "150570" : [ "09:30", "350000", "150630" ], + "150571" : [ "09:31", "350000", "150631" ], + "150572" : [ "09:32", "350000", "150632" ], + "150573" : [ "09:33", "350000", "150633" ], + "150574" : [ "09:34", "350000", "150634" ], + "150575" : [ "09:35", "350000", "150635" ], + "150576" : [ "09:36", "350000", "150636" ], + "150577" : [ "09:37", "350000", "150637" ], + "150578" : [ "09:38", "350000", "150638" ], + "150579" : [ "09:39", "350000", "150639" ], + "150580" : [ "09:40", "350000", "150640" ], + "150581" : [ "09:41", "350000", "150641" ], + "150582" : [ "09:42", "350000", "150642" ], + "150583" : [ "09:43", "350000", "150643" ], + "150584" : [ "09:44", "350000", "150644" ], + "150585" : [ "09:45", "350000", "150645" ], + "150586" : [ "09:46", "350000", "150646" ], + "150587" : [ "09:47", "350000", "150647" ], + "150588" : [ "09:48", "350000", "150648" ], + "150589" : [ "09:49", "350000", "150649" ], + "150590" : [ "09:50", "350000", "150650" ], + "150591" : [ "09:51", "350000", "150651" ], + "150592" : [ "09:52", "350000", "150652" ], + "150593" : [ "09:53", "350000", "150653" ], + "150594" : [ "09:54", "350000", "150654" ], + "150595" : [ "09:55", "350000", "150655" ], + "150596" : [ "09:56", "350000", "150656" ], + "150597" : [ "09:57", "350000", "150657" ], + "150598" : [ "09:58", "350000", "150658" ], + "150599" : [ "09:59", "350000", "150659" ], + "150600" : [ "10:00", "350000", "150660" ], + "150601" : [ "10:01", "350000", "150661" ], + "150602" : [ "10:02", "350000", "150662" ], + "150603" : [ "10:03", "350000", "150663" ], + "150604" : [ "10:04", "350000", "150664" ], + "150605" : [ "10:05", "350000", "150665" ], + "150606" : [ "10:06", "350000", "150666" ], + "150607" : [ "10:07", "350000", "150667" ], + "150608" : [ "10:08", "350000", "150668" ], + "150609" : [ "10:09", "350000", "150669" ], + "150610" : [ "10:10", "350000", "150670" ], + "150611" : [ "10:11", "350000", "150671" ], + "150612" : [ "10:12", "350000", "150672" ], + "150613" : [ "10:13", "350000", "150673" ], + "150614" : [ "10:14", "350000", "150674" ], + "150615" : [ "10:15", "350000", "150675" ], + "150616" : [ "10:16", "350000", "150676" ], + "150617" : [ "10:17", "350000", "150677" ], + "150618" : [ "10:18", "350000", "150678" ], + "150619" : [ "10:19", "350000", "150679" ], + "150620" : [ "10:20", "350000", "150680" ], + "150621" : [ "10:21", "350000", "150681" ], + "150622" : [ "10:22", "350000", "150682" ], + "150623" : [ "10:23", "350000", "150683" ], + "150624" : [ "10:24", "350000", "150684" ], + "150625" : [ "10:25", "350000", "150685" ], + "150626" : [ "10:26", "350000", "150686" ], + "150627" : [ "10:27", "350000", "150687" ], + "150628" : [ "10:28", "350000", "150688" ], + "150629" : [ "10:29", "350000", "150689" ], + "150630" : [ "10:30", "350000", "150690" ], + "150631" : [ "10:31", "350000", "150691" ], + "150632" : [ "10:32", "350000", "150692" ], + "150633" : [ "10:33", "350000", "150693" ], + "150634" : [ "10:34", "350000", "150694" ], + "150635" : [ "10:35", "350000", "150695" ], + "150636" : [ "10:36", "350000", "150696" ], + "150637" : [ "10:37", "350000", "150697" ], + "150638" : [ "10:38", "350000", "150698" ], + "150639" : [ "10:39", "350000", "150699" ], + "150640" : [ "10:40", "350000", "150700" ], + "150641" : [ "10:41", "350000", "150701" ], + "150642" : [ "10:42", "350000", "150702" ], + "150643" : [ "10:43", "350000", "150703" ], + "150644" : [ "10:44", "350000", "150704" ], + "150645" : [ "10:45", "350000", "150705" ], + "150646" : [ "10:46", "350000", "150706" ], + "150647" : [ "10:47", "350000", "150707" ], + "150648" : [ "10:48", "350000", "150708" ], + "150649" : [ "10:49", "350000", "150709" ], + "150650" : [ "10:50", "350000", "150710" ], + "150651" : [ "10:51", "350000", "150711" ], + "150652" : [ "10:52", "350000", "150712" ], + "150653" : [ "10:53", "350000", "150713" ], + "150654" : [ "10:54", "350000", "150714" ], + "150655" : [ "10:55", "350000", "150715" ], + "150656" : [ "10:56", "350000", "150716" ], + "150657" : [ "10:57", "350000", "150717" ], + "150658" : [ "10:58", "350000", "150718" ], + "150659" : [ "10:59", "350000", "150719" ], + "150660" : [ "11:00", "350000", "150720" ], + "150661" : [ "11:01", "350000", "150721" ], + "150662" : [ "11:02", "350000", "150722" ], + "150663" : [ "11:03", "350000", "150723" ], + "150664" : [ "11:04", "350000", "150724" ], + "150665" : [ "11:05", "350000", "150725" ], + "150666" : [ "11:06", "350000", "150726" ], + "150667" : [ "11:07", "350000", "150727" ], + "150668" : [ "11:08", "350000", "150728" ], + "150669" : [ "11:09", "350000", "150729" ], + "150670" : [ "11:10", "350000", "150730" ], + "150671" : [ "11:11", "350000", "150731" ], + "150672" : [ "11:12", "350000", "150732" ], + "150673" : [ "11:13", "350000", "150733" ], + "150674" : [ "11:14", "350000", "150734" ], + "150675" : [ "11:15", "350000", "150735" ], + "150676" : [ "11:16", "350000", "150736" ], + "150677" : [ "11:17", "350000", "150737" ], + "150678" : [ "11:18", "350000", "150738" ], + "150679" : [ "11:19", "350000", "150739" ], + "150680" : [ "11:20", "350000", "150740" ], + "150681" : [ "11:21", "350000", "150741" ], + "150682" : [ "11:22", "350000", "150742" ], + "150683" : [ "11:23", "350000", "150743" ], + "150684" : [ "11:24", "350000", "150744" ], + "150685" : [ "11:25", "350000", "150745" ], + "150686" : [ "11:26", "350000", "150746" ], + "150687" : [ "11:27", "350000", "150747" ], + "150688" : [ "11:28", "350000", "150748" ], + "150689" : [ "11:29", "350000", "150749" ], + "150690" : [ "11:30", "350000", "150750" ], + "150691" : [ "11:31", "350000", "150751" ], + "150692" : [ "11:32", "350000", "150752" ], + "150693" : [ "11:33", "350000", "150753" ], + "150694" : [ "11:34", "350000", "150754" ], + "150695" : [ "11:35", "350000", "150755" ], + "150696" : [ "11:36", "350000", "150756" ], + "150697" : [ "11:37", "350000", "150757" ], + "150698" : [ "11:38", "350000", "150758" ], + "150699" : [ "11:39", "350000", "150759" ], + "150700" : [ "11:40", "350000", "150760" ], + "150701" : [ "11:41", "350000", "150761" ], + "150702" : [ "11:42", "350000", "150762" ], + "150703" : [ "11:43", "350000", "150763" ], + "150704" : [ "11:44", "350000", "150764" ], + "150705" : [ "11:45", "350000", "150765" ], + "150706" : [ "11:46", "350000", "150766" ], + "150707" : [ "11:47", "350000", "150767" ], + "150708" : [ "11:48", "350000", "150768" ], + "150709" : [ "11:49", "350000", "150769" ], + "150710" : [ "11:50", "350000", "150770" ], + "150711" : [ "11:51", "350000", "150771" ], + "150712" : [ "11:52", "350000", "150772" ], + "150713" : [ "11:53", "350000", "150773" ], + "150714" : [ "11:54", "350000", "150774" ], + "150715" : [ "11:55", "350000", "150775" ], + "150716" : [ "11:56", "350000", "150776" ], + "150717" : [ "11:57", "350000", "150777" ], + "150718" : [ "11:58", "350000", "150778" ], + "150719" : [ "11:59", "350000", "150779" ], + "150720" : [ "12:00", "350000", "150780" ], + "150721" : [ "12:01", "350000", "150781" ], + "150722" : [ "12:02", "350000", "150782" ], + "150723" : [ "12:03", "350000", "150783" ], + "150724" : [ "12:04", "350000", "150784" ], + "150725" : [ "12:05", "350000", "150785" ], + "150726" : [ "12:06", "350000", "150786" ], + "150727" : [ "12:07", "350000", "150787" ], + "150728" : [ "12:08", "350000", "150788" ], + "150729" : [ "12:09", "350000", "150789" ], + "150730" : [ "12:10", "350000", "150790" ], + "150731" : [ "12:11", "350000", "150791" ], + "150732" : [ "12:12", "350000", "150792" ], + "150733" : [ "12:13", "350000", "150793" ], + "150734" : [ "12:14", "350000", "150794" ], + "150735" : [ "12:15", "350000", "150795" ], + "150736" : [ "12:16", "350000", "150796" ], + "150737" : [ "12:17", "350000", "150797" ], + "150738" : [ "12:18", "350000", "150798" ], + "150739" : [ "12:19", "350000", "150799" ], + "150740" : [ "12:20", "350000", "150800" ], + "150741" : [ "12:21", "350000", "150801" ], + "150742" : [ "12:22", "350000", "150802" ], + "150743" : [ "12:23", "350000", "150803" ], + "150744" : [ "12:24", "350000", "150804" ], + "150745" : [ "12:25", "350000", "150805" ], + "150746" : [ "12:26", "350000", "150806" ], + "150747" : [ "12:27", "350000", "150807" ], + "150748" : [ "12:28", "350000", "150808" ], + "150749" : [ "12:29", "350000", "150809" ], + "150750" : [ "12:30", "350000", "150810" ], + "150751" : [ "12:31", "350000", "150811" ], + "150752" : [ "12:32", "350000", "150812" ], + "150753" : [ "12:33", "350000", "150813" ], + "150754" : [ "12:34", "350000", "150814" ], + "150755" : [ "12:35", "350000", "150815" ], + "150756" : [ "12:36", "350000", "150816" ], + "150757" : [ "12:37", "350000", "150817" ], + "150758" : [ "12:38", "350000", "150818" ], + "150759" : [ "12:39", "350000", "150819" ], + "150760" : [ "12:40", "350000", "150820" ], + "150761" : [ "12:41", "350000", "150821" ], + "150762" : [ "12:42", "350000", "150822" ], + "150763" : [ "12:43", "350000", "150823" ], + "150764" : [ "12:44", "350000", "150824" ], + "150765" : [ "12:45", "350000", "150825" ], + "150766" : [ "12:46", "350000", "150826" ], + "150767" : [ "12:47", "350000", "150827" ], + "150768" : [ "12:48", "350000", "150828" ], + "150769" : [ "12:49", "350000", "150829" ], + "150770" : [ "12:50", "350000", "150830" ], + "150771" : [ "12:51", "350000", "150831" ], + "150772" : [ "12:52", "350000", "150832" ], + "150773" : [ "12:53", "350000", "150833" ], + "150774" : [ "12:54", "350000", "150834" ], + "150775" : [ "12:55", "350000", "150835" ], + "150776" : [ "12:56", "350000", "150836" ], + "150777" : [ "12:57", "350000", "150837" ], + "150778" : [ "12:58", "350000", "150838" ], + "150779" : [ "12:59", "350000", "150839" ], + "150780" : [ "13:00", "350000", "150840" ], + "150781" : [ "13:01", "350000", "150841" ], + "150782" : [ "13:02", "350000", "150842" ], + "150783" : [ "13:03", "350000", "150843" ], + "150784" : [ "13:04", "350000", "150844" ], + "150785" : [ "13:05", "350000", "150845" ], + "150786" : [ "13:06", "350000", "150846" ], + "150787" : [ "13:07", "350000", "150847" ], + "150788" : [ "13:08", "350000", "150848" ], + "150789" : [ "13:09", "350000", "150849" ], + "150790" : [ "13:10", "350000", "150850" ], + "150791" : [ "13:11", "350000", "150851" ], + "150792" : [ "13:12", "350000", "150852" ], + "150793" : [ "13:13", "350000", "150853" ], + "150794" : [ "13:14", "350000", "150854" ], + "150795" : [ "13:15", "350000", "150855" ], + "150796" : [ "13:16", "350000", "150856" ], + "150797" : [ "13:17", "350000", "150857" ], + "150798" : [ "13:18", "350000", "150858" ], + "150799" : [ "13:19", "350000", "150859" ], + "150800" : [ "13:20", "350000", "150860" ], + "150801" : [ "13:21", "350000", "150861" ], + "150802" : [ "13:22", "350000", "150862" ], + "150803" : [ "13:23", "350000", "150863" ], + "150804" : [ "13:24", "350000", "150864" ], + "150805" : [ "13:25", "350000", "150865" ], + "150806" : [ "13:26", "350000", "150866" ], + "150807" : [ "13:27", "350000", "150867" ], + "150808" : [ "13:28", "350000", "150868" ], + "150809" : [ "13:29", "350000", "150869" ], + "150810" : [ "13:30", "350000", "150870" ], + "150811" : [ "13:31", "350000", "150871" ], + "150812" : [ "13:32", "350000", "150872" ], + "150813" : [ "13:33", "350000", "150873" ], + "150814" : [ "13:34", "350000", "150874" ], + "150815" : [ "13:35", "350000", "150875" ], + "150816" : [ "13:36", "350000", "150876" ], + "150817" : [ "13:37", "350000", "150877" ], + "150818" : [ "13:38", "350000", "150878" ], + "150819" : [ "13:39", "350000", "150879" ], + "150820" : [ "13:40", "350000", "150880" ], + "150821" : [ "13:41", "350000", "150881" ], + "150822" : [ "13:42", "350000", "150882" ], + "150823" : [ "13:43", "350000", "150883" ], + "150824" : [ "13:44", "350000", "150884" ], + "150825" : [ "13:45", "350000", "150885" ], + "150826" : [ "13:46", "350000", "150886" ], + "150827" : [ "13:47", "350000", "150887" ], + "150828" : [ "13:48", "350000", "150888" ], + "150829" : [ "13:49", "350000", "150889" ], + "150830" : [ "13:50", "350000", "150890" ], + "150831" : [ "13:51", "350000", "150891" ], + "150832" : [ "13:52", "350000", "150892" ], + "150833" : [ "13:53", "350000", "150893" ], + "150834" : [ "13:54", "350000", "150894" ], + "150835" : [ "13:55", "350000", "150895" ], + "150836" : [ "13:56", "350000", "150896" ], + "150837" : [ "13:57", "350000", "150897" ], + "150838" : [ "13:58", "350000", "150898" ], + "150839" : [ "13:59", "350000", "150899" ], + "150840" : [ "14:00", "350000", "150900" ], + "150841" : [ "14:01", "350000", "150901" ], + "150842" : [ "14:02", "350000", "150902" ], + "150843" : [ "14:03", "350000", "150903" ], + "150844" : [ "14:04", "350000", "150904" ], + "150845" : [ "14:05", "350000", "150905" ], + "150846" : [ "14:06", "350000", "150906" ], + "150847" : [ "14:07", "350000", "150907" ], + "150848" : [ "14:08", "350000", "150908" ], + "150849" : [ "14:09", "350000", "150909" ], + "150850" : [ "14:10", "350000", "150910" ], + "150851" : [ "14:11", "350000", "150911" ], + "150852" : [ "14:12", "350000", "150912" ], + "150853" : [ "14:13", "350000", "150913" ], + "150854" : [ "14:14", "350000", "150914" ], + "150855" : [ "14:15", "350000", "150915" ], + "150856" : [ "14:16", "350000", "150916" ], + "150857" : [ "14:17", "350000", "150917" ], + "150858" : [ "14:18", "350000", "150918" ], + "150859" : [ "14:19", "350000", "150919" ], + "150860" : [ "14:20", "350000", "150920" ], + "150861" : [ "14:21", "350000", "150921" ], + "150862" : [ "14:22", "350000", "150922" ], + "150863" : [ "14:23", "350000", "150923" ], + "150864" : [ "14:24", "350000", "150924" ], + "150865" : [ "14:25", "350000", "150925" ], + "150866" : [ "14:26", "350000", "150926" ], + "150867" : [ "14:27", "350000", "150927" ], + "150868" : [ "14:28", "350000", "150928" ], + "150869" : [ "14:29", "350000", "150929" ], + "150870" : [ "14:30", "350000", "150930" ], + "150871" : [ "14:31", "350000", "150931" ], + "150872" : [ "14:32", "350000", "150932" ], + "150873" : [ "14:33", "350000", "150933" ], + "150874" : [ "14:34", "350000", "150934" ], + "150875" : [ "14:35", "350000", "150935" ], + "150876" : [ "14:36", "350000", "150936" ], + "150877" : [ "14:37", "350000", "150937" ], + "150878" : [ "14:38", "350000", "150938" ], + "150879" : [ "14:39", "350000", "150939" ], + "150880" : [ "14:40", "350000", "150940" ], + "150881" : [ "14:41", "350000", "150941" ], + "150882" : [ "14:42", "350000", "150942" ], + "150883" : [ "14:43", "350000", "150943" ], + "150884" : [ "14:44", "350000", "150944" ], + "150885" : [ "14:45", "350000", "150945" ], + "150886" : [ "14:46", "350000", "150946" ], + "150887" : [ "14:47", "350000", "150947" ], + "150888" : [ "14:48", "350000", "150948" ], + "150889" : [ "14:49", "350000", "150949" ], + "150890" : [ "14:50", "350000", "150950" ], + "150891" : [ "14:51", "350000", "150951" ], + "150892" : [ "14:52", "350000", "150952" ], + "150893" : [ "14:53", "350000", "150953" ], + "150894" : [ "14:54", "350000", "150954" ], + "150895" : [ "14:55", "350000", "150955" ], + "150896" : [ "14:56", "350000", "150956" ], + "150897" : [ "14:57", "350000", "150957" ], + "150898" : [ "14:58", "350000", "150958" ], + "150899" : [ "14:59", "350000", "150959" ], + "150900" : [ "15:00", "350000", "150960" ], + "150901" : [ "15:01", "350000", "150961" ], + "150902" : [ "15:02", "350000", "150962" ], + "150903" : [ "15:03", "350000", "150963" ], + "150904" : [ "15:04", "350000", "150964" ], + "150905" : [ "15:05", "350000", "150965" ], + "150906" : [ "15:06", "350000", "150966" ], + "150907" : [ "15:07", "350000", "150967" ], + "150908" : [ "15:08", "350000", "150968" ], + "150909" : [ "15:09", "350000", "150969" ], + "150910" : [ "15:10", "350000", "150970" ], + "150911" : [ "15:11", "350000", "150971" ], + "150912" : [ "15:12", "350000", "150972" ], + "150913" : [ "15:13", "350000", "150973" ], + "150914" : [ "15:14", "350000", "150974" ], + "150915" : [ "15:15", "350000", "150975" ], + "150916" : [ "15:16", "350000", "150976" ], + "150917" : [ "15:17", "350000", "150977" ], + "150918" : [ "15:18", "350000", "150978" ], + "150919" : [ "15:19", "350000", "150979" ], + "150920" : [ "15:20", "350000", "150980" ], + "150921" : [ "15:21", "350000", "150981" ], + "150922" : [ "15:22", "350000", "150982" ], + "150923" : [ "15:23", "350000", "150983" ], + "150924" : [ "15:24", "350000", "150984" ], + "150925" : [ "15:25", "350000", "150985" ], + "150926" : [ "15:26", "350000", "150986" ], + "150927" : [ "15:27", "350000", "150987" ], + "150928" : [ "15:28", "350000", "150988" ], + "150929" : [ "15:29", "350000", "150989" ], + "150930" : [ "15:30", "350000", "150990" ], + "150931" : [ "15:31", "350000", "150991" ], + "150932" : [ "15:32", "350000", "150992" ], + "150933" : [ "15:33", "350000", "150993" ], + "150934" : [ "15:34", "350000", "150994" ], + "150935" : [ "15:35", "350000", "150995" ], + "150936" : [ "15:36", "350000", "150996" ], + "150937" : [ "15:37", "350000", "150997" ], + "150938" : [ "15:38", "350000", "150998" ], + "150939" : [ "15:39", "350000", "150999" ], + "150940" : [ "15:40", "350000", "151000" ], + "150941" : [ "15:41", "350000", "151001" ], + "150942" : [ "15:42", "350000", "151002" ], + "150943" : [ "15:43", "350000", "151003" ], + "150944" : [ "15:44", "350000", "151004" ], + "150945" : [ "15:45", "350000", "151005" ], + "150946" : [ "15:46", "350000", "151006" ], + "150947" : [ "15:47", "350000", "151007" ], + "150948" : [ "15:48", "350000", "151008" ], + "150949" : [ "15:49", "350000", "151009" ], + "150950" : [ "15:50", "350000", "151010" ], + "150951" : [ "15:51", "350000", "151011" ], + "150952" : [ "15:52", "350000", "151012" ], + "150953" : [ "15:53", "350000", "151013" ], + "150954" : [ "15:54", "350000", "151014" ], + "150955" : [ "15:55", "350000", "151015" ], + "150956" : [ "15:56", "350000", "151016" ], + "150957" : [ "15:57", "350000", "151017" ], + "150958" : [ "15:58", "350000", "151018" ], + "150959" : [ "15:59", "350000", "151019" ], + "150960" : [ "16:00", "350000", "151020" ], + "150961" : [ "16:01", "350000", "151021" ], + "150962" : [ "16:02", "350000", "151022" ], + "150963" : [ "16:03", "350000", "151023" ], + "150964" : [ "16:04", "350000", "151024" ], + "150965" : [ "16:05", "350000", "151025" ], + "150966" : [ "16:06", "350000", "151026" ], + "150967" : [ "16:07", "350000", "151027" ], + "150968" : [ "16:08", "350000", "151028" ], + "150969" : [ "16:09", "350000", "151029" ], + "150970" : [ "16:10", "350000", "151030" ], + "150971" : [ "16:11", "350000", "151031" ], + "150972" : [ "16:12", "350000", "151032" ], + "150973" : [ "16:13", "350000", "151033" ], + "150974" : [ "16:14", "350000", "151034" ], + "150975" : [ "16:15", "350000", "151035" ], + "150976" : [ "16:16", "350000", "151036" ], + "150977" : [ "16:17", "350000", "151037" ], + "150978" : [ "16:18", "350000", "151038" ], + "150979" : [ "16:19", "350000", "151039" ], + "150980" : [ "16:20", "350000", "151040" ], + "150981" : [ "16:21", "350000", "151041" ], + "150982" : [ "16:22", "350000", "151042" ], + "150983" : [ "16:23", "350000", "151043" ], + "150984" : [ "16:24", "350000", "151044" ], + "150985" : [ "16:25", "350000", "151045" ], + "150986" : [ "16:26", "350000", "151046" ], + "150987" : [ "16:27", "350000", "151047" ], + "150988" : [ "16:28", "350000", "151048" ], + "150989" : [ "16:29", "350000", "151049" ], + "150990" : [ "16:30", "350000", "151050" ], + "150991" : [ "16:31", "350000", "151051" ], + "150992" : [ "16:32", "350000", "151052" ], + "150993" : [ "16:33", "350000", "151053" ], + "150994" : [ "16:34", "350000", "151054" ], + "150995" : [ "16:35", "350000", "151055" ], + "150996" : [ "16:36", "350000", "151056" ], + "150997" : [ "16:37", "350000", "151057" ], + "150998" : [ "16:38", "350000", "151058" ], + "150999" : [ "16:39", "350000", "151059" ], + "151000" : [ "16:40", "350000", "151060" ], + "151001" : [ "16:41", "350000", "151061" ], + "151002" : [ "16:42", "350000", "151062" ], + "151003" : [ "16:43", "350000", "151063" ], + "151004" : [ "16:44", "350000", "151064" ], + "151005" : [ "16:45", "350000", "151065" ], + "151006" : [ "16:46", "350000", "151066" ], + "151007" : [ "16:47", "350000", "151067" ], + "151008" : [ "16:48", "350000", "151068" ], + "151009" : [ "16:49", "350000", "151069" ], + "151010" : [ "16:50", "350000", "151070" ], + "151011" : [ "16:51", "350000", "151071" ], + "151012" : [ "16:52", "350000", "151072" ], + "151013" : [ "16:53", "350000", "151073" ], + "151014" : [ "16:54", "350000", "151074" ], + "151015" : [ "16:55", "350000", "151075" ], + "151016" : [ "16:56", "350000", "151076" ], + "151017" : [ "16:57", "350000", "151077" ], + "151018" : [ "16:58", "350000", "151078" ], + "151019" : [ "16:59", "350000", "151079" ], + "151020" : [ "17:00", "350000", "151080" ], + "151021" : [ "17:01", "350000", "151081" ], + "151022" : [ "17:02", "350000", "151082" ], + "151023" : [ "17:03", "350000", "151083" ], + "151024" : [ "17:04", "350000", "151084" ], + "151025" : [ "17:05", "350000", "151085" ], + "151026" : [ "17:06", "350000", "151086" ], + "151027" : [ "17:07", "350000", "151087" ], + "151028" : [ "17:08", "350000", "151088" ], + "151029" : [ "17:09", "350000", "151089" ], + "151030" : [ "17:10", "350000", "151090" ], + "151031" : [ "17:11", "350000", "151091" ], + "151032" : [ "17:12", "350000", "151092" ], + "151033" : [ "17:13", "350000", "151093" ], + "151034" : [ "17:14", "350000", "151094" ], + "151035" : [ "17:15", "350000", "151095" ], + "151036" : [ "17:16", "350000", "151096" ], + "151037" : [ "17:17", "350000", "151097" ], + "151038" : [ "17:18", "350000", "151098" ], + "151039" : [ "17:19", "350000", "151099" ], + "151040" : [ "17:20", "350000", "151100" ], + "151041" : [ "17:21", "350000", "151101" ], + "151042" : [ "17:22", "350000", "151102" ], + "151043" : [ "17:23", "350000", "151103" ], + "151044" : [ "17:24", "350000", "151104" ], + "151045" : [ "17:25", "350000", "151105" ], + "151046" : [ "17:26", "350000", "151106" ], + "151047" : [ "17:27", "350000", "151107" ], + "151048" : [ "17:28", "350000", "151108" ], + "151049" : [ "17:29", "350000", "151109" ], + "151050" : [ "17:30", "350000", "151110" ], + "151051" : [ "17:31", "350000", "151111" ], + "151052" : [ "17:32", "350000", "151112" ], + "151053" : [ "17:33", "350000", "151113" ], + "151054" : [ "17:34", "350000", "151114" ], + "151055" : [ "17:35", "350000", "151115" ], + "151056" : [ "17:36", "350000", "151116" ], + "151057" : [ "17:37", "350000", "151117" ], + "151058" : [ "17:38", "350000", "151118" ], + "151059" : [ "17:39", "350000", "151119" ], + "151060" : [ "17:40", "350000", "151120" ], + "151061" : [ "17:41", "350000", "151121" ], + "151062" : [ "17:42", "350000", "151122" ], + "151063" : [ "17:43", "350000", "151123" ], + "151064" : [ "17:44", "350000", "151124" ], + "151065" : [ "17:45", "350000", "151125" ], + "151066" : [ "17:46", "350000", "151126" ], + "151067" : [ "17:47", "350000", "151127" ], + "151068" : [ "17:48", "350000", "151128" ], + "151069" : [ "17:49", "350000", "151129" ], + "151070" : [ "17:50", "350000", "151130" ], + "151071" : [ "17:51", "350000", "151131" ], + "151072" : [ "17:52", "350000", "151132" ], + "151073" : [ "17:53", "350000", "151133" ], + "151074" : [ "17:54", "350000", "151134" ], + "151075" : [ "17:55", "350000", "151135" ], + "151076" : [ "17:56", "350000", "151136" ], + "151077" : [ "17:57", "350000", "151137" ], + "151078" : [ "17:58", "350000", "151138" ], + "151079" : [ "17:59", "350000", "151139" ], + "151080" : [ "18:00", "350000", "151140" ], + "151081" : [ "18:01", "350000", "151141" ], + "151082" : [ "18:02", "350000", "151142" ], + "151083" : [ "18:03", "350000", "151143" ], + "151084" : [ "18:04", "350000", "151144" ], + "151085" : [ "18:05", "350000", "151145" ], + "151086" : [ "18:06", "350000", "151146" ], + "151087" : [ "18:07", "350000", "151147" ], + "151088" : [ "18:08", "350000", "151148" ], + "151089" : [ "18:09", "350000", "151149" ], + "151090" : [ "18:10", "350000", "151150" ], + "151091" : [ "18:11", "350000", "151151" ], + "151092" : [ "18:12", "350000", "151152" ], + "151093" : [ "18:13", "350000", "151153" ], + "151094" : [ "18:14", "350000", "151154" ], + "151095" : [ "18:15", "350000", "151155" ], + "151096" : [ "18:16", "350000", "151156" ], + "151097" : [ "18:17", "350000", "151157" ], + "151098" : [ "18:18", "350000", "151158" ], + "151099" : [ "18:19", "350000", "151159" ], + "151100" : [ "18:20", "350000", "151160" ], + "151101" : [ "18:21", "350000", "151161" ], + "151102" : [ "18:22", "350000", "151162" ], + "151103" : [ "18:23", "350000", "151163" ], + "151104" : [ "18:24", "350000", "151164" ], + "151105" : [ "18:25", "350000", "151165" ], + "151106" : [ "18:26", "350000", "151166" ], + "151107" : [ "18:27", "350000", "151167" ], + "151108" : [ "18:28", "350000", "151168" ], + "151109" : [ "18:29", "350000", "151169" ], + "151110" : [ "18:30", "350000", "151170" ], + "151111" : [ "18:31", "350000", "151171" ], + "151112" : [ "18:32", "350000", "151172" ], + "151113" : [ "18:33", "350000", "151173" ], + "151114" : [ "18:34", "350000", "151174" ], + "151115" : [ "18:35", "350000", "151175" ], + "151116" : [ "18:36", "350000", "151176" ], + "151117" : [ "18:37", "350000", "151177" ], + "151118" : [ "18:38", "350000", "151178" ], + "151119" : [ "18:39", "350000", "151179" ], + "151120" : [ "18:40", "350000", "151180" ], + "151121" : [ "18:41", "350000", "151181" ], + "151122" : [ "18:42", "350000", "151182" ], + "151123" : [ "18:43", "350000", "151183" ], + "151124" : [ "18:44", "350000", "151184" ], + "151125" : [ "18:45", "350000", "151185" ], + "151126" : [ "18:46", "350000", "151186" ], + "151127" : [ "18:47", "350000", "151187" ], + "151128" : [ "18:48", "350000", "151188" ], + "151129" : [ "18:49", "350000", "151189" ], + "151130" : [ "18:50", "350000", "151190" ], + "151131" : [ "18:51", "350000", "151191" ], + "151132" : [ "18:52", "350000", "151192" ], + "151133" : [ "18:53", "350000", "151193" ], + "151134" : [ "18:54", "350000", "151194" ], + "151135" : [ "18:55", "350000", "151195" ], + "151136" : [ "18:56", "350000", "151196" ], + "151137" : [ "18:57", "350000", "151197" ], + "151138" : [ "18:58", "350000", "151198" ], + "151139" : [ "18:59", "350000", "151199" ], + "151140" : [ "19:00", "350000", "151200" ], + "151141" : [ "19:01", "350000", "151200" ], + "151142" : [ "19:02", "350000", "151200" ], + "151143" : [ "19:03", "350000", "151200" ], + "151144" : [ "19:04", "350000", "151200" ], + "151145" : [ "19:05", "350000", "151200" ], + "151146" : [ "19:06", "350000", "151200" ], + "151147" : [ "19:07", "350000", "151200" ], + "151148" : [ "19:08", "350000", "151200" ], + "151149" : [ "19:09", "350000", "151200" ], + "151150" : [ "19:10", "350000", "151200" ], + "151151" : [ "19:11", "350000", "151200" ], + "151152" : [ "19:12", "350000", "151200" ], + "151153" : [ "19:13", "350000", "151200" ], + "151154" : [ "19:14", "350000", "151200" ], + "151155" : [ "19:15", "350000", "151200" ], + "151156" : [ "19:16", "350000", "151200" ], + "151157" : [ "19:17", "350000", "151200" ], + "151158" : [ "19:18", "350000", "151200" ], + "151159" : [ "19:19", "350000", "151200" ], + "151160" : [ "19:20", "350000", "151200" ], + "151161" : [ "19:21", "350000", "151200" ], + "151162" : [ "19:22", "350000", "151200" ], + "151163" : [ "19:23", "350000", "151200" ], + "151164" : [ "19:24", "350000", "151200" ], + "151165" : [ "19:25", "350000", "151200" ], + "151166" : [ "19:26", "350000", "151200" ], + "151167" : [ "19:27", "350000", "151200" ], + "151168" : [ "19:28", "350000", "151200" ], + "151169" : [ "19:29", "350000", "151200" ], + "151170" : [ "19:30", "350000", "151200" ], + "151171" : [ "19:31", "350000", "151200" ], + "151172" : [ "19:32", "350000", "151200" ], + "151173" : [ "19:33", "350000", "151200" ], + "151174" : [ "19:34", "350000", "151200" ], + "151175" : [ "19:35", "350000", "151200" ], + "151176" : [ "19:36", "350000", "151200" ], + "151177" : [ "19:37", "350000", "151200" ], + "151178" : [ "19:38", "350000", "151200" ], + "151179" : [ "19:39", "350000", "151200" ], + "151180" : [ "19:40", "350000", "151200" ], + "151181" : [ "19:41", "350000", "151200" ], + "151182" : [ "19:42", "350000", "151200" ], + "151183" : [ "19:43", "350000", "151200" ], + "151184" : [ "19:44", "350000", "151200" ], + "151185" : [ "19:45", "350000", "151200" ], + "151186" : [ "19:46", "350000", "151200" ], + "151187" : [ "19:47", "350000", "151200" ], + "151188" : [ "19:48", "350000", "151200" ], + "151189" : [ "19:49", "350000", "151200" ], + "151190" : [ "19:50", "350000", "151200" ], + "151191" : [ "19:51", "350000", "151200" ], + "151192" : [ "19:52", "350000", "151200" ], + "151193" : [ "19:53", "350000", "151200" ], + "151194" : [ "19:54", "350000", "151200" ], + "151195" : [ "19:55", "350000", "151200" ], + "151196" : [ "19:56", "350000", "151200" ], + "151197" : [ "19:57", "350000", "151200" ], + "151198" : [ "19:58", "350000", "151200" ], + "151199" : [ "19:59", "350000", "151200" ], + "151200" : [ "20:00", "800000", "160420" ], + "151201" : [ "20:01", "800000", "160420" ], + "151202" : [ "20:02", "800000", "160420" ], + "151203" : [ "20:03", "800000", "160420" ], + "151204" : [ "20:04", "800000", "160420" ], + "151205" : [ "20:05", "800000", "160420" ], + "151206" : [ "20:06", "800000", "160420" ], + "151207" : [ "20:07", "800000", "160420" ], + "151208" : [ "20:08", "800000", "160420" ], + "151209" : [ "20:09", "800000", "160420" ], + "151210" : [ "20:10", "800000", "160420" ], + "151211" : [ "20:11", "800000", "160420" ], + "151212" : [ "20:12", "800000", "160420" ], + "151213" : [ "20:13", "800000", "160420" ], + "151214" : [ "20:14", "800000", "160420" ], + "151215" : [ "20:15", "800000", "160420" ], + "151216" : [ "20:16", "800000", "160420" ], + "151217" : [ "20:17", "800000", "160420" ], + "151218" : [ "20:18", "800000", "160420" ], + "151219" : [ "20:19", "800000", "160420" ], + "151220" : [ "20:20", "800000", "160420" ], + "151221" : [ "20:21", "800000", "160420" ], + "151222" : [ "20:22", "800000", "160420" ], + "151223" : [ "20:23", "800000", "160420" ], + "151224" : [ "20:24", "800000", "160420" ], + "151225" : [ "20:25", "800000", "160420" ], + "151226" : [ "20:26", "800000", "160420" ], + "151227" : [ "20:27", "800000", "160420" ], + "151228" : [ "20:28", "800000", "160420" ], + "151229" : [ "20:29", "800000", "160420" ], + "151230" : [ "20:30", "800000", "160420" ], + "151231" : [ "20:31", "800000", "160420" ], + "151232" : [ "20:32", "800000", "160420" ], + "151233" : [ "20:33", "800000", "160420" ], + "151234" : [ "20:34", "800000", "160420" ], + "151235" : [ "20:35", "800000", "160420" ], + "151236" : [ "20:36", "800000", "160420" ], + "151237" : [ "20:37", "800000", "160420" ], + "151238" : [ "20:38", "800000", "160420" ], + "151239" : [ "20:39", "800000", "160420" ], + "151240" : [ "20:40", "800000", "160420" ], + "151241" : [ "20:41", "800000", "160420" ], + "151242" : [ "20:42", "800000", "160420" ], + "151243" : [ "20:43", "800000", "160420" ], + "151244" : [ "20:44", "800000", "160420" ], + "151245" : [ "20:45", "800000", "160420" ], + "151246" : [ "20:46", "800000", "160420" ], + "151247" : [ "20:47", "800000", "160420" ], + "151248" : [ "20:48", "800000", "160420" ], + "151249" : [ "20:49", "800000", "160420" ], + "151250" : [ "20:50", "800000", "160420" ], + "151251" : [ "20:51", "800000", "160420" ], + "151252" : [ "20:52", "800000", "160420" ], + "151253" : [ "20:53", "800000", "160420" ], + "151254" : [ "20:54", "800000", "160420" ], + "151255" : [ "20:55", "800000", "160420" ], + "151256" : [ "20:56", "800000", "160420" ], + "151257" : [ "20:57", "800000", "160420" ], + "151258" : [ "20:58", "800000", "160420" ], + "151259" : [ "20:59", "800000", "160420" ], + "151260" : [ "21:00", "800000", "160420" ], + "151261" : [ "21:01", "800000", "160420" ], + "151262" : [ "21:02", "800000", "160420" ], + "151263" : [ "21:03", "800000", "160420" ], + "151264" : [ "21:04", "800000", "160420" ], + "151265" : [ "21:05", "800000", "160420" ], + "151266" : [ "21:06", "800000", "160420" ], + "151267" : [ "21:07", "800000", "160420" ], + "151268" : [ "21:08", "800000", "160420" ], + "151269" : [ "21:09", "800000", "160420" ], + "151270" : [ "21:10", "800000", "160420" ], + "151271" : [ "21:11", "800000", "160420" ], + "151272" : [ "21:12", "800000", "160420" ], + "151273" : [ "21:13", "800000", "160420" ], + "151274" : [ "21:14", "800000", "160420" ], + "151275" : [ "21:15", "800000", "160420" ], + "151276" : [ "21:16", "800000", "160420" ], + "151277" : [ "21:17", "800000", "160420" ], + "151278" : [ "21:18", "800000", "160420" ], + "151279" : [ "21:19", "800000", "160420" ], + "151280" : [ "21:20", "800000", "160420" ], + "151281" : [ "21:21", "800000", "160420" ], + "151282" : [ "21:22", "800000", "160420" ], + "151283" : [ "21:23", "800000", "160420" ], + "151284" : [ "21:24", "800000", "160420" ], + "151285" : [ "21:25", "800000", "160420" ], + "151286" : [ "21:26", "800000", "160420" ], + "151287" : [ "21:27", "800000", "160420" ], + "151288" : [ "21:28", "800000", "160420" ], + "151289" : [ "21:29", "800000", "160420" ], + "151290" : [ "21:30", "800000", "160420" ], + "151291" : [ "21:31", "800000", "160420" ], + "151292" : [ "21:32", "800000", "160420" ], + "151293" : [ "21:33", "800000", "160420" ], + "151294" : [ "21:34", "800000", "160420" ], + "151295" : [ "21:35", "800000", "160420" ], + "151296" : [ "21:36", "800000", "160420" ], + "151297" : [ "21:37", "800000", "160420" ], + "151298" : [ "21:38", "800000", "160420" ], + "151299" : [ "21:39", "800000", "160420" ], + "151300" : [ "21:40", "800000", "160420" ], + "151301" : [ "21:41", "800000", "160420" ], + "151302" : [ "21:42", "800000", "160420" ], + "151303" : [ "21:43", "800000", "160420" ], + "151304" : [ "21:44", "800000", "160420" ], + "151305" : [ "21:45", "800000", "160420" ], + "151306" : [ "21:46", "800000", "160420" ], + "151307" : [ "21:47", "800000", "160420" ], + "151308" : [ "21:48", "800000", "160420" ], + "151309" : [ "21:49", "800000", "160420" ], + "151310" : [ "21:50", "800000", "160420" ], + "151311" : [ "21:51", "800000", "160420" ], + "151312" : [ "21:52", "800000", "160420" ], + "151313" : [ "21:53", "800000", "160420" ], + "151314" : [ "21:54", "800000", "160420" ], + "151315" : [ "21:55", "800000", "160420" ], + "151316" : [ "21:56", "800000", "160420" ], + "151317" : [ "21:57", "800000", "160420" ], + "151318" : [ "21:58", "800000", "160420" ], + "151319" : [ "21:59", "800000", "160420" ], + "151320" : [ "22:00", "800000", "160420" ], + "151321" : [ "22:01", "800000", "160420" ], + "151322" : [ "22:02", "800000", "160420" ], + "151323" : [ "22:03", "800000", "160420" ], + "151324" : [ "22:04", "800000", "160420" ], + "151325" : [ "22:05", "800000", "160420" ], + "151326" : [ "22:06", "800000", "160420" ], + "151327" : [ "22:07", "800000", "160420" ], + "151328" : [ "22:08", "800000", "160420" ], + "151329" : [ "22:09", "800000", "160420" ], + "151330" : [ "22:10", "800000", "160420" ], + "151331" : [ "22:11", "800000", "160420" ], + "151332" : [ "22:12", "800000", "160420" ], + "151333" : [ "22:13", "800000", "160420" ], + "151334" : [ "22:14", "800000", "160420" ], + "151335" : [ "22:15", "800000", "160420" ], + "151336" : [ "22:16", "800000", "160420" ], + "151337" : [ "22:17", "800000", "160420" ], + "151338" : [ "22:18", "800000", "160420" ], + "151339" : [ "22:19", "800000", "160420" ], + "151340" : [ "22:20", "800000", "160420" ], + "151341" : [ "22:21", "800000", "160420" ], + "151342" : [ "22:22", "800000", "160420" ], + "151343" : [ "22:23", "800000", "160420" ], + "151344" : [ "22:24", "800000", "160420" ], + "151345" : [ "22:25", "800000", "160420" ], + "151346" : [ "22:26", "800000", "160420" ], + "151347" : [ "22:27", "800000", "160420" ], + "151348" : [ "22:28", "800000", "160420" ], + "151349" : [ "22:29", "800000", "160420" ], + "151350" : [ "22:30", "800000", "160420" ], + "151351" : [ "22:31", "800000", "160420" ], + "151352" : [ "22:32", "800000", "160420" ], + "151353" : [ "22:33", "800000", "160420" ], + "151354" : [ "22:34", "800000", "160420" ], + "151355" : [ "22:35", "800000", "160420" ], + "151356" : [ "22:36", "800000", "160420" ], + "151357" : [ "22:37", "800000", "160420" ], + "151358" : [ "22:38", "800000", "160420" ], + "151359" : [ "22:39", "800000", "160420" ], + "151360" : [ "22:40", "800000", "160420" ], + "151361" : [ "22:41", "800000", "160420" ], + "151362" : [ "22:42", "800000", "160420" ], + "151363" : [ "22:43", "800000", "160420" ], + "151364" : [ "22:44", "800000", "160420" ], + "151365" : [ "22:45", "800000", "160420" ], + "151366" : [ "22:46", "800000", "160420" ], + "151367" : [ "22:47", "800000", "160420" ], + "151368" : [ "22:48", "800000", "160420" ], + "151369" : [ "22:49", "800000", "160420" ], + "151370" : [ "22:50", "800000", "160420" ], + "151371" : [ "22:51", "800000", "160420" ], + "151372" : [ "22:52", "800000", "160420" ], + "151373" : [ "22:53", "800000", "160420" ], + "151374" : [ "22:54", "800000", "160420" ], + "151375" : [ "22:55", "800000", "160420" ], + "151376" : [ "22:56", "800000", "160420" ], + "151377" : [ "22:57", "800000", "160420" ], + "151378" : [ "22:58", "800000", "160420" ], + "151379" : [ "22:59", "800000", "160420" ], + "151380" : [ "23:00", "800000", "160420" ], + "151381" : [ "23:01", "800000", "160420" ], + "151382" : [ "23:02", "800000", "160420" ], + "151383" : [ "23:03", "800000", "160420" ], + "151384" : [ "23:04", "800000", "160420" ], + "151385" : [ "23:05", "800000", "160420" ], + "151386" : [ "23:06", "800000", "160420" ], + "151387" : [ "23:07", "800000", "160420" ], + "151388" : [ "23:08", "800000", "160420" ], + "151389" : [ "23:09", "800000", "160420" ], + "151390" : [ "23:10", "800000", "160420" ], + "151391" : [ "23:11", "800000", "160420" ], + "151392" : [ "23:12", "800000", "160420" ], + "151393" : [ "23:13", "800000", "160420" ], + "151394" : [ "23:14", "800000", "160420" ], + "151395" : [ "23:15", "800000", "160420" ], + "151396" : [ "23:16", "800000", "160420" ], + "151397" : [ "23:17", "800000", "160420" ], + "151398" : [ "23:18", "800000", "160420" ], + "151399" : [ "23:19", "800000", "160420" ], + "151400" : [ "23:20", "800000", "160420" ], + "151401" : [ "23:21", "800000", "160420" ], + "151402" : [ "23:22", "800000", "160420" ], + "151403" : [ "23:23", "800000", "160420" ], + "151404" : [ "23:24", "800000", "160420" ], + "151405" : [ "23:25", "800000", "160420" ], + "151406" : [ "23:26", "800000", "160420" ], + "151407" : [ "23:27", "800000", "160420" ], + "151408" : [ "23:28", "800000", "160420" ], + "151409" : [ "23:29", "800000", "160420" ], + "151410" : [ "23:30", "800000", "160420" ], + "151411" : [ "23:31", "800000", "160420" ], + "151412" : [ "23:32", "800000", "160420" ], + "151413" : [ "23:33", "800000", "160420" ], + "151414" : [ "23:34", "800000", "160420" ], + "151415" : [ "23:35", "800000", "160420" ], + "151416" : [ "23:36", "800000", "160420" ], + "151417" : [ "23:37", "800000", "160420" ], + "151418" : [ "23:38", "800000", "160420" ], + "151419" : [ "23:39", "800000", "160420" ], + "151420" : [ "23:40", "800000", "160420" ], + "151421" : [ "23:41", "800000", "160420" ], + "151422" : [ "23:42", "800000", "160420" ], + "151423" : [ "23:43", "800000", "160420" ], + "151424" : [ "23:44", "800000", "160420" ], + "151425" : [ "23:45", "800000", "160420" ], + "151426" : [ "23:46", "800000", "160420" ], + "151427" : [ "23:47", "800000", "160420" ], + "151428" : [ "23:48", "800000", "160420" ], + "151429" : [ "23:49", "800000", "160420" ], + "151430" : [ "23:50", "800000", "160420" ], + "151431" : [ "23:51", "800000", "160420" ], + "151432" : [ "23:52", "800000", "160420" ], + "151433" : [ "23:53", "800000", "160420" ], + "151434" : [ "23:54", "800000", "160420" ], + "151435" : [ "23:55", "800000", "160420" ], + "151436" : [ "23:56", "800000", "160420" ], + "151437" : [ "23:57", "800000", "160420" ], + "151438" : [ "23:58", "800000", "160420" ], + "151439" : [ "23:59", "800000", "160420" ] + }, + "Sunday": { + "160000" : [ "00:00", "800000", "160420" ], + "160001" : [ "00:01", "800000", "160420" ], + "160002" : [ "00:02", "800000", "160420" ], + "160003" : [ "00:03", "800000", "160420" ], + "160004" : [ "00:04", "800000", "160420" ], + "160005" : [ "00:05", "800000", "160420" ], + "160006" : [ "00:06", "800000", "160420" ], + "160007" : [ "00:07", "800000", "160420" ], + "160008" : [ "00:08", "800000", "160420" ], + "160009" : [ "00:09", "800000", "160420" ], + "160010" : [ "00:10", "800000", "160420" ], + "160011" : [ "00:11", "800000", "160420" ], + "160012" : [ "00:12", "800000", "160420" ], + "160013" : [ "00:13", "800000", "160420" ], + "160014" : [ "00:14", "800000", "160420" ], + "160015" : [ "00:15", "800000", "160420" ], + "160016" : [ "00:16", "800000", "160420" ], + "160017" : [ "00:17", "800000", "160420" ], + "160018" : [ "00:18", "800000", "160420" ], + "160019" : [ "00:19", "800000", "160420" ], + "160020" : [ "00:20", "800000", "160420" ], + "160021" : [ "00:21", "800000", "160420" ], + "160022" : [ "00:22", "800000", "160420" ], + "160023" : [ "00:23", "800000", "160420" ], + "160024" : [ "00:24", "800000", "160420" ], + "160025" : [ "00:25", "800000", "160420" ], + "160026" : [ "00:26", "800000", "160420" ], + "160027" : [ "00:27", "800000", "160420" ], + "160028" : [ "00:28", "800000", "160420" ], + "160029" : [ "00:29", "800000", "160420" ], + "160030" : [ "00:30", "800000", "160420" ], + "160031" : [ "00:31", "800000", "160420" ], + "160032" : [ "00:32", "800000", "160420" ], + "160033" : [ "00:33", "800000", "160420" ], + "160034" : [ "00:34", "800000", "160420" ], + "160035" : [ "00:35", "800000", "160420" ], + "160036" : [ "00:36", "800000", "160420" ], + "160037" : [ "00:37", "800000", "160420" ], + "160038" : [ "00:38", "800000", "160420" ], + "160039" : [ "00:39", "800000", "160420" ], + "160040" : [ "00:40", "800000", "160420" ], + "160041" : [ "00:41", "800000", "160420" ], + "160042" : [ "00:42", "800000", "160420" ], + "160043" : [ "00:43", "800000", "160420" ], + "160044" : [ "00:44", "800000", "160420" ], + "160045" : [ "00:45", "800000", "160420" ], + "160046" : [ "00:46", "800000", "160420" ], + "160047" : [ "00:47", "800000", "160420" ], + "160048" : [ "00:48", "800000", "160420" ], + "160049" : [ "00:49", "800000", "160420" ], + "160050" : [ "00:50", "800000", "160420" ], + "160051" : [ "00:51", "800000", "160420" ], + "160052" : [ "00:52", "800000", "160420" ], + "160053" : [ "00:53", "800000", "160420" ], + "160054" : [ "00:54", "800000", "160420" ], + "160055" : [ "00:55", "800000", "160420" ], + "160056" : [ "00:56", "800000", "160420" ], + "160057" : [ "00:57", "800000", "160420" ], + "160058" : [ "00:58", "800000", "160420" ], + "160059" : [ "00:59", "800000", "160420" ], + "160060" : [ "01:00", "800000", "160420" ], + "160061" : [ "01:01", "800000", "160420" ], + "160062" : [ "01:02", "800000", "160420" ], + "160063" : [ "01:03", "800000", "160420" ], + "160064" : [ "01:04", "800000", "160420" ], + "160065" : [ "01:05", "800000", "160420" ], + "160066" : [ "01:06", "800000", "160420" ], + "160067" : [ "01:07", "800000", "160420" ], + "160068" : [ "01:08", "800000", "160420" ], + "160069" : [ "01:09", "800000", "160420" ], + "160070" : [ "01:10", "800000", "160420" ], + "160071" : [ "01:11", "800000", "160420" ], + "160072" : [ "01:12", "800000", "160420" ], + "160073" : [ "01:13", "800000", "160420" ], + "160074" : [ "01:14", "800000", "160420" ], + "160075" : [ "01:15", "800000", "160420" ], + "160076" : [ "01:16", "800000", "160420" ], + "160077" : [ "01:17", "800000", "160420" ], + "160078" : [ "01:18", "800000", "160420" ], + "160079" : [ "01:19", "800000", "160420" ], + "160080" : [ "01:20", "800000", "160420" ], + "160081" : [ "01:21", "800000", "160420" ], + "160082" : [ "01:22", "800000", "160420" ], + "160083" : [ "01:23", "800000", "160420" ], + "160084" : [ "01:24", "800000", "160420" ], + "160085" : [ "01:25", "800000", "160420" ], + "160086" : [ "01:26", "800000", "160420" ], + "160087" : [ "01:27", "800000", "160420" ], + "160088" : [ "01:28", "800000", "160420" ], + "160089" : [ "01:29", "800000", "160420" ], + "160090" : [ "01:30", "800000", "160420" ], + "160091" : [ "01:31", "800000", "160420" ], + "160092" : [ "01:32", "800000", "160420" ], + "160093" : [ "01:33", "800000", "160420" ], + "160094" : [ "01:34", "800000", "160420" ], + "160095" : [ "01:35", "800000", "160420" ], + "160096" : [ "01:36", "800000", "160420" ], + "160097" : [ "01:37", "800000", "160420" ], + "160098" : [ "01:38", "800000", "160420" ], + "160099" : [ "01:39", "800000", "160420" ], + "160100" : [ "01:40", "800000", "160420" ], + "160101" : [ "01:41", "800000", "160420" ], + "160102" : [ "01:42", "800000", "160420" ], + "160103" : [ "01:43", "800000", "160420" ], + "160104" : [ "01:44", "800000", "160420" ], + "160105" : [ "01:45", "800000", "160420" ], + "160106" : [ "01:46", "800000", "160420" ], + "160107" : [ "01:47", "800000", "160420" ], + "160108" : [ "01:48", "800000", "160420" ], + "160109" : [ "01:49", "800000", "160420" ], + "160110" : [ "01:50", "800000", "160420" ], + "160111" : [ "01:51", "800000", "160420" ], + "160112" : [ "01:52", "800000", "160420" ], + "160113" : [ "01:53", "800000", "160420" ], + "160114" : [ "01:54", "800000", "160420" ], + "160115" : [ "01:55", "800000", "160420" ], + "160116" : [ "01:56", "800000", "160420" ], + "160117" : [ "01:57", "800000", "160420" ], + "160118" : [ "01:58", "800000", "160420" ], + "160119" : [ "01:59", "800000", "160420" ], + "160120" : [ "02:00", "800000", "160420" ], + "160121" : [ "02:01", "800000", "160420" ], + "160122" : [ "02:02", "800000", "160420" ], + "160123" : [ "02:03", "800000", "160420" ], + "160124" : [ "02:04", "800000", "160420" ], + "160125" : [ "02:05", "800000", "160420" ], + "160126" : [ "02:06", "800000", "160420" ], + "160127" : [ "02:07", "800000", "160420" ], + "160128" : [ "02:08", "800000", "160420" ], + "160129" : [ "02:09", "800000", "160420" ], + "160130" : [ "02:10", "800000", "160420" ], + "160131" : [ "02:11", "800000", "160420" ], + "160132" : [ "02:12", "800000", "160420" ], + "160133" : [ "02:13", "800000", "160420" ], + "160134" : [ "02:14", "800000", "160420" ], + "160135" : [ "02:15", "800000", "160420" ], + "160136" : [ "02:16", "800000", "160420" ], + "160137" : [ "02:17", "800000", "160420" ], + "160138" : [ "02:18", "800000", "160420" ], + "160139" : [ "02:19", "800000", "160420" ], + "160140" : [ "02:20", "800000", "160420" ], + "160141" : [ "02:21", "800000", "160420" ], + "160142" : [ "02:22", "800000", "160420" ], + "160143" : [ "02:23", "800000", "160420" ], + "160144" : [ "02:24", "800000", "160420" ], + "160145" : [ "02:25", "800000", "160420" ], + "160146" : [ "02:26", "800000", "160420" ], + "160147" : [ "02:27", "800000", "160420" ], + "160148" : [ "02:28", "800000", "160420" ], + "160149" : [ "02:29", "800000", "160420" ], + "160150" : [ "02:30", "800000", "160420" ], + "160151" : [ "02:31", "800000", "160420" ], + "160152" : [ "02:32", "800000", "160420" ], + "160153" : [ "02:33", "800000", "160420" ], + "160154" : [ "02:34", "800000", "160420" ], + "160155" : [ "02:35", "800000", "160420" ], + "160156" : [ "02:36", "800000", "160420" ], + "160157" : [ "02:37", "800000", "160420" ], + "160158" : [ "02:38", "800000", "160420" ], + "160159" : [ "02:39", "800000", "160420" ], + "160160" : [ "02:40", "800000", "160420" ], + "160161" : [ "02:41", "800000", "160420" ], + "160162" : [ "02:42", "800000", "160420" ], + "160163" : [ "02:43", "800000", "160420" ], + "160164" : [ "02:44", "800000", "160420" ], + "160165" : [ "02:45", "800000", "160420" ], + "160166" : [ "02:46", "800000", "160420" ], + "160167" : [ "02:47", "800000", "160420" ], + "160168" : [ "02:48", "800000", "160420" ], + "160169" : [ "02:49", "800000", "160420" ], + "160170" : [ "02:50", "800000", "160420" ], + "160171" : [ "02:51", "800000", "160420" ], + "160172" : [ "02:52", "800000", "160420" ], + "160173" : [ "02:53", "800000", "160420" ], + "160174" : [ "02:54", "800000", "160420" ], + "160175" : [ "02:55", "800000", "160420" ], + "160176" : [ "02:56", "800000", "160420" ], + "160177" : [ "02:57", "800000", "160420" ], + "160178" : [ "02:58", "800000", "160420" ], + "160179" : [ "02:59", "800000", "160420" ], + "160180" : [ "03:00", "800000", "160420" ], + "160181" : [ "03:01", "800000", "160420" ], + "160182" : [ "03:02", "800000", "160420" ], + "160183" : [ "03:03", "800000", "160420" ], + "160184" : [ "03:04", "800000", "160420" ], + "160185" : [ "03:05", "800000", "160420" ], + "160186" : [ "03:06", "800000", "160420" ], + "160187" : [ "03:07", "800000", "160420" ], + "160188" : [ "03:08", "800000", "160420" ], + "160189" : [ "03:09", "800000", "160420" ], + "160190" : [ "03:10", "800000", "160420" ], + "160191" : [ "03:11", "800000", "160420" ], + "160192" : [ "03:12", "800000", "160420" ], + "160193" : [ "03:13", "800000", "160420" ], + "160194" : [ "03:14", "800000", "160420" ], + "160195" : [ "03:15", "800000", "160420" ], + "160196" : [ "03:16", "800000", "160420" ], + "160197" : [ "03:17", "800000", "160420" ], + "160198" : [ "03:18", "800000", "160420" ], + "160199" : [ "03:19", "800000", "160420" ], + "160200" : [ "03:20", "800000", "160420" ], + "160201" : [ "03:21", "800000", "160420" ], + "160202" : [ "03:22", "800000", "160420" ], + "160203" : [ "03:23", "800000", "160420" ], + "160204" : [ "03:24", "800000", "160420" ], + "160205" : [ "03:25", "800000", "160420" ], + "160206" : [ "03:26", "800000", "160420" ], + "160207" : [ "03:27", "800000", "160420" ], + "160208" : [ "03:28", "800000", "160420" ], + "160209" : [ "03:29", "800000", "160420" ], + "160210" : [ "03:30", "800000", "160420" ], + "160211" : [ "03:31", "800000", "160420" ], + "160212" : [ "03:32", "800000", "160420" ], + "160213" : [ "03:33", "800000", "160420" ], + "160214" : [ "03:34", "800000", "160420" ], + "160215" : [ "03:35", "800000", "160420" ], + "160216" : [ "03:36", "800000", "160420" ], + "160217" : [ "03:37", "800000", "160420" ], + "160218" : [ "03:38", "800000", "160420" ], + "160219" : [ "03:39", "800000", "160420" ], + "160220" : [ "03:40", "800000", "160420" ], + "160221" : [ "03:41", "800000", "160420" ], + "160222" : [ "03:42", "800000", "160420" ], + "160223" : [ "03:43", "800000", "160420" ], + "160224" : [ "03:44", "800000", "160420" ], + "160225" : [ "03:45", "800000", "160420" ], + "160226" : [ "03:46", "800000", "160420" ], + "160227" : [ "03:47", "800000", "160420" ], + "160228" : [ "03:48", "800000", "160420" ], + "160229" : [ "03:49", "800000", "160420" ], + "160230" : [ "03:50", "800000", "160420" ], + "160231" : [ "03:51", "800000", "160420" ], + "160232" : [ "03:52", "800000", "160420" ], + "160233" : [ "03:53", "800000", "160420" ], + "160234" : [ "03:54", "800000", "160420" ], + "160235" : [ "03:55", "800000", "160420" ], + "160236" : [ "03:56", "800000", "160420" ], + "160237" : [ "03:57", "800000", "160420" ], + "160238" : [ "03:58", "800000", "160420" ], + "160239" : [ "03:59", "800000", "160420" ], + "160240" : [ "04:00", "800000", "160420" ], + "160241" : [ "04:01", "800000", "160420" ], + "160242" : [ "04:02", "800000", "160420" ], + "160243" : [ "04:03", "800000", "160420" ], + "160244" : [ "04:04", "800000", "160420" ], + "160245" : [ "04:05", "800000", "160420" ], + "160246" : [ "04:06", "800000", "160420" ], + "160247" : [ "04:07", "800000", "160420" ], + "160248" : [ "04:08", "800000", "160420" ], + "160249" : [ "04:09", "800000", "160420" ], + "160250" : [ "04:10", "800000", "160420" ], + "160251" : [ "04:11", "800000", "160420" ], + "160252" : [ "04:12", "800000", "160420" ], + "160253" : [ "04:13", "800000", "160420" ], + "160254" : [ "04:14", "800000", "160420" ], + "160255" : [ "04:15", "800000", "160420" ], + "160256" : [ "04:16", "800000", "160420" ], + "160257" : [ "04:17", "800000", "160420" ], + "160258" : [ "04:18", "800000", "160420" ], + "160259" : [ "04:19", "800000", "160420" ], + "160260" : [ "04:20", "800000", "160420" ], + "160261" : [ "04:21", "800000", "160420" ], + "160262" : [ "04:22", "800000", "160420" ], + "160263" : [ "04:23", "800000", "160420" ], + "160264" : [ "04:24", "800000", "160420" ], + "160265" : [ "04:25", "800000", "160420" ], + "160266" : [ "04:26", "800000", "160420" ], + "160267" : [ "04:27", "800000", "160420" ], + "160268" : [ "04:28", "800000", "160420" ], + "160269" : [ "04:29", "800000", "160420" ], + "160270" : [ "04:30", "800000", "160420" ], + "160271" : [ "04:31", "800000", "160420" ], + "160272" : [ "04:32", "800000", "160420" ], + "160273" : [ "04:33", "800000", "160420" ], + "160274" : [ "04:34", "800000", "160420" ], + "160275" : [ "04:35", "800000", "160420" ], + "160276" : [ "04:36", "800000", "160420" ], + "160277" : [ "04:37", "800000", "160420" ], + "160278" : [ "04:38", "800000", "160420" ], + "160279" : [ "04:39", "800000", "160420" ], + "160280" : [ "04:40", "800000", "160420" ], + "160281" : [ "04:41", "800000", "160420" ], + "160282" : [ "04:42", "800000", "160420" ], + "160283" : [ "04:43", "800000", "160420" ], + "160284" : [ "04:44", "800000", "160420" ], + "160285" : [ "04:45", "800000", "160420" ], + "160286" : [ "04:46", "800000", "160420" ], + "160287" : [ "04:47", "800000", "160420" ], + "160288" : [ "04:48", "800000", "160420" ], + "160289" : [ "04:49", "800000", "160420" ], + "160290" : [ "04:50", "800000", "160420" ], + "160291" : [ "04:51", "800000", "160420" ], + "160292" : [ "04:52", "800000", "160420" ], + "160293" : [ "04:53", "800000", "160420" ], + "160294" : [ "04:54", "800000", "160420" ], + "160295" : [ "04:55", "800000", "160420" ], + "160296" : [ "04:56", "800000", "160420" ], + "160297" : [ "04:57", "800000", "160420" ], + "160298" : [ "04:58", "800000", "160420" ], + "160299" : [ "04:59", "800000", "160420" ], + "160300" : [ "05:00", "800000", "160420" ], + "160301" : [ "05:01", "800000", "160420" ], + "160302" : [ "05:02", "800000", "160420" ], + "160303" : [ "05:03", "800000", "160420" ], + "160304" : [ "05:04", "800000", "160420" ], + "160305" : [ "05:05", "800000", "160420" ], + "160306" : [ "05:06", "800000", "160420" ], + "160307" : [ "05:07", "800000", "160420" ], + "160308" : [ "05:08", "800000", "160420" ], + "160309" : [ "05:09", "800000", "160420" ], + "160310" : [ "05:10", "800000", "160420" ], + "160311" : [ "05:11", "800000", "160420" ], + "160312" : [ "05:12", "800000", "160420" ], + "160313" : [ "05:13", "800000", "160420" ], + "160314" : [ "05:14", "800000", "160420" ], + "160315" : [ "05:15", "800000", "160420" ], + "160316" : [ "05:16", "800000", "160420" ], + "160317" : [ "05:17", "800000", "160420" ], + "160318" : [ "05:18", "800000", "160420" ], + "160319" : [ "05:19", "800000", "160420" ], + "160320" : [ "05:20", "800000", "160420" ], + "160321" : [ "05:21", "800000", "160420" ], + "160322" : [ "05:22", "800000", "160420" ], + "160323" : [ "05:23", "800000", "160420" ], + "160324" : [ "05:24", "800000", "160420" ], + "160325" : [ "05:25", "800000", "160420" ], + "160326" : [ "05:26", "800000", "160420" ], + "160327" : [ "05:27", "800000", "160420" ], + "160328" : [ "05:28", "800000", "160420" ], + "160329" : [ "05:29", "800000", "160420" ], + "160330" : [ "05:30", "800000", "160420" ], + "160331" : [ "05:31", "800000", "160420" ], + "160332" : [ "05:32", "800000", "160420" ], + "160333" : [ "05:33", "800000", "160420" ], + "160334" : [ "05:34", "800000", "160420" ], + "160335" : [ "05:35", "800000", "160420" ], + "160336" : [ "05:36", "800000", "160420" ], + "160337" : [ "05:37", "800000", "160420" ], + "160338" : [ "05:38", "800000", "160420" ], + "160339" : [ "05:39", "800000", "160420" ], + "160340" : [ "05:40", "800000", "160420" ], + "160341" : [ "05:41", "800000", "160420" ], + "160342" : [ "05:42", "800000", "160420" ], + "160343" : [ "05:43", "800000", "160420" ], + "160344" : [ "05:44", "800000", "160420" ], + "160345" : [ "05:45", "800000", "160420" ], + "160346" : [ "05:46", "800000", "160420" ], + "160347" : [ "05:47", "800000", "160420" ], + "160348" : [ "05:48", "800000", "160420" ], + "160349" : [ "05:49", "800000", "160420" ], + "160350" : [ "05:50", "800000", "160420" ], + "160351" : [ "05:51", "800000", "160420" ], + "160352" : [ "05:52", "800000", "160420" ], + "160353" : [ "05:53", "800000", "160420" ], + "160354" : [ "05:54", "800000", "160420" ], + "160355" : [ "05:55", "800000", "160420" ], + "160356" : [ "05:56", "800000", "160420" ], + "160357" : [ "05:57", "800000", "160420" ], + "160358" : [ "05:58", "800000", "160420" ], + "160359" : [ "05:59", "800000", "160420" ], + "160360" : [ "06:00", "800000", "160420" ], + "160361" : [ "06:01", "800000", "160420" ], + "160362" : [ "06:02", "800000", "160420" ], + "160363" : [ "06:03", "800000", "160420" ], + "160364" : [ "06:04", "800000", "160420" ], + "160365" : [ "06:05", "800000", "160420" ], + "160366" : [ "06:06", "800000", "160420" ], + "160367" : [ "06:07", "800000", "160420" ], + "160368" : [ "06:08", "800000", "160420" ], + "160369" : [ "06:09", "800000", "160420" ], + "160370" : [ "06:10", "800000", "160420" ], + "160371" : [ "06:11", "800000", "160420" ], + "160372" : [ "06:12", "800000", "160420" ], + "160373" : [ "06:13", "800000", "160420" ], + "160374" : [ "06:14", "800000", "160420" ], + "160375" : [ "06:15", "800000", "160420" ], + "160376" : [ "06:16", "800000", "160420" ], + "160377" : [ "06:17", "800000", "160420" ], + "160378" : [ "06:18", "800000", "160420" ], + "160379" : [ "06:19", "800000", "160420" ], + "160380" : [ "06:20", "800000", "160420" ], + "160381" : [ "06:21", "800000", "160420" ], + "160382" : [ "06:22", "800000", "160420" ], + "160383" : [ "06:23", "800000", "160420" ], + "160384" : [ "06:24", "800000", "160420" ], + "160385" : [ "06:25", "800000", "160420" ], + "160386" : [ "06:26", "800000", "160420" ], + "160387" : [ "06:27", "800000", "160420" ], + "160388" : [ "06:28", "800000", "160420" ], + "160389" : [ "06:29", "800000", "160420" ], + "160390" : [ "06:30", "800000", "160420" ], + "160391" : [ "06:31", "800000", "160420" ], + "160392" : [ "06:32", "800000", "160420" ], + "160393" : [ "06:33", "800000", "160420" ], + "160394" : [ "06:34", "800000", "160420" ], + "160395" : [ "06:35", "800000", "160420" ], + "160396" : [ "06:36", "800000", "160420" ], + "160397" : [ "06:37", "800000", "160420" ], + "160398" : [ "06:38", "800000", "160420" ], + "160399" : [ "06:39", "800000", "160420" ], + "160400" : [ "06:40", "800000", "160420" ], + "160401" : [ "06:41", "800000", "160420" ], + "160402" : [ "06:42", "800000", "160420" ], + "160403" : [ "06:43", "800000", "160420" ], + "160404" : [ "06:44", "800000", "160420" ], + "160405" : [ "06:45", "800000", "160420" ], + "160406" : [ "06:46", "800000", "160420" ], + "160407" : [ "06:47", "800000", "160420" ], + "160408" : [ "06:48", "800000", "160420" ], + "160409" : [ "06:49", "800000", "160420" ], + "160410" : [ "06:50", "800000", "160420" ], + "160411" : [ "06:51", "800000", "160420" ], + "160412" : [ "06:52", "800000", "160420" ], + "160413" : [ "06:53", "800000", "160420" ], + "160414" : [ "06:54", "800000", "160420" ], + "160415" : [ "06:55", "800000", "160420" ], + "160416" : [ "06:56", "800000", "160420" ], + "160417" : [ "06:57", "800000", "160420" ], + "160418" : [ "06:58", "800000", "160420" ], + "160419" : [ "06:59", "800000", "160420" ], + "160420" : [ "07:00", "350000", "160480" ], + "160421" : [ "07:01", "350000", "160481" ], + "160422" : [ "07:02", "350000", "160482" ], + "160423" : [ "07:03", "350000", "160483" ], + "160424" : [ "07:04", "350000", "160484" ], + "160425" : [ "07:05", "350000", "160485" ], + "160426" : [ "07:06", "350000", "160486" ], + "160427" : [ "07:07", "350000", "160487" ], + "160428" : [ "07:08", "350000", "160488" ], + "160429" : [ "07:09", "350000", "160489" ], + "160430" : [ "07:10", "350000", "160490" ], + "160431" : [ "07:11", "350000", "160491" ], + "160432" : [ "07:12", "350000", "160492" ], + "160433" : [ "07:13", "350000", "160493" ], + "160434" : [ "07:14", "350000", "160494" ], + "160435" : [ "07:15", "350000", "160495" ], + "160436" : [ "07:16", "350000", "160496" ], + "160437" : [ "07:17", "350000", "160497" ], + "160438" : [ "07:18", "350000", "160498" ], + "160439" : [ "07:19", "350000", "160499" ], + "160440" : [ "07:20", "350000", "160500" ], + "160441" : [ "07:21", "350000", "160501" ], + "160442" : [ "07:22", "350000", "160502" ], + "160443" : [ "07:23", "350000", "160503" ], + "160444" : [ "07:24", "350000", "160504" ], + "160445" : [ "07:25", "350000", "160505" ], + "160446" : [ "07:26", "350000", "160506" ], + "160447" : [ "07:27", "350000", "160507" ], + "160448" : [ "07:28", "350000", "160508" ], + "160449" : [ "07:29", "350000", "160509" ], + "160450" : [ "07:30", "350000", "160510" ], + "160451" : [ "07:31", "350000", "160511" ], + "160452" : [ "07:32", "350000", "160512" ], + "160453" : [ "07:33", "350000", "160513" ], + "160454" : [ "07:34", "350000", "160514" ], + "160455" : [ "07:35", "350000", "160515" ], + "160456" : [ "07:36", "350000", "160516" ], + "160457" : [ "07:37", "350000", "160517" ], + "160458" : [ "07:38", "350000", "160518" ], + "160459" : [ "07:39", "350000", "160519" ], + "160460" : [ "07:40", "350000", "160520" ], + "160461" : [ "07:41", "350000", "160521" ], + "160462" : [ "07:42", "350000", "160522" ], + "160463" : [ "07:43", "350000", "160523" ], + "160464" : [ "07:44", "350000", "160524" ], + "160465" : [ "07:45", "350000", "160525" ], + "160466" : [ "07:46", "350000", "160526" ], + "160467" : [ "07:47", "350000", "160527" ], + "160468" : [ "07:48", "350000", "160528" ], + "160469" : [ "07:49", "350000", "160529" ], + "160470" : [ "07:50", "350000", "160530" ], + "160471" : [ "07:51", "350000", "160531" ], + "160472" : [ "07:52", "350000", "160532" ], + "160473" : [ "07:53", "350000", "160533" ], + "160474" : [ "07:54", "350000", "160534" ], + "160475" : [ "07:55", "350000", "160535" ], + "160476" : [ "07:56", "350000", "160536" ], + "160477" : [ "07:57", "350000", "160537" ], + "160478" : [ "07:58", "350000", "160538" ], + "160479" : [ "07:59", "350000", "160539" ], + "160480" : [ "08:00", "350000", "160540" ], + "160481" : [ "08:01", "350000", "160541" ], + "160482" : [ "08:02", "350000", "160542" ], + "160483" : [ "08:03", "350000", "160543" ], + "160484" : [ "08:04", "350000", "160544" ], + "160485" : [ "08:05", "350000", "160545" ], + "160486" : [ "08:06", "350000", "160546" ], + "160487" : [ "08:07", "350000", "160547" ], + "160488" : [ "08:08", "350000", "160548" ], + "160489" : [ "08:09", "350000", "160549" ], + "160490" : [ "08:10", "350000", "160550" ], + "160491" : [ "08:11", "350000", "160551" ], + "160492" : [ "08:12", "350000", "160552" ], + "160493" : [ "08:13", "350000", "160553" ], + "160494" : [ "08:14", "350000", "160554" ], + "160495" : [ "08:15", "350000", "160555" ], + "160496" : [ "08:16", "350000", "160556" ], + "160497" : [ "08:17", "350000", "160557" ], + "160498" : [ "08:18", "350000", "160558" ], + "160499" : [ "08:19", "350000", "160559" ], + "160500" : [ "08:20", "350000", "160560" ], + "160501" : [ "08:21", "350000", "160561" ], + "160502" : [ "08:22", "350000", "160562" ], + "160503" : [ "08:23", "350000", "160563" ], + "160504" : [ "08:24", "350000", "160564" ], + "160505" : [ "08:25", "350000", "160565" ], + "160506" : [ "08:26", "350000", "160566" ], + "160507" : [ "08:27", "350000", "160567" ], + "160508" : [ "08:28", "350000", "160568" ], + "160509" : [ "08:29", "350000", "160569" ], + "160510" : [ "08:30", "350000", "160570" ], + "160511" : [ "08:31", "350000", "160571" ], + "160512" : [ "08:32", "350000", "160572" ], + "160513" : [ "08:33", "350000", "160573" ], + "160514" : [ "08:34", "350000", "160574" ], + "160515" : [ "08:35", "350000", "160575" ], + "160516" : [ "08:36", "350000", "160576" ], + "160517" : [ "08:37", "350000", "160577" ], + "160518" : [ "08:38", "350000", "160578" ], + "160519" : [ "08:39", "350000", "160579" ], + "160520" : [ "08:40", "350000", "160580" ], + "160521" : [ "08:41", "350000", "160581" ], + "160522" : [ "08:42", "350000", "160582" ], + "160523" : [ "08:43", "350000", "160583" ], + "160524" : [ "08:44", "350000", "160584" ], + "160525" : [ "08:45", "350000", "160585" ], + "160526" : [ "08:46", "350000", "160586" ], + "160527" : [ "08:47", "350000", "160587" ], + "160528" : [ "08:48", "350000", "160588" ], + "160529" : [ "08:49", "350000", "160589" ], + "160530" : [ "08:50", "350000", "160590" ], + "160531" : [ "08:51", "350000", "160591" ], + "160532" : [ "08:52", "350000", "160592" ], + "160533" : [ "08:53", "350000", "160593" ], + "160534" : [ "08:54", "350000", "160594" ], + "160535" : [ "08:55", "350000", "160595" ], + "160536" : [ "08:56", "350000", "160596" ], + "160537" : [ "08:57", "350000", "160597" ], + "160538" : [ "08:58", "350000", "160598" ], + "160539" : [ "08:59", "350000", "160599" ], + "160540" : [ "09:00", "350000", "160600" ], + "160541" : [ "09:01", "350000", "160601" ], + "160542" : [ "09:02", "350000", "160602" ], + "160543" : [ "09:03", "350000", "160603" ], + "160544" : [ "09:04", "350000", "160604" ], + "160545" : [ "09:05", "350000", "160605" ], + "160546" : [ "09:06", "350000", "160606" ], + "160547" : [ "09:07", "350000", "160607" ], + "160548" : [ "09:08", "350000", "160608" ], + "160549" : [ "09:09", "350000", "160609" ], + "160550" : [ "09:10", "350000", "160610" ], + "160551" : [ "09:11", "350000", "160611" ], + "160552" : [ "09:12", "350000", "160612" ], + "160553" : [ "09:13", "350000", "160613" ], + "160554" : [ "09:14", "350000", "160614" ], + "160555" : [ "09:15", "350000", "160615" ], + "160556" : [ "09:16", "350000", "160616" ], + "160557" : [ "09:17", "350000", "160617" ], + "160558" : [ "09:18", "350000", "160618" ], + "160559" : [ "09:19", "350000", "160619" ], + "160560" : [ "09:20", "350000", "160620" ], + "160561" : [ "09:21", "350000", "160621" ], + "160562" : [ "09:22", "350000", "160622" ], + "160563" : [ "09:23", "350000", "160623" ], + "160564" : [ "09:24", "350000", "160624" ], + "160565" : [ "09:25", "350000", "160625" ], + "160566" : [ "09:26", "350000", "160626" ], + "160567" : [ "09:27", "350000", "160627" ], + "160568" : [ "09:28", "350000", "160628" ], + "160569" : [ "09:29", "350000", "160629" ], + "160570" : [ "09:30", "350000", "160630" ], + "160571" : [ "09:31", "350000", "160631" ], + "160572" : [ "09:32", "350000", "160632" ], + "160573" : [ "09:33", "350000", "160633" ], + "160574" : [ "09:34", "350000", "160634" ], + "160575" : [ "09:35", "350000", "160635" ], + "160576" : [ "09:36", "350000", "160636" ], + "160577" : [ "09:37", "350000", "160637" ], + "160578" : [ "09:38", "350000", "160638" ], + "160579" : [ "09:39", "350000", "160639" ], + "160580" : [ "09:40", "350000", "160640" ], + "160581" : [ "09:41", "350000", "160641" ], + "160582" : [ "09:42", "350000", "160642" ], + "160583" : [ "09:43", "350000", "160643" ], + "160584" : [ "09:44", "350000", "160644" ], + "160585" : [ "09:45", "350000", "160645" ], + "160586" : [ "09:46", "350000", "160646" ], + "160587" : [ "09:47", "350000", "160647" ], + "160588" : [ "09:48", "350000", "160648" ], + "160589" : [ "09:49", "350000", "160649" ], + "160590" : [ "09:50", "350000", "160650" ], + "160591" : [ "09:51", "350000", "160651" ], + "160592" : [ "09:52", "350000", "160652" ], + "160593" : [ "09:53", "350000", "160653" ], + "160594" : [ "09:54", "350000", "160654" ], + "160595" : [ "09:55", "350000", "160655" ], + "160596" : [ "09:56", "350000", "160656" ], + "160597" : [ "09:57", "350000", "160657" ], + "160598" : [ "09:58", "350000", "160658" ], + "160599" : [ "09:59", "350000", "160659" ], + "160600" : [ "10:00", "350000", "160660" ], + "160601" : [ "10:01", "350000", "160661" ], + "160602" : [ "10:02", "350000", "160662" ], + "160603" : [ "10:03", "350000", "160663" ], + "160604" : [ "10:04", "350000", "160664" ], + "160605" : [ "10:05", "350000", "160665" ], + "160606" : [ "10:06", "350000", "160666" ], + "160607" : [ "10:07", "350000", "160667" ], + "160608" : [ "10:08", "350000", "160668" ], + "160609" : [ "10:09", "350000", "160669" ], + "160610" : [ "10:10", "350000", "160670" ], + "160611" : [ "10:11", "350000", "160671" ], + "160612" : [ "10:12", "350000", "160672" ], + "160613" : [ "10:13", "350000", "160673" ], + "160614" : [ "10:14", "350000", "160674" ], + "160615" : [ "10:15", "350000", "160675" ], + "160616" : [ "10:16", "350000", "160676" ], + "160617" : [ "10:17", "350000", "160677" ], + "160618" : [ "10:18", "350000", "160678" ], + "160619" : [ "10:19", "350000", "160679" ], + "160620" : [ "10:20", "350000", "160680" ], + "160621" : [ "10:21", "350000", "160681" ], + "160622" : [ "10:22", "350000", "160682" ], + "160623" : [ "10:23", "350000", "160683" ], + "160624" : [ "10:24", "350000", "160684" ], + "160625" : [ "10:25", "350000", "160685" ], + "160626" : [ "10:26", "350000", "160686" ], + "160627" : [ "10:27", "350000", "160687" ], + "160628" : [ "10:28", "350000", "160688" ], + "160629" : [ "10:29", "350000", "160689" ], + "160630" : [ "10:30", "350000", "160690" ], + "160631" : [ "10:31", "350000", "160691" ], + "160632" : [ "10:32", "350000", "160692" ], + "160633" : [ "10:33", "350000", "160693" ], + "160634" : [ "10:34", "350000", "160694" ], + "160635" : [ "10:35", "350000", "160695" ], + "160636" : [ "10:36", "350000", "160696" ], + "160637" : [ "10:37", "350000", "160697" ], + "160638" : [ "10:38", "350000", "160698" ], + "160639" : [ "10:39", "350000", "160699" ], + "160640" : [ "10:40", "350000", "160700" ], + "160641" : [ "10:41", "350000", "160701" ], + "160642" : [ "10:42", "350000", "160702" ], + "160643" : [ "10:43", "350000", "160703" ], + "160644" : [ "10:44", "350000", "160704" ], + "160645" : [ "10:45", "350000", "160705" ], + "160646" : [ "10:46", "350000", "160706" ], + "160647" : [ "10:47", "350000", "160707" ], + "160648" : [ "10:48", "350000", "160708" ], + "160649" : [ "10:49", "350000", "160709" ], + "160650" : [ "10:50", "350000", "160710" ], + "160651" : [ "10:51", "350000", "160711" ], + "160652" : [ "10:52", "350000", "160712" ], + "160653" : [ "10:53", "350000", "160713" ], + "160654" : [ "10:54", "350000", "160714" ], + "160655" : [ "10:55", "350000", "160715" ], + "160656" : [ "10:56", "350000", "160716" ], + "160657" : [ "10:57", "350000", "160717" ], + "160658" : [ "10:58", "350000", "160718" ], + "160659" : [ "10:59", "350000", "160719" ], + "160660" : [ "11:00", "350000", "160720" ], + "160661" : [ "11:01", "350000", "160721" ], + "160662" : [ "11:02", "350000", "160722" ], + "160663" : [ "11:03", "350000", "160723" ], + "160664" : [ "11:04", "350000", "160724" ], + "160665" : [ "11:05", "350000", "160725" ], + "160666" : [ "11:06", "350000", "160726" ], + "160667" : [ "11:07", "350000", "160727" ], + "160668" : [ "11:08", "350000", "160728" ], + "160669" : [ "11:09", "350000", "160729" ], + "160670" : [ "11:10", "350000", "160730" ], + "160671" : [ "11:11", "350000", "160731" ], + "160672" : [ "11:12", "350000", "160732" ], + "160673" : [ "11:13", "350000", "160733" ], + "160674" : [ "11:14", "350000", "160734" ], + "160675" : [ "11:15", "350000", "160735" ], + "160676" : [ "11:16", "350000", "160736" ], + "160677" : [ "11:17", "350000", "160737" ], + "160678" : [ "11:18", "350000", "160738" ], + "160679" : [ "11:19", "350000", "160739" ], + "160680" : [ "11:20", "350000", "160740" ], + "160681" : [ "11:21", "350000", "160741" ], + "160682" : [ "11:22", "350000", "160742" ], + "160683" : [ "11:23", "350000", "160743" ], + "160684" : [ "11:24", "350000", "160744" ], + "160685" : [ "11:25", "350000", "160745" ], + "160686" : [ "11:26", "350000", "160746" ], + "160687" : [ "11:27", "350000", "160747" ], + "160688" : [ "11:28", "350000", "160748" ], + "160689" : [ "11:29", "350000", "160749" ], + "160690" : [ "11:30", "350000", "160750" ], + "160691" : [ "11:31", "350000", "160751" ], + "160692" : [ "11:32", "350000", "160752" ], + "160693" : [ "11:33", "350000", "160753" ], + "160694" : [ "11:34", "350000", "160754" ], + "160695" : [ "11:35", "350000", "160755" ], + "160696" : [ "11:36", "350000", "160756" ], + "160697" : [ "11:37", "350000", "160757" ], + "160698" : [ "11:38", "350000", "160758" ], + "160699" : [ "11:39", "350000", "160759" ], + "160700" : [ "11:40", "350000", "160760" ], + "160701" : [ "11:41", "350000", "160761" ], + "160702" : [ "11:42", "350000", "160762" ], + "160703" : [ "11:43", "350000", "160763" ], + "160704" : [ "11:44", "350000", "160764" ], + "160705" : [ "11:45", "350000", "160765" ], + "160706" : [ "11:46", "350000", "160766" ], + "160707" : [ "11:47", "350000", "160767" ], + "160708" : [ "11:48", "350000", "160768" ], + "160709" : [ "11:49", "350000", "160769" ], + "160710" : [ "11:50", "350000", "160770" ], + "160711" : [ "11:51", "350000", "160771" ], + "160712" : [ "11:52", "350000", "160772" ], + "160713" : [ "11:53", "350000", "160773" ], + "160714" : [ "11:54", "350000", "160774" ], + "160715" : [ "11:55", "350000", "160775" ], + "160716" : [ "11:56", "350000", "160776" ], + "160717" : [ "11:57", "350000", "160777" ], + "160718" : [ "11:58", "350000", "160778" ], + "160719" : [ "11:59", "350000", "160779" ], + "160720" : [ "12:00", "350000", "160780" ], + "160721" : [ "12:01", "350000", "160781" ], + "160722" : [ "12:02", "350000", "160782" ], + "160723" : [ "12:03", "350000", "160783" ], + "160724" : [ "12:04", "350000", "160784" ], + "160725" : [ "12:05", "350000", "160785" ], + "160726" : [ "12:06", "350000", "160786" ], + "160727" : [ "12:07", "350000", "160787" ], + "160728" : [ "12:08", "350000", "160788" ], + "160729" : [ "12:09", "350000", "160789" ], + "160730" : [ "12:10", "350000", "160790" ], + "160731" : [ "12:11", "350000", "160791" ], + "160732" : [ "12:12", "350000", "160792" ], + "160733" : [ "12:13", "350000", "160793" ], + "160734" : [ "12:14", "350000", "160794" ], + "160735" : [ "12:15", "350000", "160795" ], + "160736" : [ "12:16", "350000", "160796" ], + "160737" : [ "12:17", "350000", "160797" ], + "160738" : [ "12:18", "350000", "160798" ], + "160739" : [ "12:19", "350000", "160799" ], + "160740" : [ "12:20", "350000", "160800" ], + "160741" : [ "12:21", "350000", "160801" ], + "160742" : [ "12:22", "350000", "160802" ], + "160743" : [ "12:23", "350000", "160803" ], + "160744" : [ "12:24", "350000", "160804" ], + "160745" : [ "12:25", "350000", "160805" ], + "160746" : [ "12:26", "350000", "160806" ], + "160747" : [ "12:27", "350000", "160807" ], + "160748" : [ "12:28", "350000", "160808" ], + "160749" : [ "12:29", "350000", "160809" ], + "160750" : [ "12:30", "350000", "160810" ], + "160751" : [ "12:31", "350000", "160811" ], + "160752" : [ "12:32", "350000", "160812" ], + "160753" : [ "12:33", "350000", "160813" ], + "160754" : [ "12:34", "350000", "160814" ], + "160755" : [ "12:35", "350000", "160815" ], + "160756" : [ "12:36", "350000", "160816" ], + "160757" : [ "12:37", "350000", "160817" ], + "160758" : [ "12:38", "350000", "160818" ], + "160759" : [ "12:39", "350000", "160819" ], + "160760" : [ "12:40", "350000", "160820" ], + "160761" : [ "12:41", "350000", "160821" ], + "160762" : [ "12:42", "350000", "160822" ], + "160763" : [ "12:43", "350000", "160823" ], + "160764" : [ "12:44", "350000", "160824" ], + "160765" : [ "12:45", "350000", "160825" ], + "160766" : [ "12:46", "350000", "160826" ], + "160767" : [ "12:47", "350000", "160827" ], + "160768" : [ "12:48", "350000", "160828" ], + "160769" : [ "12:49", "350000", "160829" ], + "160770" : [ "12:50", "350000", "160830" ], + "160771" : [ "12:51", "350000", "160831" ], + "160772" : [ "12:52", "350000", "160832" ], + "160773" : [ "12:53", "350000", "160833" ], + "160774" : [ "12:54", "350000", "160834" ], + "160775" : [ "12:55", "350000", "160835" ], + "160776" : [ "12:56", "350000", "160836" ], + "160777" : [ "12:57", "350000", "160837" ], + "160778" : [ "12:58", "350000", "160838" ], + "160779" : [ "12:59", "350000", "160839" ], + "160780" : [ "13:00", "350000", "160840" ], + "160781" : [ "13:01", "350000", "160841" ], + "160782" : [ "13:02", "350000", "160842" ], + "160783" : [ "13:03", "350000", "160843" ], + "160784" : [ "13:04", "350000", "160844" ], + "160785" : [ "13:05", "350000", "160845" ], + "160786" : [ "13:06", "350000", "160846" ], + "160787" : [ "13:07", "350000", "160847" ], + "160788" : [ "13:08", "350000", "160848" ], + "160789" : [ "13:09", "350000", "160849" ], + "160790" : [ "13:10", "350000", "160850" ], + "160791" : [ "13:11", "350000", "160851" ], + "160792" : [ "13:12", "350000", "160852" ], + "160793" : [ "13:13", "350000", "160853" ], + "160794" : [ "13:14", "350000", "160854" ], + "160795" : [ "13:15", "350000", "160855" ], + "160796" : [ "13:16", "350000", "160856" ], + "160797" : [ "13:17", "350000", "160857" ], + "160798" : [ "13:18", "350000", "160858" ], + "160799" : [ "13:19", "350000", "160859" ], + "160800" : [ "13:20", "350000", "160860" ], + "160801" : [ "13:21", "350000", "160861" ], + "160802" : [ "13:22", "350000", "160862" ], + "160803" : [ "13:23", "350000", "160863" ], + "160804" : [ "13:24", "350000", "160864" ], + "160805" : [ "13:25", "350000", "160865" ], + "160806" : [ "13:26", "350000", "160866" ], + "160807" : [ "13:27", "350000", "160867" ], + "160808" : [ "13:28", "350000", "160868" ], + "160809" : [ "13:29", "350000", "160869" ], + "160810" : [ "13:30", "350000", "160870" ], + "160811" : [ "13:31", "350000", "160871" ], + "160812" : [ "13:32", "350000", "160872" ], + "160813" : [ "13:33", "350000", "160873" ], + "160814" : [ "13:34", "350000", "160874" ], + "160815" : [ "13:35", "350000", "160875" ], + "160816" : [ "13:36", "350000", "160876" ], + "160817" : [ "13:37", "350000", "160877" ], + "160818" : [ "13:38", "350000", "160878" ], + "160819" : [ "13:39", "350000", "160879" ], + "160820" : [ "13:40", "350000", "160880" ], + "160821" : [ "13:41", "350000", "160881" ], + "160822" : [ "13:42", "350000", "160882" ], + "160823" : [ "13:43", "350000", "160883" ], + "160824" : [ "13:44", "350000", "160884" ], + "160825" : [ "13:45", "350000", "160885" ], + "160826" : [ "13:46", "350000", "160886" ], + "160827" : [ "13:47", "350000", "160887" ], + "160828" : [ "13:48", "350000", "160888" ], + "160829" : [ "13:49", "350000", "160889" ], + "160830" : [ "13:50", "350000", "160890" ], + "160831" : [ "13:51", "350000", "160891" ], + "160832" : [ "13:52", "350000", "160892" ], + "160833" : [ "13:53", "350000", "160893" ], + "160834" : [ "13:54", "350000", "160894" ], + "160835" : [ "13:55", "350000", "160895" ], + "160836" : [ "13:56", "350000", "160896" ], + "160837" : [ "13:57", "350000", "160897" ], + "160838" : [ "13:58", "350000", "160898" ], + "160839" : [ "13:59", "350000", "160899" ], + "160840" : [ "14:00", "350000", "160900" ], + "160841" : [ "14:01", "350000", "160901" ], + "160842" : [ "14:02", "350000", "160902" ], + "160843" : [ "14:03", "350000", "160903" ], + "160844" : [ "14:04", "350000", "160904" ], + "160845" : [ "14:05", "350000", "160905" ], + "160846" : [ "14:06", "350000", "160906" ], + "160847" : [ "14:07", "350000", "160907" ], + "160848" : [ "14:08", "350000", "160908" ], + "160849" : [ "14:09", "350000", "160909" ], + "160850" : [ "14:10", "350000", "160910" ], + "160851" : [ "14:11", "350000", "160911" ], + "160852" : [ "14:12", "350000", "160912" ], + "160853" : [ "14:13", "350000", "160913" ], + "160854" : [ "14:14", "350000", "160914" ], + "160855" : [ "14:15", "350000", "160915" ], + "160856" : [ "14:16", "350000", "160916" ], + "160857" : [ "14:17", "350000", "160917" ], + "160858" : [ "14:18", "350000", "160918" ], + "160859" : [ "14:19", "350000", "160919" ], + "160860" : [ "14:20", "350000", "160920" ], + "160861" : [ "14:21", "350000", "160921" ], + "160862" : [ "14:22", "350000", "160922" ], + "160863" : [ "14:23", "350000", "160923" ], + "160864" : [ "14:24", "350000", "160924" ], + "160865" : [ "14:25", "350000", "160925" ], + "160866" : [ "14:26", "350000", "160926" ], + "160867" : [ "14:27", "350000", "160927" ], + "160868" : [ "14:28", "350000", "160928" ], + "160869" : [ "14:29", "350000", "160929" ], + "160870" : [ "14:30", "350000", "160930" ], + "160871" : [ "14:31", "350000", "160931" ], + "160872" : [ "14:32", "350000", "160932" ], + "160873" : [ "14:33", "350000", "160933" ], + "160874" : [ "14:34", "350000", "160934" ], + "160875" : [ "14:35", "350000", "160935" ], + "160876" : [ "14:36", "350000", "160936" ], + "160877" : [ "14:37", "350000", "160937" ], + "160878" : [ "14:38", "350000", "160938" ], + "160879" : [ "14:39", "350000", "160939" ], + "160880" : [ "14:40", "350000", "160940" ], + "160881" : [ "14:41", "350000", "160941" ], + "160882" : [ "14:42", "350000", "160942" ], + "160883" : [ "14:43", "350000", "160943" ], + "160884" : [ "14:44", "350000", "160944" ], + "160885" : [ "14:45", "350000", "160945" ], + "160886" : [ "14:46", "350000", "160946" ], + "160887" : [ "14:47", "350000", "160947" ], + "160888" : [ "14:48", "350000", "160948" ], + "160889" : [ "14:49", "350000", "160949" ], + "160890" : [ "14:50", "350000", "160950" ], + "160891" : [ "14:51", "350000", "160951" ], + "160892" : [ "14:52", "350000", "160952" ], + "160893" : [ "14:53", "350000", "160953" ], + "160894" : [ "14:54", "350000", "160954" ], + "160895" : [ "14:55", "350000", "160955" ], + "160896" : [ "14:56", "350000", "160956" ], + "160897" : [ "14:57", "350000", "160957" ], + "160898" : [ "14:58", "350000", "160958" ], + "160899" : [ "14:59", "350000", "160959" ], + "160900" : [ "15:00", "350000", "160960" ], + "160901" : [ "15:01", "350000", "160961" ], + "160902" : [ "15:02", "350000", "160962" ], + "160903" : [ "15:03", "350000", "160963" ], + "160904" : [ "15:04", "350000", "160964" ], + "160905" : [ "15:05", "350000", "160965" ], + "160906" : [ "15:06", "350000", "160966" ], + "160907" : [ "15:07", "350000", "160967" ], + "160908" : [ "15:08", "350000", "160968" ], + "160909" : [ "15:09", "350000", "160969" ], + "160910" : [ "15:10", "350000", "160970" ], + "160911" : [ "15:11", "350000", "160971" ], + "160912" : [ "15:12", "350000", "160972" ], + "160913" : [ "15:13", "350000", "160973" ], + "160914" : [ "15:14", "350000", "160974" ], + "160915" : [ "15:15", "350000", "160975" ], + "160916" : [ "15:16", "350000", "160976" ], + "160917" : [ "15:17", "350000", "160977" ], + "160918" : [ "15:18", "350000", "160978" ], + "160919" : [ "15:19", "350000", "160979" ], + "160920" : [ "15:20", "350000", "160980" ], + "160921" : [ "15:21", "350000", "160981" ], + "160922" : [ "15:22", "350000", "160982" ], + "160923" : [ "15:23", "350000", "160983" ], + "160924" : [ "15:24", "350000", "160984" ], + "160925" : [ "15:25", "350000", "160985" ], + "160926" : [ "15:26", "350000", "160986" ], + "160927" : [ "15:27", "350000", "160987" ], + "160928" : [ "15:28", "350000", "160988" ], + "160929" : [ "15:29", "350000", "160989" ], + "160930" : [ "15:30", "350000", "160990" ], + "160931" : [ "15:31", "350000", "160991" ], + "160932" : [ "15:32", "350000", "160992" ], + "160933" : [ "15:33", "350000", "160993" ], + "160934" : [ "15:34", "350000", "160994" ], + "160935" : [ "15:35", "350000", "160995" ], + "160936" : [ "15:36", "350000", "160996" ], + "160937" : [ "15:37", "350000", "160997" ], + "160938" : [ "15:38", "350000", "160998" ], + "160939" : [ "15:39", "350000", "160999" ], + "160940" : [ "15:40", "350000", "161000" ], + "160941" : [ "15:41", "350000", "161001" ], + "160942" : [ "15:42", "350000", "161002" ], + "160943" : [ "15:43", "350000", "161003" ], + "160944" : [ "15:44", "350000", "161004" ], + "160945" : [ "15:45", "350000", "161005" ], + "160946" : [ "15:46", "350000", "161006" ], + "160947" : [ "15:47", "350000", "161007" ], + "160948" : [ "15:48", "350000", "161008" ], + "160949" : [ "15:49", "350000", "161009" ], + "160950" : [ "15:50", "350000", "161010" ], + "160951" : [ "15:51", "350000", "161011" ], + "160952" : [ "15:52", "350000", "161012" ], + "160953" : [ "15:53", "350000", "161013" ], + "160954" : [ "15:54", "350000", "161014" ], + "160955" : [ "15:55", "350000", "161015" ], + "160956" : [ "15:56", "350000", "161016" ], + "160957" : [ "15:57", "350000", "161017" ], + "160958" : [ "15:58", "350000", "161018" ], + "160959" : [ "15:59", "350000", "161019" ], + "160960" : [ "16:00", "350000", "161020" ], + "160961" : [ "16:01", "350000", "161021" ], + "160962" : [ "16:02", "350000", "161022" ], + "160963" : [ "16:03", "350000", "161023" ], + "160964" : [ "16:04", "350000", "161024" ], + "160965" : [ "16:05", "350000", "161025" ], + "160966" : [ "16:06", "350000", "161026" ], + "160967" : [ "16:07", "350000", "161027" ], + "160968" : [ "16:08", "350000", "161028" ], + "160969" : [ "16:09", "350000", "161029" ], + "160970" : [ "16:10", "350000", "161030" ], + "160971" : [ "16:11", "350000", "161031" ], + "160972" : [ "16:12", "350000", "161032" ], + "160973" : [ "16:13", "350000", "161033" ], + "160974" : [ "16:14", "350000", "161034" ], + "160975" : [ "16:15", "350000", "161035" ], + "160976" : [ "16:16", "350000", "161036" ], + "160977" : [ "16:17", "350000", "161037" ], + "160978" : [ "16:18", "350000", "161038" ], + "160979" : [ "16:19", "350000", "161039" ], + "160980" : [ "16:20", "350000", "161040" ], + "160981" : [ "16:21", "350000", "161041" ], + "160982" : [ "16:22", "350000", "161042" ], + "160983" : [ "16:23", "350000", "161043" ], + "160984" : [ "16:24", "350000", "161044" ], + "160985" : [ "16:25", "350000", "161045" ], + "160986" : [ "16:26", "350000", "161046" ], + "160987" : [ "16:27", "350000", "161047" ], + "160988" : [ "16:28", "350000", "161048" ], + "160989" : [ "16:29", "350000", "161049" ], + "160990" : [ "16:30", "350000", "161050" ], + "160991" : [ "16:31", "350000", "161051" ], + "160992" : [ "16:32", "350000", "161052" ], + "160993" : [ "16:33", "350000", "161053" ], + "160994" : [ "16:34", "350000", "161054" ], + "160995" : [ "16:35", "350000", "161055" ], + "160996" : [ "16:36", "350000", "161056" ], + "160997" : [ "16:37", "350000", "161057" ], + "160998" : [ "16:38", "350000", "161058" ], + "160999" : [ "16:39", "350000", "161059" ], + "161000" : [ "16:40", "350000", "161060" ], + "161001" : [ "16:41", "350000", "161061" ], + "161002" : [ "16:42", "350000", "161062" ], + "161003" : [ "16:43", "350000", "161063" ], + "161004" : [ "16:44", "350000", "161064" ], + "161005" : [ "16:45", "350000", "161065" ], + "161006" : [ "16:46", "350000", "161066" ], + "161007" : [ "16:47", "350000", "161067" ], + "161008" : [ "16:48", "350000", "161068" ], + "161009" : [ "16:49", "350000", "161069" ], + "161010" : [ "16:50", "350000", "161070" ], + "161011" : [ "16:51", "350000", "161071" ], + "161012" : [ "16:52", "350000", "161072" ], + "161013" : [ "16:53", "350000", "161073" ], + "161014" : [ "16:54", "350000", "161074" ], + "161015" : [ "16:55", "350000", "161075" ], + "161016" : [ "16:56", "350000", "161076" ], + "161017" : [ "16:57", "350000", "161077" ], + "161018" : [ "16:58", "350000", "161078" ], + "161019" : [ "16:59", "350000", "161079" ], + "161020" : [ "17:00", "350000", "161080" ], + "161021" : [ "17:01", "350000", "161081" ], + "161022" : [ "17:02", "350000", "161082" ], + "161023" : [ "17:03", "350000", "161083" ], + "161024" : [ "17:04", "350000", "161084" ], + "161025" : [ "17:05", "350000", "161085" ], + "161026" : [ "17:06", "350000", "161086" ], + "161027" : [ "17:07", "350000", "161087" ], + "161028" : [ "17:08", "350000", "161088" ], + "161029" : [ "17:09", "350000", "161089" ], + "161030" : [ "17:10", "350000", "161090" ], + "161031" : [ "17:11", "350000", "161091" ], + "161032" : [ "17:12", "350000", "161092" ], + "161033" : [ "17:13", "350000", "161093" ], + "161034" : [ "17:14", "350000", "161094" ], + "161035" : [ "17:15", "350000", "161095" ], + "161036" : [ "17:16", "350000", "161096" ], + "161037" : [ "17:17", "350000", "161097" ], + "161038" : [ "17:18", "350000", "161098" ], + "161039" : [ "17:19", "350000", "161099" ], + "161040" : [ "17:20", "350000", "161100" ], + "161041" : [ "17:21", "350000", "161101" ], + "161042" : [ "17:22", "350000", "161102" ], + "161043" : [ "17:23", "350000", "161103" ], + "161044" : [ "17:24", "350000", "161104" ], + "161045" : [ "17:25", "350000", "161105" ], + "161046" : [ "17:26", "350000", "161106" ], + "161047" : [ "17:27", "350000", "161107" ], + "161048" : [ "17:28", "350000", "161108" ], + "161049" : [ "17:29", "350000", "161109" ], + "161050" : [ "17:30", "350000", "161110" ], + "161051" : [ "17:31", "350000", "161111" ], + "161052" : [ "17:32", "350000", "161112" ], + "161053" : [ "17:33", "350000", "161113" ], + "161054" : [ "17:34", "350000", "161114" ], + "161055" : [ "17:35", "350000", "161115" ], + "161056" : [ "17:36", "350000", "161116" ], + "161057" : [ "17:37", "350000", "161117" ], + "161058" : [ "17:38", "350000", "161118" ], + "161059" : [ "17:39", "350000", "161119" ], + "161060" : [ "17:40", "350000", "161120" ], + "161061" : [ "17:41", "350000", "161121" ], + "161062" : [ "17:42", "350000", "161122" ], + "161063" : [ "17:43", "350000", "161123" ], + "161064" : [ "17:44", "350000", "161124" ], + "161065" : [ "17:45", "350000", "161125" ], + "161066" : [ "17:46", "350000", "161126" ], + "161067" : [ "17:47", "350000", "161127" ], + "161068" : [ "17:48", "350000", "161128" ], + "161069" : [ "17:49", "350000", "161129" ], + "161070" : [ "17:50", "350000", "161130" ], + "161071" : [ "17:51", "350000", "161131" ], + "161072" : [ "17:52", "350000", "161132" ], + "161073" : [ "17:53", "350000", "161133" ], + "161074" : [ "17:54", "350000", "161134" ], + "161075" : [ "17:55", "350000", "161135" ], + "161076" : [ "17:56", "350000", "161136" ], + "161077" : [ "17:57", "350000", "161137" ], + "161078" : [ "17:58", "350000", "161138" ], + "161079" : [ "17:59", "350000", "161139" ], + "161080" : [ "18:00", "350000", "161140" ], + "161081" : [ "18:01", "350000", "161141" ], + "161082" : [ "18:02", "350000", "161142" ], + "161083" : [ "18:03", "350000", "161143" ], + "161084" : [ "18:04", "350000", "161144" ], + "161085" : [ "18:05", "350000", "161145" ], + "161086" : [ "18:06", "350000", "161146" ], + "161087" : [ "18:07", "350000", "161147" ], + "161088" : [ "18:08", "350000", "161148" ], + "161089" : [ "18:09", "350000", "161149" ], + "161090" : [ "18:10", "350000", "161150" ], + "161091" : [ "18:11", "350000", "161151" ], + "161092" : [ "18:12", "350000", "161152" ], + "161093" : [ "18:13", "350000", "161153" ], + "161094" : [ "18:14", "350000", "161154" ], + "161095" : [ "18:15", "350000", "161155" ], + "161096" : [ "18:16", "350000", "161156" ], + "161097" : [ "18:17", "350000", "161157" ], + "161098" : [ "18:18", "350000", "161158" ], + "161099" : [ "18:19", "350000", "161159" ], + "161100" : [ "18:20", "350000", "161160" ], + "161101" : [ "18:21", "350000", "161161" ], + "161102" : [ "18:22", "350000", "161162" ], + "161103" : [ "18:23", "350000", "161163" ], + "161104" : [ "18:24", "350000", "161164" ], + "161105" : [ "18:25", "350000", "161165" ], + "161106" : [ "18:26", "350000", "161166" ], + "161107" : [ "18:27", "350000", "161167" ], + "161108" : [ "18:28", "350000", "161168" ], + "161109" : [ "18:29", "350000", "161169" ], + "161110" : [ "18:30", "350000", "161170" ], + "161111" : [ "18:31", "350000", "161171" ], + "161112" : [ "18:32", "350000", "161172" ], + "161113" : [ "18:33", "350000", "161173" ], + "161114" : [ "18:34", "350000", "161174" ], + "161115" : [ "18:35", "350000", "161175" ], + "161116" : [ "18:36", "350000", "161176" ], + "161117" : [ "18:37", "350000", "161177" ], + "161118" : [ "18:38", "350000", "161178" ], + "161119" : [ "18:39", "350000", "161179" ], + "161120" : [ "18:40", "350000", "161180" ], + "161121" : [ "18:41", "350000", "161181" ], + "161122" : [ "18:42", "350000", "161182" ], + "161123" : [ "18:43", "350000", "161183" ], + "161124" : [ "18:44", "350000", "161184" ], + "161125" : [ "18:45", "350000", "161185" ], + "161126" : [ "18:46", "350000", "161186" ], + "161127" : [ "18:47", "350000", "161187" ], + "161128" : [ "18:48", "350000", "161188" ], + "161129" : [ "18:49", "350000", "161189" ], + "161130" : [ "18:50", "350000", "161190" ], + "161131" : [ "18:51", "350000", "161191" ], + "161132" : [ "18:52", "350000", "161192" ], + "161133" : [ "18:53", "350000", "161193" ], + "161134" : [ "18:54", "350000", "161194" ], + "161135" : [ "18:55", "350000", "161195" ], + "161136" : [ "18:56", "350000", "161196" ], + "161137" : [ "18:57", "350000", "161197" ], + "161138" : [ "18:58", "350000", "161198" ], + "161139" : [ "18:59", "350000", "161199" ], + "161140" : [ "19:00", "350000", "161200" ], + "161141" : [ "19:01", "350000", "161200" ], + "161142" : [ "19:02", "350000", "161200" ], + "161143" : [ "19:03", "350000", "161200" ], + "161144" : [ "19:04", "350000", "161200" ], + "161145" : [ "19:05", "350000", "161200" ], + "161146" : [ "19:06", "350000", "161200" ], + "161147" : [ "19:07", "350000", "161200" ], + "161148" : [ "19:08", "350000", "161200" ], + "161149" : [ "19:09", "350000", "161200" ], + "161150" : [ "19:10", "350000", "161200" ], + "161151" : [ "19:11", "350000", "161200" ], + "161152" : [ "19:12", "350000", "161200" ], + "161153" : [ "19:13", "350000", "161200" ], + "161154" : [ "19:14", "350000", "161200" ], + "161155" : [ "19:15", "350000", "161200" ], + "161156" : [ "19:16", "350000", "161200" ], + "161157" : [ "19:17", "350000", "161200" ], + "161158" : [ "19:18", "350000", "161200" ], + "161159" : [ "19:19", "350000", "161200" ], + "161160" : [ "19:20", "350000", "161200" ], + "161161" : [ "19:21", "350000", "161200" ], + "161162" : [ "19:22", "350000", "161200" ], + "161163" : [ "19:23", "350000", "161200" ], + "161164" : [ "19:24", "350000", "161200" ], + "161165" : [ "19:25", "350000", "161200" ], + "161166" : [ "19:26", "350000", "161200" ], + "161167" : [ "19:27", "350000", "161200" ], + "161168" : [ "19:28", "350000", "161200" ], + "161169" : [ "19:29", "350000", "161200" ], + "161170" : [ "19:30", "350000", "161200" ], + "161171" : [ "19:31", "350000", "161200" ], + "161172" : [ "19:32", "350000", "161200" ], + "161173" : [ "19:33", "350000", "161200" ], + "161174" : [ "19:34", "350000", "161200" ], + "161175" : [ "19:35", "350000", "161200" ], + "161176" : [ "19:36", "350000", "161200" ], + "161177" : [ "19:37", "350000", "161200" ], + "161178" : [ "19:38", "350000", "161200" ], + "161179" : [ "19:39", "350000", "161200" ], + "161180" : [ "19:40", "350000", "161200" ], + "161181" : [ "19:41", "350000", "161200" ], + "161182" : [ "19:42", "350000", "161200" ], + "161183" : [ "19:43", "350000", "161200" ], + "161184" : [ "19:44", "350000", "161200" ], + "161185" : [ "19:45", "350000", "161200" ], + "161186" : [ "19:46", "350000", "161200" ], + "161187" : [ "19:47", "350000", "161200" ], + "161188" : [ "19:48", "350000", "161200" ], + "161189" : [ "19:49", "350000", "161200" ], + "161190" : [ "19:50", "350000", "161200" ], + "161191" : [ "19:51", "350000", "161200" ], + "161192" : [ "19:52", "350000", "161200" ], + "161193" : [ "19:53", "350000", "161200" ], + "161194" : [ "19:54", "350000", "161200" ], + "161195" : [ "19:55", "350000", "161200" ], + "161196" : [ "19:56", "350000", "161200" ], + "161197" : [ "19:57", "350000", "161200" ], + "161198" : [ "19:58", "350000", "161200" ], + "161199" : [ "19:59", "350000", "161200" ], + "161200" : [ "20:00", "800000", "260420" ], + "161201" : [ "20:01", "800000", "260420" ], + "161202" : [ "20:02", "800000", "260420" ], + "161203" : [ "20:03", "800000", "260420" ], + "161204" : [ "20:04", "800000", "260420" ], + "161205" : [ "20:05", "800000", "260420" ], + "161206" : [ "20:06", "800000", "260420" ], + "161207" : [ "20:07", "800000", "260420" ], + "161208" : [ "20:08", "800000", "260420" ], + "161209" : [ "20:09", "800000", "260420" ], + "161210" : [ "20:10", "800000", "260420" ], + "161211" : [ "20:11", "800000", "260420" ], + "161212" : [ "20:12", "800000", "260420" ], + "161213" : [ "20:13", "800000", "260420" ], + "161214" : [ "20:14", "800000", "260420" ], + "161215" : [ "20:15", "800000", "260420" ], + "161216" : [ "20:16", "800000", "260420" ], + "161217" : [ "20:17", "800000", "260420" ], + "161218" : [ "20:18", "800000", "260420" ], + "161219" : [ "20:19", "800000", "260420" ], + "161220" : [ "20:20", "800000", "260420" ], + "161221" : [ "20:21", "800000", "260420" ], + "161222" : [ "20:22", "800000", "260420" ], + "161223" : [ "20:23", "800000", "260420" ], + "161224" : [ "20:24", "800000", "260420" ], + "161225" : [ "20:25", "800000", "260420" ], + "161226" : [ "20:26", "800000", "260420" ], + "161227" : [ "20:27", "800000", "260420" ], + "161228" : [ "20:28", "800000", "260420" ], + "161229" : [ "20:29", "800000", "260420" ], + "161230" : [ "20:30", "800000", "260420" ], + "161231" : [ "20:31", "800000", "260420" ], + "161232" : [ "20:32", "800000", "260420" ], + "161233" : [ "20:33", "800000", "260420" ], + "161234" : [ "20:34", "800000", "260420" ], + "161235" : [ "20:35", "800000", "260420" ], + "161236" : [ "20:36", "800000", "260420" ], + "161237" : [ "20:37", "800000", "260420" ], + "161238" : [ "20:38", "800000", "260420" ], + "161239" : [ "20:39", "800000", "260420" ], + "161240" : [ "20:40", "800000", "260420" ], + "161241" : [ "20:41", "800000", "260420" ], + "161242" : [ "20:42", "800000", "260420" ], + "161243" : [ "20:43", "800000", "260420" ], + "161244" : [ "20:44", "800000", "260420" ], + "161245" : [ "20:45", "800000", "260420" ], + "161246" : [ "20:46", "800000", "260420" ], + "161247" : [ "20:47", "800000", "260420" ], + "161248" : [ "20:48", "800000", "260420" ], + "161249" : [ "20:49", "800000", "260420" ], + "161250" : [ "20:50", "800000", "260420" ], + "161251" : [ "20:51", "800000", "260420" ], + "161252" : [ "20:52", "800000", "260420" ], + "161253" : [ "20:53", "800000", "260420" ], + "161254" : [ "20:54", "800000", "260420" ], + "161255" : [ "20:55", "800000", "260420" ], + "161256" : [ "20:56", "800000", "260420" ], + "161257" : [ "20:57", "800000", "260420" ], + "161258" : [ "20:58", "800000", "260420" ], + "161259" : [ "20:59", "800000", "260420" ], + "161260" : [ "21:00", "800000", "260420" ], + "161261" : [ "21:01", "800000", "260420" ], + "161262" : [ "21:02", "800000", "260420" ], + "161263" : [ "21:03", "800000", "260420" ], + "161264" : [ "21:04", "800000", "260420" ], + "161265" : [ "21:05", "800000", "260420" ], + "161266" : [ "21:06", "800000", "260420" ], + "161267" : [ "21:07", "800000", "260420" ], + "161268" : [ "21:08", "800000", "260420" ], + "161269" : [ "21:09", "800000", "260420" ], + "161270" : [ "21:10", "800000", "260420" ], + "161271" : [ "21:11", "800000", "260420" ], + "161272" : [ "21:12", "800000", "260420" ], + "161273" : [ "21:13", "800000", "260420" ], + "161274" : [ "21:14", "800000", "260420" ], + "161275" : [ "21:15", "800000", "260420" ], + "161276" : [ "21:16", "800000", "260420" ], + "161277" : [ "21:17", "800000", "260420" ], + "161278" : [ "21:18", "800000", "260420" ], + "161279" : [ "21:19", "800000", "260420" ], + "161280" : [ "21:20", "800000", "260420" ], + "161281" : [ "21:21", "800000", "260420" ], + "161282" : [ "21:22", "800000", "260420" ], + "161283" : [ "21:23", "800000", "260420" ], + "161284" : [ "21:24", "800000", "260420" ], + "161285" : [ "21:25", "800000", "260420" ], + "161286" : [ "21:26", "800000", "260420" ], + "161287" : [ "21:27", "800000", "260420" ], + "161288" : [ "21:28", "800000", "260420" ], + "161289" : [ "21:29", "800000", "260420" ], + "161290" : [ "21:30", "800000", "260420" ], + "161291" : [ "21:31", "800000", "260420" ], + "161292" : [ "21:32", "800000", "260420" ], + "161293" : [ "21:33", "800000", "260420" ], + "161294" : [ "21:34", "800000", "260420" ], + "161295" : [ "21:35", "800000", "260420" ], + "161296" : [ "21:36", "800000", "260420" ], + "161297" : [ "21:37", "800000", "260420" ], + "161298" : [ "21:38", "800000", "260420" ], + "161299" : [ "21:39", "800000", "260420" ], + "161300" : [ "21:40", "800000", "200420" ], + "161301" : [ "21:41", "800000", "200420" ], + "161302" : [ "21:42", "800000", "200420" ], + "161303" : [ "21:43", "800000", "200420" ], + "161304" : [ "21:44", "800000", "200420" ], + "161305" : [ "21:45", "800000", "200420" ], + "161306" : [ "21:46", "800000", "200420" ], + "161307" : [ "21:47", "800000", "200420" ], + "161308" : [ "21:48", "800000", "200420" ], + "161309" : [ "21:49", "800000", "200420" ], + "161310" : [ "21:50", "800000", "200420" ], + "161311" : [ "21:51", "800000", "200420" ], + "161312" : [ "21:52", "800000", "200420" ], + "161313" : [ "21:53", "800000", "200420" ], + "161314" : [ "21:54", "800000", "200420" ], + "161315" : [ "21:55", "800000", "200420" ], + "161316" : [ "21:56", "800000", "200420" ], + "161317" : [ "21:57", "800000", "200420" ], + "161318" : [ "21:58", "800000", "200420" ], + "161319" : [ "21:59", "800000", "200420" ], + "161320" : [ "22:00", "800000", "200420" ], + "161321" : [ "22:01", "800000", "200420" ], + "161322" : [ "22:02", "800000", "200420" ], + "161323" : [ "22:03", "800000", "200420" ], + "161324" : [ "22:04", "800000", "200420" ], + "161325" : [ "22:05", "800000", "200420" ], + "161326" : [ "22:06", "800000", "200420" ], + "161327" : [ "22:07", "800000", "200420" ], + "161328" : [ "22:08", "800000", "200420" ], + "161329" : [ "22:09", "800000", "200420" ], + "161330" : [ "22:10", "800000", "200420" ], + "161331" : [ "22:11", "800000", "200420" ], + "161332" : [ "22:12", "800000", "200420" ], + "161333" : [ "22:13", "800000", "200420" ], + "161334" : [ "22:14", "800000", "200420" ], + "161335" : [ "22:15", "800000", "200420" ], + "161336" : [ "22:16", "800000", "200420" ], + "161337" : [ "22:17", "800000", "200420" ], + "161338" : [ "22:18", "800000", "200420" ], + "161339" : [ "22:19", "800000", "200420" ], + "161340" : [ "22:20", "800000", "200420" ], + "161341" : [ "22:21", "800000", "200420" ], + "161342" : [ "22:22", "800000", "200420" ], + "161343" : [ "22:23", "800000", "200420" ], + "161344" : [ "22:24", "800000", "200420" ], + "161345" : [ "22:25", "800000", "200420" ], + "161346" : [ "22:26", "800000", "200420" ], + "161347" : [ "22:27", "800000", "200420" ], + "161348" : [ "22:28", "800000", "200420" ], + "161349" : [ "22:29", "800000", "200420" ], + "161350" : [ "22:30", "800000", "200420" ], + "161351" : [ "22:31", "800000", "200420" ], + "161352" : [ "22:32", "800000", "200420" ], + "161353" : [ "22:33", "800000", "200420" ], + "161354" : [ "22:34", "800000", "200420" ], + "161355" : [ "22:35", "800000", "200420" ], + "161356" : [ "22:36", "800000", "200420" ], + "161357" : [ "22:37", "800000", "200420" ], + "161358" : [ "22:38", "800000", "200420" ], + "161359" : [ "22:39", "800000", "200420" ], + "161360" : [ "22:40", "800000", "200420" ], + "161361" : [ "22:41", "800000", "200420" ], + "161362" : [ "22:42", "800000", "200420" ], + "161363" : [ "22:43", "800000", "200420" ], + "161364" : [ "22:44", "800000", "200420" ], + "161365" : [ "22:45", "800000", "200420" ], + "161366" : [ "22:46", "800000", "200420" ], + "161367" : [ "22:47", "800000", "200420" ], + "161368" : [ "22:48", "800000", "200420" ], + "161369" : [ "22:49", "800000", "200420" ], + "161370" : [ "22:50", "800000", "200420" ], + "161371" : [ "22:51", "800000", "200420" ], + "161372" : [ "22:52", "800000", "200420" ], + "161373" : [ "22:53", "800000", "200420" ], + "161374" : [ "22:54", "800000", "200420" ], + "161375" : [ "22:55", "800000", "200420" ], + "161376" : [ "22:56", "800000", "200420" ], + "161377" : [ "22:57", "800000", "200420" ], + "161378" : [ "22:58", "800000", "200420" ], + "161379" : [ "22:59", "800000", "200420" ], + "161380" : [ "23:00", "800000", "200420" ], + "161381" : [ "23:01", "800000", "200420" ], + "161382" : [ "23:02", "800000", "200420" ], + "161383" : [ "23:03", "800000", "200420" ], + "161384" : [ "23:04", "800000", "200420" ], + "161385" : [ "23:05", "800000", "200420" ], + "161386" : [ "23:06", "800000", "200420" ], + "161387" : [ "23:07", "800000", "200420" ], + "161388" : [ "23:08", "800000", "200420" ], + "161389" : [ "23:09", "800000", "200420" ], + "161390" : [ "23:10", "800000", "200420" ], + "161391" : [ "23:11", "800000", "200420" ], + "161392" : [ "23:12", "800000", "200420" ], + "161393" : [ "23:13", "800000", "200420" ], + "161394" : [ "23:14", "800000", "200420" ], + "161395" : [ "23:15", "800000", "200420" ], + "161396" : [ "23:16", "800000", "200420" ], + "161397" : [ "23:17", "800000", "200420" ], + "161398" : [ "23:18", "800000", "200420" ], + "161399" : [ "23:19", "800000", "200420" ], + "161400" : [ "23:20", "800000", "200420" ], + "161401" : [ "23:21", "800000", "200420" ], + "161402" : [ "23:22", "800000", "200420" ], + "161403" : [ "23:23", "800000", "200420" ], + "161404" : [ "23:24", "800000", "200420" ], + "161405" : [ "23:25", "800000", "200420" ], + "161406" : [ "23:26", "800000", "200420" ], + "161407" : [ "23:27", "800000", "200420" ], + "161408" : [ "23:28", "800000", "200420" ], + "161409" : [ "23:29", "800000", "200420" ], + "161410" : [ "23:30", "800000", "200420" ], + "161411" : [ "23:31", "800000", "200420" ], + "161412" : [ "23:32", "800000", "200420" ], + "161413" : [ "23:33", "800000", "200420" ], + "161414" : [ "23:34", "800000", "200420" ], + "161415" : [ "23:35", "800000", "200420" ], + "161416" : [ "23:36", "800000", "200420" ], + "161417" : [ "23:37", "800000", "200420" ], + "161418" : [ "23:38", "800000", "200420" ], + "161419" : [ "23:39", "800000", "200420" ], + "161420" : [ "23:40", "800000", "200420" ], + "161421" : [ "23:41", "800000", "200420" ], + "161422" : [ "23:42", "800000", "200420" ], + "161423" : [ "23:43", "800000", "200420" ], + "161424" : [ "23:44", "800000", "200420" ], + "161425" : [ "23:45", "800000", "200420" ], + "161426" : [ "23:46", "800000", "200420" ], + "161427" : [ "23:47", "800000", "200420" ], + "161428" : [ "23:48", "800000", "200420" ], + "161429" : [ "23:49", "800000", "200420" ], + "161430" : [ "23:50", "800000", "200420" ], + "161431" : [ "23:51", "800000", "200420" ], + "161432" : [ "23:52", "800000", "200420" ], + "161433" : [ "23:53", "800000", "200420" ], + "161434" : [ "23:54", "800000", "200420" ], + "161435" : [ "23:55", "800000", "200420" ], + "161436" : [ "23:56", "800000", "200420" ], + "161437" : [ "23:57", "800000", "200420" ], + "161438" : [ "23:58", "800000", "200420" ], + "161439" : [ "23:59", "800000", "200420" ] + } + }, + "week3" : { + "Monday": { + "200000" : [ "00:00", "800000", "100420" ], + "200001" : [ "00:01", "800000", "100420" ], + "200002" : [ "00:02", "800000", "100420" ], + "200003" : [ "00:03", "800000", "100420" ], + "200004" : [ "00:04", "800000", "100420" ], + "200005" : [ "00:05", "800000", "100420" ], + "200006" : [ "00:06", "800000", "100420" ], + "200007" : [ "00:07", "800000", "100420" ], + "200008" : [ "00:08", "800000", "100420" ], + "200009" : [ "00:09", "800000", "100420" ], + "200010" : [ "00:10", "800000", "100420" ], + "200011" : [ "00:11", "800000", "100420" ], + "200012" : [ "00:12", "800000", "100420" ], + "200013" : [ "00:13", "800000", "100420" ], + "200014" : [ "00:14", "800000", "100420" ], + "200015" : [ "00:15", "800000", "100420" ], + "200016" : [ "00:16", "800000", "100420" ], + "200017" : [ "00:17", "800000", "100420" ], + "200018" : [ "00:18", "800000", "100420" ], + "200019" : [ "00:19", "800000", "100420" ], + "200020" : [ "00:20", "800000", "100420" ], + "200021" : [ "00:21", "800000", "100420" ], + "200022" : [ "00:22", "800000", "100420" ], + "200023" : [ "00:23", "800000", "100420" ], + "200024" : [ "00:24", "800000", "100420" ], + "200025" : [ "00:25", "800000", "100420" ], + "200026" : [ "00:26", "800000", "100420" ], + "200027" : [ "00:27", "800000", "100420" ], + "200028" : [ "00:28", "800000", "100420" ], + "200029" : [ "00:29", "800000", "100420" ], + "200030" : [ "00:30", "800000", "100420" ], + "200031" : [ "00:31", "800000", "100420" ], + "200032" : [ "00:32", "800000", "100420" ], + "200033" : [ "00:33", "800000", "100420" ], + "200034" : [ "00:34", "800000", "100420" ], + "200035" : [ "00:35", "800000", "100420" ], + "200036" : [ "00:36", "800000", "100420" ], + "200037" : [ "00:37", "800000", "100420" ], + "200038" : [ "00:38", "800000", "100420" ], + "200039" : [ "00:39", "800000", "100420" ], + "200040" : [ "00:40", "800000", "100420" ], + "200041" : [ "00:41", "800000", "100420" ], + "200042" : [ "00:42", "800000", "100420" ], + "200043" : [ "00:43", "800000", "100420" ], + "200044" : [ "00:44", "800000", "100420" ], + "200045" : [ "00:45", "800000", "100420" ], + "200046" : [ "00:46", "800000", "100420" ], + "200047" : [ "00:47", "800000", "100420" ], + "200048" : [ "00:48", "800000", "100420" ], + "200049" : [ "00:49", "800000", "100420" ], + "200050" : [ "00:50", "800000", "100420" ], + "200051" : [ "00:51", "800000", "100420" ], + "200052" : [ "00:52", "800000", "100420" ], + "200053" : [ "00:53", "800000", "100420" ], + "200054" : [ "00:54", "800000", "100420" ], + "200055" : [ "00:55", "800000", "100420" ], + "200056" : [ "00:56", "800000", "100420" ], + "200057" : [ "00:57", "800000", "100420" ], + "200058" : [ "00:58", "800000", "100420" ], + "200059" : [ "00:59", "800000", "100420" ], + "200060" : [ "01:00", "800000", "100420" ], + "200061" : [ "01:01", "800000", "100420" ], + "200062" : [ "01:02", "800000", "100420" ], + "200063" : [ "01:03", "800000", "100420" ], + "200064" : [ "01:04", "800000", "100420" ], + "200065" : [ "01:05", "800000", "100420" ], + "200066" : [ "01:06", "800000", "100420" ], + "200067" : [ "01:07", "800000", "100420" ], + "200068" : [ "01:08", "800000", "100420" ], + "200069" : [ "01:09", "800000", "100420" ], + "200070" : [ "01:10", "800000", "100420" ], + "200071" : [ "01:11", "800000", "100420" ], + "200072" : [ "01:12", "800000", "100420" ], + "200073" : [ "01:13", "800000", "100420" ], + "200074" : [ "01:14", "800000", "100420" ], + "200075" : [ "01:15", "800000", "100420" ], + "200076" : [ "01:16", "800000", "100420" ], + "200077" : [ "01:17", "800000", "100420" ], + "200078" : [ "01:18", "800000", "100420" ], + "200079" : [ "01:19", "800000", "100420" ], + "200080" : [ "01:20", "800000", "100420" ], + "200081" : [ "01:21", "800000", "100420" ], + "200082" : [ "01:22", "800000", "100420" ], + "200083" : [ "01:23", "800000", "100420" ], + "200084" : [ "01:24", "800000", "100420" ], + "200085" : [ "01:25", "800000", "100420" ], + "200086" : [ "01:26", "800000", "100420" ], + "200087" : [ "01:27", "800000", "100420" ], + "200088" : [ "01:28", "800000", "100420" ], + "200089" : [ "01:29", "800000", "100420" ], + "200090" : [ "01:30", "800000", "100420" ], + "200091" : [ "01:31", "800000", "100420" ], + "200092" : [ "01:32", "800000", "100420" ], + "200093" : [ "01:33", "800000", "100420" ], + "200094" : [ "01:34", "800000", "100420" ], + "200095" : [ "01:35", "800000", "100420" ], + "200096" : [ "01:36", "800000", "100420" ], + "200097" : [ "01:37", "800000", "100420" ], + "200098" : [ "01:38", "800000", "100420" ], + "200099" : [ "01:39", "800000", "100420" ], + "200100" : [ "01:40", "800000", "100420" ], + "200101" : [ "01:41", "800000", "100420" ], + "200102" : [ "01:42", "800000", "100420" ], + "200103" : [ "01:43", "800000", "100420" ], + "200104" : [ "01:44", "800000", "100420" ], + "200105" : [ "01:45", "800000", "100420" ], + "200106" : [ "01:46", "800000", "100420" ], + "200107" : [ "01:47", "800000", "100420" ], + "200108" : [ "01:48", "800000", "100420" ], + "200109" : [ "01:49", "800000", "100420" ], + "200110" : [ "01:50", "800000", "100420" ], + "200111" : [ "01:51", "800000", "100420" ], + "200112" : [ "01:52", "800000", "100420" ], + "200113" : [ "01:53", "800000", "100420" ], + "200114" : [ "01:54", "800000", "100420" ], + "200115" : [ "01:55", "800000", "100420" ], + "200116" : [ "01:56", "800000", "100420" ], + "200117" : [ "01:57", "800000", "100420" ], + "200118" : [ "01:58", "800000", "100420" ], + "200119" : [ "01:59", "800000", "100420" ], + "200120" : [ "02:00", "800000", "100420" ], + "200121" : [ "02:01", "800000", "100420" ], + "200122" : [ "02:02", "800000", "100420" ], + "200123" : [ "02:03", "800000", "100420" ], + "200124" : [ "02:04", "800000", "100420" ], + "200125" : [ "02:05", "800000", "100420" ], + "200126" : [ "02:06", "800000", "100420" ], + "200127" : [ "02:07", "800000", "100420" ], + "200128" : [ "02:08", "800000", "100420" ], + "200129" : [ "02:09", "800000", "100420" ], + "200130" : [ "02:10", "800000", "100420" ], + "200131" : [ "02:11", "800000", "100420" ], + "200132" : [ "02:12", "800000", "100420" ], + "200133" : [ "02:13", "800000", "100420" ], + "200134" : [ "02:14", "800000", "100420" ], + "200135" : [ "02:15", "800000", "100420" ], + "200136" : [ "02:16", "800000", "100420" ], + "200137" : [ "02:17", "800000", "100420" ], + "200138" : [ "02:18", "800000", "100420" ], + "200139" : [ "02:19", "800000", "100420" ], + "200140" : [ "02:20", "800000", "100420" ], + "200141" : [ "02:21", "800000", "100420" ], + "200142" : [ "02:22", "800000", "100420" ], + "200143" : [ "02:23", "800000", "100420" ], + "200144" : [ "02:24", "800000", "100420" ], + "200145" : [ "02:25", "800000", "100420" ], + "200146" : [ "02:26", "800000", "100420" ], + "200147" : [ "02:27", "800000", "100420" ], + "200148" : [ "02:28", "800000", "100420" ], + "200149" : [ "02:29", "800000", "100420" ], + "200150" : [ "02:30", "800000", "100420" ], + "200151" : [ "02:31", "800000", "100420" ], + "200152" : [ "02:32", "800000", "100420" ], + "200153" : [ "02:33", "800000", "100420" ], + "200154" : [ "02:34", "800000", "100420" ], + "200155" : [ "02:35", "800000", "100420" ], + "200156" : [ "02:36", "800000", "100420" ], + "200157" : [ "02:37", "800000", "100420" ], + "200158" : [ "02:38", "800000", "100420" ], + "200159" : [ "02:39", "800000", "100420" ], + "200160" : [ "02:40", "800000", "100420" ], + "200161" : [ "02:41", "800000", "100420" ], + "200162" : [ "02:42", "800000", "100420" ], + "200163" : [ "02:43", "800000", "100420" ], + "200164" : [ "02:44", "800000", "100420" ], + "200165" : [ "02:45", "800000", "100420" ], + "200166" : [ "02:46", "800000", "100420" ], + "200167" : [ "02:47", "800000", "100420" ], + "200168" : [ "02:48", "800000", "100420" ], + "200169" : [ "02:49", "800000", "100420" ], + "200170" : [ "02:50", "800000", "100420" ], + "200171" : [ "02:51", "800000", "100420" ], + "200172" : [ "02:52", "800000", "100420" ], + "200173" : [ "02:53", "800000", "100420" ], + "200174" : [ "02:54", "800000", "100420" ], + "200175" : [ "02:55", "800000", "100420" ], + "200176" : [ "02:56", "800000", "100420" ], + "200177" : [ "02:57", "800000", "100420" ], + "200178" : [ "02:58", "800000", "100420" ], + "200179" : [ "02:59", "800000", "100420" ], + "200180" : [ "03:00", "800000", "100420" ], + "200181" : [ "03:01", "800000", "100420" ], + "200182" : [ "03:02", "800000", "100420" ], + "200183" : [ "03:03", "800000", "100420" ], + "200184" : [ "03:04", "800000", "100420" ], + "200185" : [ "03:05", "800000", "100420" ], + "200186" : [ "03:06", "800000", "100420" ], + "200187" : [ "03:07", "800000", "100420" ], + "200188" : [ "03:08", "800000", "100420" ], + "200189" : [ "03:09", "800000", "100420" ], + "200190" : [ "03:10", "800000", "100420" ], + "200191" : [ "03:11", "800000", "100420" ], + "200192" : [ "03:12", "800000", "100420" ], + "200193" : [ "03:13", "800000", "100420" ], + "200194" : [ "03:14", "800000", "100420" ], + "200195" : [ "03:15", "800000", "100420" ], + "200196" : [ "03:16", "800000", "100420" ], + "200197" : [ "03:17", "800000", "100420" ], + "200198" : [ "03:18", "800000", "100420" ], + "200199" : [ "03:19", "800000", "100420" ], + "200200" : [ "03:20", "800000", "100420" ], + "200201" : [ "03:21", "800000", "100420" ], + "200202" : [ "03:22", "800000", "100420" ], + "200203" : [ "03:23", "800000", "100420" ], + "200204" : [ "03:24", "800000", "100420" ], + "200205" : [ "03:25", "800000", "100420" ], + "200206" : [ "03:26", "800000", "100420" ], + "200207" : [ "03:27", "800000", "100420" ], + "200208" : [ "03:28", "800000", "100420" ], + "200209" : [ "03:29", "800000", "100420" ], + "200210" : [ "03:30", "800000", "100420" ], + "200211" : [ "03:31", "800000", "100420" ], + "200212" : [ "03:32", "800000", "100420" ], + "200213" : [ "03:33", "800000", "100420" ], + "200214" : [ "03:34", "800000", "100420" ], + "200215" : [ "03:35", "800000", "100420" ], + "200216" : [ "03:36", "800000", "100420" ], + "200217" : [ "03:37", "800000", "100420" ], + "200218" : [ "03:38", "800000", "100420" ], + "200219" : [ "03:39", "800000", "100420" ], + "200220" : [ "03:40", "800000", "100420" ], + "200221" : [ "03:41", "800000", "100420" ], + "200222" : [ "03:42", "800000", "100420" ], + "200223" : [ "03:43", "800000", "100420" ], + "200224" : [ "03:44", "800000", "100420" ], + "200225" : [ "03:45", "800000", "100420" ], + "200226" : [ "03:46", "800000", "100420" ], + "200227" : [ "03:47", "800000", "100420" ], + "200228" : [ "03:48", "800000", "100420" ], + "200229" : [ "03:49", "800000", "100420" ], + "200230" : [ "03:50", "800000", "100420" ], + "200231" : [ "03:51", "800000", "100420" ], + "200232" : [ "03:52", "800000", "100420" ], + "200233" : [ "03:53", "800000", "100420" ], + "200234" : [ "03:54", "800000", "100420" ], + "200235" : [ "03:55", "800000", "100420" ], + "200236" : [ "03:56", "800000", "100420" ], + "200237" : [ "03:57", "800000", "100420" ], + "200238" : [ "03:58", "800000", "100420" ], + "200239" : [ "03:59", "800000", "100420" ], + "200240" : [ "04:00", "800000", "100420" ], + "200241" : [ "04:01", "800000", "100420" ], + "200242" : [ "04:02", "800000", "100420" ], + "200243" : [ "04:03", "800000", "100420" ], + "200244" : [ "04:04", "800000", "100420" ], + "200245" : [ "04:05", "800000", "100420" ], + "200246" : [ "04:06", "800000", "100420" ], + "200247" : [ "04:07", "800000", "100420" ], + "200248" : [ "04:08", "800000", "100420" ], + "200249" : [ "04:09", "800000", "100420" ], + "200250" : [ "04:10", "800000", "100420" ], + "200251" : [ "04:11", "800000", "100420" ], + "200252" : [ "04:12", "800000", "100420" ], + "200253" : [ "04:13", "800000", "100420" ], + "200254" : [ "04:14", "800000", "100420" ], + "200255" : [ "04:15", "800000", "100420" ], + "200256" : [ "04:16", "800000", "100420" ], + "200257" : [ "04:17", "800000", "100420" ], + "200258" : [ "04:18", "800000", "100420" ], + "200259" : [ "04:19", "800000", "100420" ], + "200260" : [ "04:20", "800000", "100420" ], + "200261" : [ "04:21", "800000", "100420" ], + "200262" : [ "04:22", "800000", "100420" ], + "200263" : [ "04:23", "800000", "100420" ], + "200264" : [ "04:24", "800000", "100420" ], + "200265" : [ "04:25", "800000", "100420" ], + "200266" : [ "04:26", "800000", "100420" ], + "200267" : [ "04:27", "800000", "100420" ], + "200268" : [ "04:28", "800000", "100420" ], + "200269" : [ "04:29", "800000", "100420" ], + "200270" : [ "04:30", "800000", "100420" ], + "200271" : [ "04:31", "800000", "100420" ], + "200272" : [ "04:32", "800000", "100420" ], + "200273" : [ "04:33", "800000", "100420" ], + "200274" : [ "04:34", "800000", "100420" ], + "200275" : [ "04:35", "800000", "100420" ], + "200276" : [ "04:36", "800000", "100420" ], + "200277" : [ "04:37", "800000", "100420" ], + "200278" : [ "04:38", "800000", "100420" ], + "200279" : [ "04:39", "800000", "100420" ], + "200280" : [ "04:40", "800000", "100420" ], + "200281" : [ "04:41", "800000", "100420" ], + "200282" : [ "04:42", "800000", "100420" ], + "200283" : [ "04:43", "800000", "100420" ], + "200284" : [ "04:44", "800000", "100420" ], + "200285" : [ "04:45", "800000", "100420" ], + "200286" : [ "04:46", "800000", "100420" ], + "200287" : [ "04:47", "800000", "100420" ], + "200288" : [ "04:48", "800000", "100420" ], + "200289" : [ "04:49", "800000", "100420" ], + "200290" : [ "04:50", "800000", "100420" ], + "200291" : [ "04:51", "800000", "100420" ], + "200292" : [ "04:52", "800000", "100420" ], + "200293" : [ "04:53", "800000", "100420" ], + "200294" : [ "04:54", "800000", "100420" ], + "200295" : [ "04:55", "800000", "100420" ], + "200296" : [ "04:56", "800000", "100420" ], + "200297" : [ "04:57", "800000", "100420" ], + "200298" : [ "04:58", "800000", "100420" ], + "200299" : [ "04:59", "800000", "100420" ], + "200300" : [ "05:00", "800000", "100420" ], + "200301" : [ "05:01", "800000", "100420" ], + "200302" : [ "05:02", "800000", "100420" ], + "200303" : [ "05:03", "800000", "100420" ], + "200304" : [ "05:04", "800000", "100420" ], + "200305" : [ "05:05", "800000", "100420" ], + "200306" : [ "05:06", "800000", "100420" ], + "200307" : [ "05:07", "800000", "100420" ], + "200308" : [ "05:08", "800000", "100420" ], + "200309" : [ "05:09", "800000", "100420" ], + "200310" : [ "05:10", "800000", "100420" ], + "200311" : [ "05:11", "800000", "100420" ], + "200312" : [ "05:12", "800000", "100420" ], + "200313" : [ "05:13", "800000", "100420" ], + "200314" : [ "05:14", "800000", "100420" ], + "200315" : [ "05:15", "800000", "100420" ], + "200316" : [ "05:16", "800000", "100420" ], + "200317" : [ "05:17", "800000", "100420" ], + "200318" : [ "05:18", "800000", "100420" ], + "200319" : [ "05:19", "800000", "100420" ], + "200320" : [ "05:20", "800000", "100420" ], + "200321" : [ "05:21", "800000", "100420" ], + "200322" : [ "05:22", "800000", "100420" ], + "200323" : [ "05:23", "800000", "100420" ], + "200324" : [ "05:24", "800000", "100420" ], + "200325" : [ "05:25", "800000", "100420" ], + "200326" : [ "05:26", "800000", "100420" ], + "200327" : [ "05:27", "800000", "100420" ], + "200328" : [ "05:28", "800000", "100420" ], + "200329" : [ "05:29", "800000", "100420" ], + "200330" : [ "05:30", "800000", "100420" ], + "200331" : [ "05:31", "800000", "100420" ], + "200332" : [ "05:32", "800000", "100420" ], + "200333" : [ "05:33", "800000", "100420" ], + "200334" : [ "05:34", "800000", "100420" ], + "200335" : [ "05:35", "800000", "100420" ], + "200336" : [ "05:36", "800000", "100420" ], + "200337" : [ "05:37", "800000", "100420" ], + "200338" : [ "05:38", "800000", "100420" ], + "200339" : [ "05:39", "800000", "100420" ], + "200340" : [ "05:40", "800000", "100420" ], + "200341" : [ "05:41", "800000", "100420" ], + "200342" : [ "05:42", "800000", "100420" ], + "200343" : [ "05:43", "800000", "100420" ], + "200344" : [ "05:44", "800000", "100420" ], + "200345" : [ "05:45", "800000", "100420" ], + "200346" : [ "05:46", "800000", "100420" ], + "200347" : [ "05:47", "800000", "100420" ], + "200348" : [ "05:48", "800000", "100420" ], + "200349" : [ "05:49", "800000", "100420" ], + "200350" : [ "05:50", "800000", "100420" ], + "200351" : [ "05:51", "800000", "100420" ], + "200352" : [ "05:52", "800000", "100420" ], + "200353" : [ "05:53", "800000", "100420" ], + "200354" : [ "05:54", "800000", "100420" ], + "200355" : [ "05:55", "800000", "100420" ], + "200356" : [ "05:56", "800000", "100420" ], + "200357" : [ "05:57", "800000", "100420" ], + "200358" : [ "05:58", "800000", "100420" ], + "200359" : [ "05:59", "800000", "100420" ], + "200360" : [ "06:00", "800000", "100420" ], + "200361" : [ "06:01", "800000", "100420" ], + "200362" : [ "06:02", "800000", "100420" ], + "200363" : [ "06:03", "800000", "100420" ], + "200364" : [ "06:04", "800000", "100420" ], + "200365" : [ "06:05", "800000", "100420" ], + "200366" : [ "06:06", "800000", "100420" ], + "200367" : [ "06:07", "800000", "100420" ], + "200368" : [ "06:08", "800000", "100420" ], + "200369" : [ "06:09", "800000", "100420" ], + "200370" : [ "06:10", "800000", "100420" ], + "200371" : [ "06:11", "800000", "100420" ], + "200372" : [ "06:12", "800000", "100420" ], + "200373" : [ "06:13", "800000", "100420" ], + "200374" : [ "06:14", "800000", "100420" ], + "200375" : [ "06:15", "800000", "100420" ], + "200376" : [ "06:16", "800000", "100420" ], + "200377" : [ "06:17", "800000", "100420" ], + "200378" : [ "06:18", "800000", "100420" ], + "200379" : [ "06:19", "800000", "100420" ], + "200380" : [ "06:20", "800000", "100420" ], + "200381" : [ "06:21", "800000", "100420" ], + "200382" : [ "06:22", "800000", "100420" ], + "200383" : [ "06:23", "800000", "100420" ], + "200384" : [ "06:24", "800000", "100420" ], + "200385" : [ "06:25", "800000", "100420" ], + "200386" : [ "06:26", "800000", "100420" ], + "200387" : [ "06:27", "800000", "100420" ], + "200388" : [ "06:28", "800000", "100420" ], + "200389" : [ "06:29", "800000", "100420" ], + "200390" : [ "06:30", "800000", "100420" ], + "200391" : [ "06:31", "800000", "100420" ], + "200392" : [ "06:32", "800000", "100420" ], + "200393" : [ "06:33", "800000", "100420" ], + "200394" : [ "06:34", "800000", "100420" ], + "200395" : [ "06:35", "800000", "100420" ], + "200396" : [ "06:36", "800000", "100420" ], + "200397" : [ "06:37", "800000", "100420" ], + "200398" : [ "06:38", "800000", "100420" ], + "200399" : [ "06:39", "800000", "100420" ], + "200400" : [ "06:40", "800000", "100420" ], + "200401" : [ "06:41", "800000", "100420" ], + "200402" : [ "06:42", "800000", "100420" ], + "200403" : [ "06:43", "800000", "100420" ], + "200404" : [ "06:44", "800000", "100420" ], + "200405" : [ "06:45", "800000", "100420" ], + "200406" : [ "06:46", "800000", "100420" ], + "200407" : [ "06:47", "800000", "100420" ], + "200408" : [ "06:48", "800000", "100420" ], + "200409" : [ "06:49", "800000", "100420" ], + "200410" : [ "06:50", "800000", "100420" ], + "200411" : [ "06:51", "800000", "100420" ], + "200412" : [ "06:52", "800000", "100420" ], + "200413" : [ "06:53", "800000", "100420" ], + "200414" : [ "06:54", "800000", "100420" ], + "200415" : [ "06:55", "800000", "100420" ], + "200416" : [ "06:56", "800000", "100420" ], + "200417" : [ "06:57", "800000", "100420" ], + "200418" : [ "06:58", "800000", "100420" ], + "200419" : [ "06:59", "800000", "100420" ], + "200420" : [ "07:00", "350000", "100480" ], + "200421" : [ "07:01", "350000", "100481" ], + "200422" : [ "07:02", "350000", "100482" ], + "200423" : [ "07:03", "350000", "100483" ], + "200424" : [ "07:04", "350000", "100484" ], + "200425" : [ "07:05", "350000", "100485" ], + "200426" : [ "07:06", "350000", "100486" ], + "200427" : [ "07:07", "350000", "100487" ], + "200428" : [ "07:08", "350000", "100488" ], + "200429" : [ "07:09", "350000", "100489" ], + "200430" : [ "07:10", "350000", "100490" ], + "200431" : [ "07:11", "350000", "100491" ], + "200432" : [ "07:12", "350000", "100492" ], + "200433" : [ "07:13", "350000", "100493" ], + "200434" : [ "07:14", "350000", "100494" ], + "200435" : [ "07:15", "350000", "100495" ], + "200436" : [ "07:16", "350000", "100496" ], + "200437" : [ "07:17", "350000", "100497" ], + "200438" : [ "07:18", "350000", "100498" ], + "200439" : [ "07:19", "350000", "100499" ], + "200440" : [ "07:20", "350000", "100500" ], + "200441" : [ "07:21", "350000", "100501" ], + "200442" : [ "07:22", "350000", "100502" ], + "200443" : [ "07:23", "350000", "100503" ], + "200444" : [ "07:24", "350000", "100504" ], + "200445" : [ "07:25", "350000", "100505" ], + "200446" : [ "07:26", "350000", "100506" ], + "200447" : [ "07:27", "350000", "100507" ], + "200448" : [ "07:28", "350000", "100508" ], + "200449" : [ "07:29", "350000", "100509" ], + "200450" : [ "07:30", "350000", "100510" ], + "200451" : [ "07:31", "350000", "100511" ], + "200452" : [ "07:32", "350000", "100512" ], + "200453" : [ "07:33", "350000", "100513" ], + "200454" : [ "07:34", "350000", "100514" ], + "200455" : [ "07:35", "350000", "100515" ], + "200456" : [ "07:36", "350000", "100516" ], + "200457" : [ "07:37", "350000", "100517" ], + "200458" : [ "07:38", "350000", "100518" ], + "200459" : [ "07:39", "350000", "100519" ], + "200460" : [ "07:40", "350000", "100520" ], + "200461" : [ "07:41", "350000", "100521" ], + "200462" : [ "07:42", "350000", "100522" ], + "200463" : [ "07:43", "350000", "100523" ], + "200464" : [ "07:44", "350000", "100524" ], + "200465" : [ "07:45", "350000", "100525" ], + "200466" : [ "07:46", "350000", "100526" ], + "200467" : [ "07:47", "350000", "100527" ], + "200468" : [ "07:48", "350000", "100528" ], + "200469" : [ "07:49", "350000", "100529" ], + "200470" : [ "07:50", "350000", "100530" ], + "200471" : [ "07:51", "350000", "100531" ], + "200472" : [ "07:52", "350000", "100532" ], + "200473" : [ "07:53", "350000", "100533" ], + "200474" : [ "07:54", "350000", "100534" ], + "200475" : [ "07:55", "350000", "100535" ], + "200476" : [ "07:56", "350000", "100536" ], + "200477" : [ "07:57", "350000", "100537" ], + "200478" : [ "07:58", "350000", "100538" ], + "200479" : [ "07:59", "350000", "100539" ], + "200480" : [ "08:00", "350000", "100540" ], + "200481" : [ "08:01", "350000", "100541" ], + "200482" : [ "08:02", "350000", "100542" ], + "200483" : [ "08:03", "350000", "100543" ], + "200484" : [ "08:04", "350000", "100544" ], + "200485" : [ "08:05", "350000", "100545" ], + "200486" : [ "08:06", "350000", "100546" ], + "200487" : [ "08:07", "350000", "100547" ], + "200488" : [ "08:08", "350000", "100548" ], + "200489" : [ "08:09", "350000", "100549" ], + "200490" : [ "08:10", "350000", "100550" ], + "200491" : [ "08:11", "350000", "100551" ], + "200492" : [ "08:12", "350000", "100552" ], + "200493" : [ "08:13", "350000", "100553" ], + "200494" : [ "08:14", "350000", "100554" ], + "200495" : [ "08:15", "350000", "100555" ], + "200496" : [ "08:16", "350000", "100556" ], + "200497" : [ "08:17", "350000", "100557" ], + "200498" : [ "08:18", "350000", "100558" ], + "200499" : [ "08:19", "350000", "100559" ], + "200500" : [ "08:20", "350000", "100560" ], + "200501" : [ "08:21", "350000", "100561" ], + "200502" : [ "08:22", "350000", "100562" ], + "200503" : [ "08:23", "350000", "100563" ], + "200504" : [ "08:24", "350000", "100564" ], + "200505" : [ "08:25", "350000", "100565" ], + "200506" : [ "08:26", "350000", "100566" ], + "200507" : [ "08:27", "350000", "100567" ], + "200508" : [ "08:28", "350000", "100568" ], + "200509" : [ "08:29", "350000", "100569" ], + "200510" : [ "08:30", "350000", "100570" ], + "200511" : [ "08:31", "350000", "100571" ], + "200512" : [ "08:32", "350000", "100572" ], + "200513" : [ "08:33", "350000", "100573" ], + "200514" : [ "08:34", "350000", "100574" ], + "200515" : [ "08:35", "350000", "100575" ], + "200516" : [ "08:36", "350000", "100576" ], + "200517" : [ "08:37", "350000", "100577" ], + "200518" : [ "08:38", "350000", "100578" ], + "200519" : [ "08:39", "350000", "100579" ], + "200520" : [ "08:40", "350000", "100580" ], + "200521" : [ "08:41", "350000", "100581" ], + "200522" : [ "08:42", "350000", "100582" ], + "200523" : [ "08:43", "350000", "100583" ], + "200524" : [ "08:44", "350000", "100584" ], + "200525" : [ "08:45", "350000", "100585" ], + "200526" : [ "08:46", "350000", "100586" ], + "200527" : [ "08:47", "350000", "100587" ], + "200528" : [ "08:48", "350000", "100588" ], + "200529" : [ "08:49", "350000", "100589" ], + "200530" : [ "08:50", "350000", "100590" ], + "200531" : [ "08:51", "350000", "100591" ], + "200532" : [ "08:52", "350000", "100592" ], + "200533" : [ "08:53", "350000", "100593" ], + "200534" : [ "08:54", "350000", "100594" ], + "200535" : [ "08:55", "350000", "100595" ], + "200536" : [ "08:56", "350000", "100596" ], + "200537" : [ "08:57", "350000", "100597" ], + "200538" : [ "08:58", "350000", "100598" ], + "200539" : [ "08:59", "350000", "100599" ], + "200540" : [ "09:00", "350000", "100600" ], + "200541" : [ "09:01", "350000", "100601" ], + "200542" : [ "09:02", "350000", "100602" ], + "200543" : [ "09:03", "350000", "100603" ], + "200544" : [ "09:04", "350000", "100604" ], + "200545" : [ "09:05", "350000", "100605" ], + "200546" : [ "09:06", "350000", "100606" ], + "200547" : [ "09:07", "350000", "100607" ], + "200548" : [ "09:08", "350000", "100608" ], + "200549" : [ "09:09", "350000", "100609" ], + "200550" : [ "09:10", "350000", "100610" ], + "200551" : [ "09:11", "350000", "100611" ], + "200552" : [ "09:12", "350000", "100612" ], + "200553" : [ "09:13", "350000", "100613" ], + "200554" : [ "09:14", "350000", "100614" ], + "200555" : [ "09:15", "350000", "100615" ], + "200556" : [ "09:16", "350000", "100616" ], + "200557" : [ "09:17", "350000", "100617" ], + "200558" : [ "09:18", "350000", "100618" ], + "200559" : [ "09:19", "350000", "100619" ], + "200560" : [ "09:20", "350000", "100620" ], + "200561" : [ "09:21", "350000", "100621" ], + "200562" : [ "09:22", "350000", "100622" ], + "200563" : [ "09:23", "350000", "100623" ], + "200564" : [ "09:24", "350000", "100624" ], + "200565" : [ "09:25", "350000", "100625" ], + "200566" : [ "09:26", "350000", "100626" ], + "200567" : [ "09:27", "350000", "100627" ], + "200568" : [ "09:28", "350000", "100628" ], + "200569" : [ "09:29", "350000", "100629" ], + "200570" : [ "09:30", "350000", "100630" ], + "200571" : [ "09:31", "350000", "100631" ], + "200572" : [ "09:32", "350000", "100632" ], + "200573" : [ "09:33", "350000", "100633" ], + "200574" : [ "09:34", "350000", "100634" ], + "200575" : [ "09:35", "350000", "100635" ], + "200576" : [ "09:36", "350000", "100636" ], + "200577" : [ "09:37", "350000", "100637" ], + "200578" : [ "09:38", "350000", "100638" ], + "200579" : [ "09:39", "350000", "100639" ], + "200580" : [ "09:40", "350000", "100640" ], + "200581" : [ "09:41", "350000", "100641" ], + "200582" : [ "09:42", "350000", "100642" ], + "200583" : [ "09:43", "350000", "100643" ], + "200584" : [ "09:44", "350000", "100644" ], + "200585" : [ "09:45", "350000", "100645" ], + "200586" : [ "09:46", "350000", "100646" ], + "200587" : [ "09:47", "350000", "100647" ], + "200588" : [ "09:48", "350000", "100648" ], + "200589" : [ "09:49", "350000", "100649" ], + "200590" : [ "09:50", "350000", "100650" ], + "200591" : [ "09:51", "350000", "100651" ], + "200592" : [ "09:52", "350000", "100652" ], + "200593" : [ "09:53", "350000", "100653" ], + "200594" : [ "09:54", "350000", "100654" ], + "200595" : [ "09:55", "350000", "100655" ], + "200596" : [ "09:56", "350000", "100656" ], + "200597" : [ "09:57", "350000", "100657" ], + "200598" : [ "09:58", "350000", "100658" ], + "200599" : [ "09:59", "350000", "100659" ], + "200600" : [ "10:00", "350000", "100660" ], + "200601" : [ "10:01", "350000", "100661" ], + "200602" : [ "10:02", "350000", "100662" ], + "200603" : [ "10:03", "350000", "100663" ], + "200604" : [ "10:04", "350000", "100664" ], + "200605" : [ "10:05", "350000", "100665" ], + "200606" : [ "10:06", "350000", "100666" ], + "200607" : [ "10:07", "350000", "100667" ], + "200608" : [ "10:08", "350000", "100668" ], + "200609" : [ "10:09", "350000", "100669" ], + "200610" : [ "10:10", "350000", "100670" ], + "200611" : [ "10:11", "350000", "100671" ], + "200612" : [ "10:12", "350000", "100672" ], + "200613" : [ "10:13", "350000", "100673" ], + "200614" : [ "10:14", "350000", "100674" ], + "200615" : [ "10:15", "350000", "100675" ], + "200616" : [ "10:16", "350000", "100676" ], + "200617" : [ "10:17", "350000", "100677" ], + "200618" : [ "10:18", "350000", "100678" ], + "200619" : [ "10:19", "350000", "100679" ], + "200620" : [ "10:20", "350000", "100680" ], + "200621" : [ "10:21", "350000", "100681" ], + "200622" : [ "10:22", "350000", "100682" ], + "200623" : [ "10:23", "350000", "100683" ], + "200624" : [ "10:24", "350000", "100684" ], + "200625" : [ "10:25", "350000", "100685" ], + "200626" : [ "10:26", "350000", "100686" ], + "200627" : [ "10:27", "350000", "100687" ], + "200628" : [ "10:28", "350000", "100688" ], + "200629" : [ "10:29", "350000", "100689" ], + "200630" : [ "10:30", "350000", "100690" ], + "200631" : [ "10:31", "350000", "100691" ], + "200632" : [ "10:32", "350000", "100692" ], + "200633" : [ "10:33", "350000", "100693" ], + "200634" : [ "10:34", "350000", "100694" ], + "200635" : [ "10:35", "350000", "100695" ], + "200636" : [ "10:36", "350000", "100696" ], + "200637" : [ "10:37", "350000", "100697" ], + "200638" : [ "10:38", "350000", "100698" ], + "200639" : [ "10:39", "350000", "100699" ], + "200640" : [ "10:40", "350000", "100700" ], + "200641" : [ "10:41", "350000", "100701" ], + "200642" : [ "10:42", "350000", "100702" ], + "200643" : [ "10:43", "350000", "100703" ], + "200644" : [ "10:44", "350000", "100704" ], + "200645" : [ "10:45", "350000", "100705" ], + "200646" : [ "10:46", "350000", "100706" ], + "200647" : [ "10:47", "350000", "100707" ], + "200648" : [ "10:48", "350000", "100708" ], + "200649" : [ "10:49", "350000", "100709" ], + "200650" : [ "10:50", "350000", "100710" ], + "200651" : [ "10:51", "350000", "100711" ], + "200652" : [ "10:52", "350000", "100712" ], + "200653" : [ "10:53", "350000", "100713" ], + "200654" : [ "10:54", "350000", "100714" ], + "200655" : [ "10:55", "350000", "100715" ], + "200656" : [ "10:56", "350000", "100716" ], + "200657" : [ "10:57", "350000", "100717" ], + "200658" : [ "10:58", "350000", "100718" ], + "200659" : [ "10:59", "350000", "100719" ], + "200660" : [ "11:00", "350000", "100720" ], + "200661" : [ "11:01", "350000", "100721" ], + "200662" : [ "11:02", "350000", "100722" ], + "200663" : [ "11:03", "350000", "100723" ], + "200664" : [ "11:04", "350000", "100724" ], + "200665" : [ "11:05", "350000", "100725" ], + "200666" : [ "11:06", "350000", "100726" ], + "200667" : [ "11:07", "350000", "100727" ], + "200668" : [ "11:08", "350000", "100728" ], + "200669" : [ "11:09", "350000", "100729" ], + "200670" : [ "11:10", "350000", "100730" ], + "200671" : [ "11:11", "350000", "100731" ], + "200672" : [ "11:12", "350000", "100732" ], + "200673" : [ "11:13", "350000", "100733" ], + "200674" : [ "11:14", "350000", "100734" ], + "200675" : [ "11:15", "350000", "100735" ], + "200676" : [ "11:16", "350000", "100736" ], + "200677" : [ "11:17", "350000", "100737" ], + "200678" : [ "11:18", "350000", "100738" ], + "200679" : [ "11:19", "350000", "100739" ], + "200680" : [ "11:20", "350000", "100740" ], + "200681" : [ "11:21", "350000", "100741" ], + "200682" : [ "11:22", "350000", "100742" ], + "200683" : [ "11:23", "350000", "100743" ], + "200684" : [ "11:24", "350000", "100744" ], + "200685" : [ "11:25", "350000", "100745" ], + "200686" : [ "11:26", "350000", "100746" ], + "200687" : [ "11:27", "350000", "100747" ], + "200688" : [ "11:28", "350000", "100748" ], + "200689" : [ "11:29", "350000", "100749" ], + "200690" : [ "11:30", "350000", "100750" ], + "200691" : [ "11:31", "350000", "100751" ], + "200692" : [ "11:32", "350000", "100752" ], + "200693" : [ "11:33", "350000", "100753" ], + "200694" : [ "11:34", "350000", "100754" ], + "200695" : [ "11:35", "350000", "100755" ], + "200696" : [ "11:36", "350000", "100756" ], + "200697" : [ "11:37", "350000", "100757" ], + "200698" : [ "11:38", "350000", "100758" ], + "200699" : [ "11:39", "350000", "100759" ], + "200700" : [ "11:40", "350000", "100760" ], + "200701" : [ "11:41", "350000", "100761" ], + "200702" : [ "11:42", "350000", "100762" ], + "200703" : [ "11:43", "350000", "100763" ], + "200704" : [ "11:44", "350000", "100764" ], + "200705" : [ "11:45", "350000", "100765" ], + "200706" : [ "11:46", "350000", "100766" ], + "200707" : [ "11:47", "350000", "100767" ], + "200708" : [ "11:48", "350000", "100768" ], + "200709" : [ "11:49", "350000", "100769" ], + "200710" : [ "11:50", "350000", "100770" ], + "200711" : [ "11:51", "350000", "100771" ], + "200712" : [ "11:52", "350000", "100772" ], + "200713" : [ "11:53", "350000", "100773" ], + "200714" : [ "11:54", "350000", "100774" ], + "200715" : [ "11:55", "350000", "100775" ], + "200716" : [ "11:56", "350000", "100776" ], + "200717" : [ "11:57", "350000", "100777" ], + "200718" : [ "11:58", "350000", "100778" ], + "200719" : [ "11:59", "350000", "100779" ], + "200720" : [ "12:00", "350000", "100780" ], + "200721" : [ "12:01", "350000", "100781" ], + "200722" : [ "12:02", "350000", "100782" ], + "200723" : [ "12:03", "350000", "100783" ], + "200724" : [ "12:04", "350000", "100784" ], + "200725" : [ "12:05", "350000", "100785" ], + "200726" : [ "12:06", "350000", "100786" ], + "200727" : [ "12:07", "350000", "100787" ], + "200728" : [ "12:08", "350000", "100788" ], + "200729" : [ "12:09", "350000", "100789" ], + "200730" : [ "12:10", "350000", "100790" ], + "200731" : [ "12:11", "350000", "100791" ], + "200732" : [ "12:12", "350000", "100792" ], + "200733" : [ "12:13", "350000", "100793" ], + "200734" : [ "12:14", "350000", "100794" ], + "200735" : [ "12:15", "350000", "100795" ], + "200736" : [ "12:16", "350000", "100796" ], + "200737" : [ "12:17", "350000", "100797" ], + "200738" : [ "12:18", "350000", "100798" ], + "200739" : [ "12:19", "350000", "100799" ], + "200740" : [ "12:20", "350000", "100800" ], + "200741" : [ "12:21", "350000", "100801" ], + "200742" : [ "12:22", "350000", "100802" ], + "200743" : [ "12:23", "350000", "100803" ], + "200744" : [ "12:24", "350000", "100804" ], + "200745" : [ "12:25", "350000", "100805" ], + "200746" : [ "12:26", "350000", "100806" ], + "200747" : [ "12:27", "350000", "100807" ], + "200748" : [ "12:28", "350000", "100808" ], + "200749" : [ "12:29", "350000", "100809" ], + "200750" : [ "12:30", "350000", "100810" ], + "200751" : [ "12:31", "350000", "100811" ], + "200752" : [ "12:32", "350000", "100812" ], + "200753" : [ "12:33", "350000", "100813" ], + "200754" : [ "12:34", "350000", "100814" ], + "200755" : [ "12:35", "350000", "100815" ], + "200756" : [ "12:36", "350000", "100816" ], + "200757" : [ "12:37", "350000", "100817" ], + "200758" : [ "12:38", "350000", "100818" ], + "200759" : [ "12:39", "350000", "100819" ], + "200760" : [ "12:40", "350000", "100820" ], + "200761" : [ "12:41", "350000", "100821" ], + "200762" : [ "12:42", "350000", "100822" ], + "200763" : [ "12:43", "350000", "100823" ], + "200764" : [ "12:44", "350000", "100824" ], + "200765" : [ "12:45", "350000", "100825" ], + "200766" : [ "12:46", "350000", "100826" ], + "200767" : [ "12:47", "350000", "100827" ], + "200768" : [ "12:48", "350000", "100828" ], + "200769" : [ "12:49", "350000", "100829" ], + "200770" : [ "12:50", "350000", "100830" ], + "200771" : [ "12:51", "350000", "100831" ], + "200772" : [ "12:52", "350000", "100832" ], + "200773" : [ "12:53", "350000", "100833" ], + "200774" : [ "12:54", "350000", "100834" ], + "200775" : [ "12:55", "350000", "100835" ], + "200776" : [ "12:56", "350000", "100836" ], + "200777" : [ "12:57", "350000", "100837" ], + "200778" : [ "12:58", "350000", "100838" ], + "200779" : [ "12:59", "350000", "100839" ], + "200780" : [ "13:00", "350000", "100840" ], + "200781" : [ "13:01", "350000", "100841" ], + "200782" : [ "13:02", "350000", "100842" ], + "200783" : [ "13:03", "350000", "100843" ], + "200784" : [ "13:04", "350000", "100844" ], + "200785" : [ "13:05", "350000", "100845" ], + "200786" : [ "13:06", "350000", "100846" ], + "200787" : [ "13:07", "350000", "100847" ], + "200788" : [ "13:08", "350000", "100848" ], + "200789" : [ "13:09", "350000", "100849" ], + "200790" : [ "13:10", "350000", "100850" ], + "200791" : [ "13:11", "350000", "100851" ], + "200792" : [ "13:12", "350000", "100852" ], + "200793" : [ "13:13", "350000", "100853" ], + "200794" : [ "13:14", "350000", "100854" ], + "200795" : [ "13:15", "350000", "100855" ], + "200796" : [ "13:16", "350000", "100856" ], + "200797" : [ "13:17", "350000", "100857" ], + "200798" : [ "13:18", "350000", "100858" ], + "200799" : [ "13:19", "350000", "100859" ], + "200800" : [ "13:20", "350000", "100860" ], + "200801" : [ "13:21", "350000", "100861" ], + "200802" : [ "13:22", "350000", "100862" ], + "200803" : [ "13:23", "350000", "100863" ], + "200804" : [ "13:24", "350000", "100864" ], + "200805" : [ "13:25", "350000", "100865" ], + "200806" : [ "13:26", "350000", "100866" ], + "200807" : [ "13:27", "350000", "100867" ], + "200808" : [ "13:28", "350000", "100868" ], + "200809" : [ "13:29", "350000", "100869" ], + "200810" : [ "13:30", "350000", "100870" ], + "200811" : [ "13:31", "350000", "100871" ], + "200812" : [ "13:32", "350000", "100872" ], + "200813" : [ "13:33", "350000", "100873" ], + "200814" : [ "13:34", "350000", "100874" ], + "200815" : [ "13:35", "350000", "100875" ], + "200816" : [ "13:36", "350000", "100876" ], + "200817" : [ "13:37", "350000", "100877" ], + "200818" : [ "13:38", "350000", "100878" ], + "200819" : [ "13:39", "350000", "100879" ], + "200820" : [ "13:40", "350000", "100880" ], + "200821" : [ "13:41", "350000", "100881" ], + "200822" : [ "13:42", "350000", "100882" ], + "200823" : [ "13:43", "350000", "100883" ], + "200824" : [ "13:44", "350000", "100884" ], + "200825" : [ "13:45", "350000", "100885" ], + "200826" : [ "13:46", "350000", "100886" ], + "200827" : [ "13:47", "350000", "100887" ], + "200828" : [ "13:48", "350000", "100888" ], + "200829" : [ "13:49", "350000", "100889" ], + "200830" : [ "13:50", "350000", "100890" ], + "200831" : [ "13:51", "350000", "100891" ], + "200832" : [ "13:52", "350000", "100892" ], + "200833" : [ "13:53", "350000", "100893" ], + "200834" : [ "13:54", "350000", "100894" ], + "200835" : [ "13:55", "350000", "100895" ], + "200836" : [ "13:56", "350000", "100896" ], + "200837" : [ "13:57", "350000", "100897" ], + "200838" : [ "13:58", "350000", "100898" ], + "200839" : [ "13:59", "350000", "100899" ], + "200840" : [ "14:00", "350000", "100900" ], + "200841" : [ "14:01", "350000", "100901" ], + "200842" : [ "14:02", "350000", "100902" ], + "200843" : [ "14:03", "350000", "100903" ], + "200844" : [ "14:04", "350000", "100904" ], + "200845" : [ "14:05", "350000", "100905" ], + "200846" : [ "14:06", "350000", "100906" ], + "200847" : [ "14:07", "350000", "100907" ], + "200848" : [ "14:08", "350000", "100908" ], + "200849" : [ "14:09", "350000", "100909" ], + "200850" : [ "14:10", "350000", "100910" ], + "200851" : [ "14:11", "350000", "100911" ], + "200852" : [ "14:12", "350000", "100912" ], + "200853" : [ "14:13", "350000", "100913" ], + "200854" : [ "14:14", "350000", "100914" ], + "200855" : [ "14:15", "350000", "100915" ], + "200856" : [ "14:16", "350000", "100916" ], + "200857" : [ "14:17", "350000", "100917" ], + "200858" : [ "14:18", "350000", "100918" ], + "200859" : [ "14:19", "350000", "100919" ], + "200860" : [ "14:20", "350000", "100920" ], + "200861" : [ "14:21", "350000", "100921" ], + "200862" : [ "14:22", "350000", "100922" ], + "200863" : [ "14:23", "350000", "100923" ], + "200864" : [ "14:24", "350000", "100924" ], + "200865" : [ "14:25", "350000", "100925" ], + "200866" : [ "14:26", "350000", "100926" ], + "200867" : [ "14:27", "350000", "100927" ], + "200868" : [ "14:28", "350000", "100928" ], + "200869" : [ "14:29", "350000", "100929" ], + "200870" : [ "14:30", "350000", "100930" ], + "200871" : [ "14:31", "350000", "100931" ], + "200872" : [ "14:32", "350000", "100932" ], + "200873" : [ "14:33", "350000", "100933" ], + "200874" : [ "14:34", "350000", "100934" ], + "200875" : [ "14:35", "350000", "100935" ], + "200876" : [ "14:36", "350000", "100936" ], + "200877" : [ "14:37", "350000", "100937" ], + "200878" : [ "14:38", "350000", "100938" ], + "200879" : [ "14:39", "350000", "100939" ], + "200880" : [ "14:40", "350000", "100940" ], + "200881" : [ "14:41", "350000", "100941" ], + "200882" : [ "14:42", "350000", "100942" ], + "200883" : [ "14:43", "350000", "100943" ], + "200884" : [ "14:44", "350000", "100944" ], + "200885" : [ "14:45", "350000", "100945" ], + "200886" : [ "14:46", "350000", "100946" ], + "200887" : [ "14:47", "350000", "100947" ], + "200888" : [ "14:48", "350000", "100948" ], + "200889" : [ "14:49", "350000", "100949" ], + "200890" : [ "14:50", "350000", "100950" ], + "200891" : [ "14:51", "350000", "100951" ], + "200892" : [ "14:52", "350000", "100952" ], + "200893" : [ "14:53", "350000", "100953" ], + "200894" : [ "14:54", "350000", "100954" ], + "200895" : [ "14:55", "350000", "100955" ], + "200896" : [ "14:56", "350000", "100956" ], + "200897" : [ "14:57", "350000", "100957" ], + "200898" : [ "14:58", "350000", "100958" ], + "200899" : [ "14:59", "350000", "100959" ], + "200900" : [ "15:00", "350000", "100960" ], + "200901" : [ "15:01", "350000", "100961" ], + "200902" : [ "15:02", "350000", "100962" ], + "200903" : [ "15:03", "350000", "100963" ], + "200904" : [ "15:04", "350000", "100964" ], + "200905" : [ "15:05", "350000", "100965" ], + "200906" : [ "15:06", "350000", "100966" ], + "200907" : [ "15:07", "350000", "100967" ], + "200908" : [ "15:08", "350000", "100968" ], + "200909" : [ "15:09", "350000", "100969" ], + "200910" : [ "15:10", "350000", "100970" ], + "200911" : [ "15:11", "350000", "100971" ], + "200912" : [ "15:12", "350000", "100972" ], + "200913" : [ "15:13", "350000", "100973" ], + "200914" : [ "15:14", "350000", "100974" ], + "200915" : [ "15:15", "350000", "100975" ], + "200916" : [ "15:16", "350000", "100976" ], + "200917" : [ "15:17", "350000", "100977" ], + "200918" : [ "15:18", "350000", "100978" ], + "200919" : [ "15:19", "350000", "100979" ], + "200920" : [ "15:20", "350000", "100980" ], + "200921" : [ "15:21", "350000", "100981" ], + "200922" : [ "15:22", "350000", "100982" ], + "200923" : [ "15:23", "350000", "100983" ], + "200924" : [ "15:24", "350000", "100984" ], + "200925" : [ "15:25", "350000", "100985" ], + "200926" : [ "15:26", "350000", "100986" ], + "200927" : [ "15:27", "350000", "100987" ], + "200928" : [ "15:28", "350000", "100988" ], + "200929" : [ "15:29", "350000", "100989" ], + "200930" : [ "15:30", "350000", "100990" ], + "200931" : [ "15:31", "350000", "100991" ], + "200932" : [ "15:32", "350000", "100992" ], + "200933" : [ "15:33", "350000", "100993" ], + "200934" : [ "15:34", "350000", "100994" ], + "200935" : [ "15:35", "350000", "100995" ], + "200936" : [ "15:36", "350000", "100996" ], + "200937" : [ "15:37", "350000", "100997" ], + "200938" : [ "15:38", "350000", "100998" ], + "200939" : [ "15:39", "350000", "100999" ], + "200940" : [ "15:40", "350000", "101000" ], + "200941" : [ "15:41", "350000", "101001" ], + "200942" : [ "15:42", "350000", "101002" ], + "200943" : [ "15:43", "350000", "101003" ], + "200944" : [ "15:44", "350000", "101004" ], + "200945" : [ "15:45", "350000", "101005" ], + "200946" : [ "15:46", "350000", "101006" ], + "200947" : [ "15:47", "350000", "101007" ], + "200948" : [ "15:48", "350000", "101008" ], + "200949" : [ "15:49", "350000", "101009" ], + "200950" : [ "15:50", "350000", "101010" ], + "200951" : [ "15:51", "350000", "101011" ], + "200952" : [ "15:52", "350000", "101012" ], + "200953" : [ "15:53", "350000", "101013" ], + "200954" : [ "15:54", "350000", "101014" ], + "200955" : [ "15:55", "350000", "101015" ], + "200956" : [ "15:56", "350000", "101016" ], + "200957" : [ "15:57", "350000", "101017" ], + "200958" : [ "15:58", "350000", "101018" ], + "200959" : [ "15:59", "350000", "101019" ], + "200960" : [ "16:00", "350000", "101020" ], + "200961" : [ "16:01", "350000", "101021" ], + "200962" : [ "16:02", "350000", "101022" ], + "200963" : [ "16:03", "350000", "101023" ], + "200964" : [ "16:04", "350000", "101024" ], + "200965" : [ "16:05", "350000", "101025" ], + "200966" : [ "16:06", "350000", "101026" ], + "200967" : [ "16:07", "350000", "101027" ], + "200968" : [ "16:08", "350000", "101028" ], + "200969" : [ "16:09", "350000", "101029" ], + "200970" : [ "16:10", "350000", "101030" ], + "200971" : [ "16:11", "350000", "101031" ], + "200972" : [ "16:12", "350000", "101032" ], + "200973" : [ "16:13", "350000", "101033" ], + "200974" : [ "16:14", "350000", "101034" ], + "200975" : [ "16:15", "350000", "101035" ], + "200976" : [ "16:16", "350000", "101036" ], + "200977" : [ "16:17", "350000", "101037" ], + "200978" : [ "16:18", "350000", "101038" ], + "200979" : [ "16:19", "350000", "101039" ], + "200980" : [ "16:20", "350000", "101040" ], + "200981" : [ "16:21", "350000", "101041" ], + "200982" : [ "16:22", "350000", "101042" ], + "200983" : [ "16:23", "350000", "101043" ], + "200984" : [ "16:24", "350000", "101044" ], + "200985" : [ "16:25", "350000", "101045" ], + "200986" : [ "16:26", "350000", "101046" ], + "200987" : [ "16:27", "350000", "101047" ], + "200988" : [ "16:28", "350000", "101048" ], + "200989" : [ "16:29", "350000", "101049" ], + "200990" : [ "16:30", "350000", "101050" ], + "200991" : [ "16:31", "350000", "101051" ], + "200992" : [ "16:32", "350000", "101052" ], + "200993" : [ "16:33", "350000", "101053" ], + "200994" : [ "16:34", "350000", "101054" ], + "200995" : [ "16:35", "350000", "101055" ], + "200996" : [ "16:36", "350000", "101056" ], + "200997" : [ "16:37", "350000", "101057" ], + "200998" : [ "16:38", "350000", "101058" ], + "200999" : [ "16:39", "350000", "101059" ], + "201000" : [ "16:40", "350000", "101060" ], + "201001" : [ "16:41", "350000", "101061" ], + "201002" : [ "16:42", "350000", "101062" ], + "201003" : [ "16:43", "350000", "101063" ], + "201004" : [ "16:44", "350000", "101064" ], + "201005" : [ "16:45", "350000", "101065" ], + "201006" : [ "16:46", "350000", "101066" ], + "201007" : [ "16:47", "350000", "101067" ], + "201008" : [ "16:48", "350000", "101068" ], + "201009" : [ "16:49", "350000", "101069" ], + "201010" : [ "16:50", "350000", "101070" ], + "201011" : [ "16:51", "350000", "101071" ], + "201012" : [ "16:52", "350000", "101072" ], + "201013" : [ "16:53", "350000", "101073" ], + "201014" : [ "16:54", "350000", "101074" ], + "201015" : [ "16:55", "350000", "101075" ], + "201016" : [ "16:56", "350000", "101076" ], + "201017" : [ "16:57", "350000", "101077" ], + "201018" : [ "16:58", "350000", "101078" ], + "201019" : [ "16:59", "350000", "101079" ], + "201020" : [ "17:00", "350000", "101080" ], + "201021" : [ "17:01", "350000", "101081" ], + "201022" : [ "17:02", "350000", "101082" ], + "201023" : [ "17:03", "350000", "101083" ], + "201024" : [ "17:04", "350000", "101084" ], + "201025" : [ "17:05", "350000", "101085" ], + "201026" : [ "17:06", "350000", "101086" ], + "201027" : [ "17:07", "350000", "101087" ], + "201028" : [ "17:08", "350000", "101088" ], + "201029" : [ "17:09", "350000", "101089" ], + "201030" : [ "17:10", "350000", "101090" ], + "201031" : [ "17:11", "350000", "101091" ], + "201032" : [ "17:12", "350000", "101092" ], + "201033" : [ "17:13", "350000", "101093" ], + "201034" : [ "17:14", "350000", "101094" ], + "201035" : [ "17:15", "350000", "101095" ], + "201036" : [ "17:16", "350000", "101096" ], + "201037" : [ "17:17", "350000", "101097" ], + "201038" : [ "17:18", "350000", "101098" ], + "201039" : [ "17:19", "350000", "101099" ], + "201040" : [ "17:20", "350000", "101100" ], + "201041" : [ "17:21", "350000", "101101" ], + "201042" : [ "17:22", "350000", "101102" ], + "201043" : [ "17:23", "350000", "101103" ], + "201044" : [ "17:24", "350000", "101104" ], + "201045" : [ "17:25", "350000", "101105" ], + "201046" : [ "17:26", "350000", "101106" ], + "201047" : [ "17:27", "350000", "101107" ], + "201048" : [ "17:28", "350000", "101108" ], + "201049" : [ "17:29", "350000", "101109" ], + "201050" : [ "17:30", "350000", "101110" ], + "201051" : [ "17:31", "350000", "101111" ], + "201052" : [ "17:32", "350000", "101112" ], + "201053" : [ "17:33", "350000", "101113" ], + "201054" : [ "17:34", "350000", "101114" ], + "201055" : [ "17:35", "350000", "101115" ], + "201056" : [ "17:36", "350000", "101116" ], + "201057" : [ "17:37", "350000", "101117" ], + "201058" : [ "17:38", "350000", "101118" ], + "201059" : [ "17:39", "350000", "101119" ], + "201060" : [ "17:40", "350000", "101120" ], + "201061" : [ "17:41", "350000", "101121" ], + "201062" : [ "17:42", "350000", "101122" ], + "201063" : [ "17:43", "350000", "101123" ], + "201064" : [ "17:44", "350000", "101124" ], + "201065" : [ "17:45", "350000", "101125" ], + "201066" : [ "17:46", "350000", "101126" ], + "201067" : [ "17:47", "350000", "101127" ], + "201068" : [ "17:48", "350000", "101128" ], + "201069" : [ "17:49", "350000", "101129" ], + "201070" : [ "17:50", "350000", "101130" ], + "201071" : [ "17:51", "350000", "101131" ], + "201072" : [ "17:52", "350000", "101132" ], + "201073" : [ "17:53", "350000", "101133" ], + "201074" : [ "17:54", "350000", "101134" ], + "201075" : [ "17:55", "350000", "101135" ], + "201076" : [ "17:56", "350000", "101136" ], + "201077" : [ "17:57", "350000", "101137" ], + "201078" : [ "17:58", "350000", "101138" ], + "201079" : [ "17:59", "350000", "101139" ], + "201080" : [ "18:00", "350000", "101140" ], + "201081" : [ "18:01", "350000", "101141" ], + "201082" : [ "18:02", "350000", "101142" ], + "201083" : [ "18:03", "350000", "101143" ], + "201084" : [ "18:04", "350000", "101144" ], + "201085" : [ "18:05", "350000", "101145" ], + "201086" : [ "18:06", "350000", "101146" ], + "201087" : [ "18:07", "350000", "101147" ], + "201088" : [ "18:08", "350000", "101148" ], + "201089" : [ "18:09", "350000", "101149" ], + "201090" : [ "18:10", "350000", "101150" ], + "201091" : [ "18:11", "350000", "101151" ], + "201092" : [ "18:12", "350000", "101152" ], + "201093" : [ "18:13", "350000", "101153" ], + "201094" : [ "18:14", "350000", "101154" ], + "201095" : [ "18:15", "350000", "101155" ], + "201096" : [ "18:16", "350000", "101156" ], + "201097" : [ "18:17", "350000", "101157" ], + "201098" : [ "18:18", "350000", "101158" ], + "201099" : [ "18:19", "350000", "101159" ], + "201100" : [ "18:20", "350000", "101160" ], + "201101" : [ "18:21", "350000", "101161" ], + "201102" : [ "18:22", "350000", "101162" ], + "201103" : [ "18:23", "350000", "101163" ], + "201104" : [ "18:24", "350000", "101164" ], + "201105" : [ "18:25", "350000", "101165" ], + "201106" : [ "18:26", "350000", "101166" ], + "201107" : [ "18:27", "350000", "101167" ], + "201108" : [ "18:28", "350000", "101168" ], + "201109" : [ "18:29", "350000", "101169" ], + "201110" : [ "18:30", "350000", "101170" ], + "201111" : [ "18:31", "350000", "101171" ], + "201112" : [ "18:32", "350000", "101172" ], + "201113" : [ "18:33", "350000", "101173" ], + "201114" : [ "18:34", "350000", "101174" ], + "201115" : [ "18:35", "350000", "101175" ], + "201116" : [ "18:36", "350000", "101176" ], + "201117" : [ "18:37", "350000", "101177" ], + "201118" : [ "18:38", "350000", "101178" ], + "201119" : [ "18:39", "350000", "101179" ], + "201120" : [ "18:40", "350000", "101180" ], + "201121" : [ "18:41", "350000", "101181" ], + "201122" : [ "18:42", "350000", "101182" ], + "201123" : [ "18:43", "350000", "101183" ], + "201124" : [ "18:44", "350000", "101184" ], + "201125" : [ "18:45", "350000", "101185" ], + "201126" : [ "18:46", "350000", "101186" ], + "201127" : [ "18:47", "350000", "101187" ], + "201128" : [ "18:48", "350000", "101188" ], + "201129" : [ "18:49", "350000", "101189" ], + "201130" : [ "18:50", "350000", "101190" ], + "201131" : [ "18:51", "350000", "101191" ], + "201132" : [ "18:52", "350000", "101192" ], + "201133" : [ "18:53", "350000", "101193" ], + "201134" : [ "18:54", "350000", "101194" ], + "201135" : [ "18:55", "350000", "101195" ], + "201136" : [ "18:56", "350000", "101196" ], + "201137" : [ "18:57", "350000", "101197" ], + "201138" : [ "18:58", "350000", "101198" ], + "201139" : [ "18:59", "350000", "101199" ], + "201140" : [ "19:00", "350000", "101200" ], + "201141" : [ "19:01", "350000", "101200" ], + "201142" : [ "19:02", "350000", "101200" ], + "201143" : [ "19:03", "350000", "101200" ], + "201144" : [ "19:04", "350000", "101200" ], + "201145" : [ "19:05", "350000", "101200" ], + "201146" : [ "19:06", "350000", "101200" ], + "201147" : [ "19:07", "350000", "101200" ], + "201148" : [ "19:08", "350000", "101200" ], + "201149" : [ "19:09", "350000", "101200" ], + "201150" : [ "19:10", "350000", "101200" ], + "201151" : [ "19:11", "350000", "101200" ], + "201152" : [ "19:12", "350000", "101200" ], + "201153" : [ "19:13", "350000", "101200" ], + "201154" : [ "19:14", "350000", "101200" ], + "201155" : [ "19:15", "350000", "101200" ], + "201156" : [ "19:16", "350000", "101200" ], + "201157" : [ "19:17", "350000", "101200" ], + "201158" : [ "19:18", "350000", "101200" ], + "201159" : [ "19:19", "350000", "101200" ], + "201160" : [ "19:20", "350000", "101200" ], + "201161" : [ "19:21", "350000", "101200" ], + "201162" : [ "19:22", "350000", "101200" ], + "201163" : [ "19:23", "350000", "101200" ], + "201164" : [ "19:24", "350000", "101200" ], + "201165" : [ "19:25", "350000", "101200" ], + "201166" : [ "19:26", "350000", "101200" ], + "201167" : [ "19:27", "350000", "101200" ], + "201168" : [ "19:28", "350000", "101200" ], + "201169" : [ "19:29", "350000", "101200" ], + "201170" : [ "19:30", "350000", "101200" ], + "201171" : [ "19:31", "350000", "101200" ], + "201172" : [ "19:32", "350000", "101200" ], + "201173" : [ "19:33", "350000", "101200" ], + "201174" : [ "19:34", "350000", "101200" ], + "201175" : [ "19:35", "350000", "101200" ], + "201176" : [ "19:36", "350000", "101200" ], + "201177" : [ "19:37", "350000", "101200" ], + "201178" : [ "19:38", "350000", "101200" ], + "201179" : [ "19:39", "350000", "101200" ], + "201180" : [ "19:40", "350000", "101200" ], + "201181" : [ "19:41", "350000", "101200" ], + "201182" : [ "19:42", "350000", "101200" ], + "201183" : [ "19:43", "350000", "101200" ], + "201184" : [ "19:44", "350000", "101200" ], + "201185" : [ "19:45", "350000", "101200" ], + "201186" : [ "19:46", "350000", "101200" ], + "201187" : [ "19:47", "350000", "101200" ], + "201188" : [ "19:48", "350000", "101200" ], + "201189" : [ "19:49", "350000", "101200" ], + "201190" : [ "19:50", "350000", "101200" ], + "201191" : [ "19:51", "350000", "101200" ], + "201192" : [ "19:52", "350000", "101200" ], + "201193" : [ "19:53", "350000", "101200" ], + "201194" : [ "19:54", "350000", "101200" ], + "201195" : [ "19:55", "350000", "101200" ], + "201196" : [ "19:56", "350000", "101200" ], + "201197" : [ "19:57", "350000", "101200" ], + "201198" : [ "19:58", "350000", "101200" ], + "201199" : [ "19:59", "350000", "101200" ], + "201200" : [ "20:00", "800000", "110420" ], + "201201" : [ "20:01", "800000", "110420" ], + "201202" : [ "20:02", "800000", "110420" ], + "201203" : [ "20:03", "800000", "110420" ], + "201204" : [ "20:04", "800000", "110420" ], + "201205" : [ "20:05", "800000", "110420" ], + "201206" : [ "20:06", "800000", "110420" ], + "201207" : [ "20:07", "800000", "110420" ], + "201208" : [ "20:08", "800000", "110420" ], + "201209" : [ "20:09", "800000", "110420" ], + "201210" : [ "20:10", "800000", "110420" ], + "201211" : [ "20:11", "800000", "110420" ], + "201212" : [ "20:12", "800000", "110420" ], + "201213" : [ "20:13", "800000", "110420" ], + "201214" : [ "20:14", "800000", "110420" ], + "201215" : [ "20:15", "800000", "110420" ], + "201216" : [ "20:16", "800000", "110420" ], + "201217" : [ "20:17", "800000", "110420" ], + "201218" : [ "20:18", "800000", "110420" ], + "201219" : [ "20:19", "800000", "110420" ], + "201220" : [ "20:20", "800000", "110420" ], + "201221" : [ "20:21", "800000", "110420" ], + "201222" : [ "20:22", "800000", "110420" ], + "201223" : [ "20:23", "800000", "110420" ], + "201224" : [ "20:24", "800000", "110420" ], + "201225" : [ "20:25", "800000", "110420" ], + "201226" : [ "20:26", "800000", "110420" ], + "201227" : [ "20:27", "800000", "110420" ], + "201228" : [ "20:28", "800000", "110420" ], + "201229" : [ "20:29", "800000", "110420" ], + "201230" : [ "20:30", "800000", "110420" ], + "201231" : [ "20:31", "800000", "110420" ], + "201232" : [ "20:32", "800000", "110420" ], + "201233" : [ "20:33", "800000", "110420" ], + "201234" : [ "20:34", "800000", "110420" ], + "201235" : [ "20:35", "800000", "110420" ], + "201236" : [ "20:36", "800000", "110420" ], + "201237" : [ "20:37", "800000", "110420" ], + "201238" : [ "20:38", "800000", "110420" ], + "201239" : [ "20:39", "800000", "110420" ], + "201240" : [ "20:40", "800000", "110420" ], + "201241" : [ "20:41", "800000", "110420" ], + "201242" : [ "20:42", "800000", "110420" ], + "201243" : [ "20:43", "800000", "110420" ], + "201244" : [ "20:44", "800000", "110420" ], + "201245" : [ "20:45", "800000", "110420" ], + "201246" : [ "20:46", "800000", "110420" ], + "201247" : [ "20:47", "800000", "110420" ], + "201248" : [ "20:48", "800000", "110420" ], + "201249" : [ "20:49", "800000", "110420" ], + "201250" : [ "20:50", "800000", "110420" ], + "201251" : [ "20:51", "800000", "110420" ], + "201252" : [ "20:52", "800000", "110420" ], + "201253" : [ "20:53", "800000", "110420" ], + "201254" : [ "20:54", "800000", "110420" ], + "201255" : [ "20:55", "800000", "110420" ], + "201256" : [ "20:56", "800000", "110420" ], + "201257" : [ "20:57", "800000", "110420" ], + "201258" : [ "20:58", "800000", "110420" ], + "201259" : [ "20:59", "800000", "110420" ], + "201260" : [ "21:00", "800000", "110420" ], + "201261" : [ "21:01", "800000", "110420" ], + "201262" : [ "21:02", "800000", "110420" ], + "201263" : [ "21:03", "800000", "110420" ], + "201264" : [ "21:04", "800000", "110420" ], + "201265" : [ "21:05", "800000", "110420" ], + "201266" : [ "21:06", "800000", "110420" ], + "201267" : [ "21:07", "800000", "110420" ], + "201268" : [ "21:08", "800000", "110420" ], + "201269" : [ "21:09", "800000", "110420" ], + "201270" : [ "21:10", "800000", "110420" ], + "201271" : [ "21:11", "800000", "110420" ], + "201272" : [ "21:12", "800000", "110420" ], + "201273" : [ "21:13", "800000", "110420" ], + "201274" : [ "21:14", "800000", "110420" ], + "201275" : [ "21:15", "800000", "110420" ], + "201276" : [ "21:16", "800000", "110420" ], + "201277" : [ "21:17", "800000", "110420" ], + "201278" : [ "21:18", "800000", "110420" ], + "201279" : [ "21:19", "800000", "110420" ], + "201280" : [ "21:20", "800000", "110420" ], + "201281" : [ "21:21", "800000", "110420" ], + "201282" : [ "21:22", "800000", "110420" ], + "201283" : [ "21:23", "800000", "110420" ], + "201284" : [ "21:24", "800000", "110420" ], + "201285" : [ "21:25", "800000", "110420" ], + "201286" : [ "21:26", "800000", "110420" ], + "201287" : [ "21:27", "800000", "110420" ], + "201288" : [ "21:28", "800000", "110420" ], + "201289" : [ "21:29", "800000", "110420" ], + "201290" : [ "21:30", "800000", "110420" ], + "201291" : [ "21:31", "800000", "110420" ], + "201292" : [ "21:32", "800000", "110420" ], + "201293" : [ "21:33", "800000", "110420" ], + "201294" : [ "21:34", "800000", "110420" ], + "201295" : [ "21:35", "800000", "110420" ], + "201296" : [ "21:36", "800000", "110420" ], + "201297" : [ "21:37", "800000", "110420" ], + "201298" : [ "21:38", "800000", "110420" ], + "201299" : [ "21:39", "800000", "110420" ], + "201300" : [ "21:40", "800000", "110420" ], + "201301" : [ "21:41", "800000", "110420" ], + "201302" : [ "21:42", "800000", "110420" ], + "201303" : [ "21:43", "800000", "110420" ], + "201304" : [ "21:44", "800000", "110420" ], + "201305" : [ "21:45", "800000", "110420" ], + "201306" : [ "21:46", "800000", "110420" ], + "201307" : [ "21:47", "800000", "110420" ], + "201308" : [ "21:48", "800000", "110420" ], + "201309" : [ "21:49", "800000", "110420" ], + "201310" : [ "21:50", "800000", "110420" ], + "201311" : [ "21:51", "800000", "110420" ], + "201312" : [ "21:52", "800000", "110420" ], + "201313" : [ "21:53", "800000", "110420" ], + "201314" : [ "21:54", "800000", "110420" ], + "201315" : [ "21:55", "800000", "110420" ], + "201316" : [ "21:56", "800000", "110420" ], + "201317" : [ "21:57", "800000", "110420" ], + "201318" : [ "21:58", "800000", "110420" ], + "201319" : [ "21:59", "800000", "110420" ], + "201320" : [ "22:00", "800000", "110420" ], + "201321" : [ "22:01", "800000", "110420" ], + "201322" : [ "22:02", "800000", "110420" ], + "201323" : [ "22:03", "800000", "110420" ], + "201324" : [ "22:04", "800000", "110420" ], + "201325" : [ "22:05", "800000", "110420" ], + "201326" : [ "22:06", "800000", "110420" ], + "201327" : [ "22:07", "800000", "110420" ], + "201328" : [ "22:08", "800000", "110420" ], + "201329" : [ "22:09", "800000", "110420" ], + "201330" : [ "22:10", "800000", "110420" ], + "201331" : [ "22:11", "800000", "110420" ], + "201332" : [ "22:12", "800000", "110420" ], + "201333" : [ "22:13", "800000", "110420" ], + "201334" : [ "22:14", "800000", "110420" ], + "201335" : [ "22:15", "800000", "110420" ], + "201336" : [ "22:16", "800000", "110420" ], + "201337" : [ "22:17", "800000", "110420" ], + "201338" : [ "22:18", "800000", "110420" ], + "201339" : [ "22:19", "800000", "110420" ], + "201340" : [ "22:20", "800000", "110420" ], + "201341" : [ "22:21", "800000", "110420" ], + "201342" : [ "22:22", "800000", "110420" ], + "201343" : [ "22:23", "800000", "110420" ], + "201344" : [ "22:24", "800000", "110420" ], + "201345" : [ "22:25", "800000", "110420" ], + "201346" : [ "22:26", "800000", "110420" ], + "201347" : [ "22:27", "800000", "110420" ], + "201348" : [ "22:28", "800000", "110420" ], + "201349" : [ "22:29", "800000", "110420" ], + "201350" : [ "22:30", "800000", "110420" ], + "201351" : [ "22:31", "800000", "110420" ], + "201352" : [ "22:32", "800000", "110420" ], + "201353" : [ "22:33", "800000", "110420" ], + "201354" : [ "22:34", "800000", "110420" ], + "201355" : [ "22:35", "800000", "110420" ], + "201356" : [ "22:36", "800000", "110420" ], + "201357" : [ "22:37", "800000", "110420" ], + "201358" : [ "22:38", "800000", "110420" ], + "201359" : [ "22:39", "800000", "110420" ], + "201360" : [ "22:40", "800000", "110420" ], + "201361" : [ "22:41", "800000", "110420" ], + "201362" : [ "22:42", "800000", "110420" ], + "201363" : [ "22:43", "800000", "110420" ], + "201364" : [ "22:44", "800000", "110420" ], + "201365" : [ "22:45", "800000", "110420" ], + "201366" : [ "22:46", "800000", "110420" ], + "201367" : [ "22:47", "800000", "110420" ], + "201368" : [ "22:48", "800000", "110420" ], + "201369" : [ "22:49", "800000", "110420" ], + "201370" : [ "22:50", "800000", "110420" ], + "201371" : [ "22:51", "800000", "110420" ], + "201372" : [ "22:52", "800000", "110420" ], + "201373" : [ "22:53", "800000", "110420" ], + "201374" : [ "22:54", "800000", "110420" ], + "201375" : [ "22:55", "800000", "110420" ], + "201376" : [ "22:56", "800000", "110420" ], + "201377" : [ "22:57", "800000", "110420" ], + "201378" : [ "22:58", "800000", "110420" ], + "201379" : [ "22:59", "800000", "110420" ], + "201380" : [ "23:00", "800000", "110420" ], + "201381" : [ "23:01", "800000", "110420" ], + "201382" : [ "23:02", "800000", "110420" ], + "201383" : [ "23:03", "800000", "110420" ], + "201384" : [ "23:04", "800000", "110420" ], + "201385" : [ "23:05", "800000", "110420" ], + "201386" : [ "23:06", "800000", "110420" ], + "201387" : [ "23:07", "800000", "110420" ], + "201388" : [ "23:08", "800000", "110420" ], + "201389" : [ "23:09", "800000", "110420" ], + "201390" : [ "23:10", "800000", "110420" ], + "201391" : [ "23:11", "800000", "110420" ], + "201392" : [ "23:12", "800000", "110420" ], + "201393" : [ "23:13", "800000", "110420" ], + "201394" : [ "23:14", "800000", "110420" ], + "201395" : [ "23:15", "800000", "110420" ], + "201396" : [ "23:16", "800000", "110420" ], + "201397" : [ "23:17", "800000", "110420" ], + "201398" : [ "23:18", "800000", "110420" ], + "201399" : [ "23:19", "800000", "110420" ], + "201400" : [ "23:20", "800000", "110420" ], + "201401" : [ "23:21", "800000", "110420" ], + "201402" : [ "23:22", "800000", "110420" ], + "201403" : [ "23:23", "800000", "110420" ], + "201404" : [ "23:24", "800000", "110420" ], + "201405" : [ "23:25", "800000", "110420" ], + "201406" : [ "23:26", "800000", "110420" ], + "201407" : [ "23:27", "800000", "110420" ], + "201408" : [ "23:28", "800000", "110420" ], + "201409" : [ "23:29", "800000", "110420" ], + "201410" : [ "23:30", "800000", "110420" ], + "201411" : [ "23:31", "800000", "110420" ], + "201412" : [ "23:32", "800000", "110420" ], + "201413" : [ "23:33", "800000", "110420" ], + "201414" : [ "23:34", "800000", "110420" ], + "201415" : [ "23:35", "800000", "110420" ], + "201416" : [ "23:36", "800000", "110420" ], + "201417" : [ "23:37", "800000", "110420" ], + "201418" : [ "23:38", "800000", "110420" ], + "201419" : [ "23:39", "800000", "110420" ], + "201420" : [ "23:40", "800000", "110420" ], + "201421" : [ "23:41", "800000", "110420" ], + "201422" : [ "23:42", "800000", "110420" ], + "201423" : [ "23:43", "800000", "110420" ], + "201424" : [ "23:44", "800000", "110420" ], + "201425" : [ "23:45", "800000", "110420" ], + "201426" : [ "23:46", "800000", "110420" ], + "201427" : [ "23:47", "800000", "110420" ], + "201428" : [ "23:48", "800000", "110420" ], + "201429" : [ "23:49", "800000", "110420" ], + "201430" : [ "23:50", "800000", "110420" ], + "201431" : [ "23:51", "800000", "110420" ], + "201432" : [ "23:52", "800000", "110420" ], + "201433" : [ "23:53", "800000", "110420" ], + "201434" : [ "23:54", "800000", "110420" ], + "201435" : [ "23:55", "800000", "110420" ], + "201436" : [ "23:56", "800000", "110420" ], + "201437" : [ "23:57", "800000", "110420" ], + "201438" : [ "23:58", "800000", "110420" ], + "201439" : [ "23:59", "800000", "110420" ] + }, + "Tuesday": { + "210000" : [ "00:00", "800000", "110420" ], + "210001" : [ "00:01", "800000", "110420" ], + "210002" : [ "00:02", "800000", "110420" ], + "210003" : [ "00:03", "800000", "110420" ], + "210004" : [ "00:04", "800000", "110420" ], + "210005" : [ "00:05", "800000", "110420" ], + "210006" : [ "00:06", "800000", "110420" ], + "210007" : [ "00:07", "800000", "110420" ], + "210008" : [ "00:08", "800000", "110420" ], + "210009" : [ "00:09", "800000", "110420" ], + "210010" : [ "00:10", "800000", "110420" ], + "210011" : [ "00:11", "800000", "110420" ], + "210012" : [ "00:12", "800000", "110420" ], + "210013" : [ "00:13", "800000", "110420" ], + "210014" : [ "00:14", "800000", "110420" ], + "210015" : [ "00:15", "800000", "110420" ], + "210016" : [ "00:16", "800000", "110420" ], + "210017" : [ "00:17", "800000", "110420" ], + "210018" : [ "00:18", "800000", "110420" ], + "210019" : [ "00:19", "800000", "110420" ], + "210020" : [ "00:20", "800000", "110420" ], + "210021" : [ "00:21", "800000", "110420" ], + "210022" : [ "00:22", "800000", "110420" ], + "210023" : [ "00:23", "800000", "110420" ], + "210024" : [ "00:24", "800000", "110420" ], + "210025" : [ "00:25", "800000", "110420" ], + "210026" : [ "00:26", "800000", "110420" ], + "210027" : [ "00:27", "800000", "110420" ], + "210028" : [ "00:28", "800000", "110420" ], + "210029" : [ "00:29", "800000", "110420" ], + "210030" : [ "00:30", "800000", "110420" ], + "210031" : [ "00:31", "800000", "110420" ], + "210032" : [ "00:32", "800000", "110420" ], + "210033" : [ "00:33", "800000", "110420" ], + "210034" : [ "00:34", "800000", "110420" ], + "210035" : [ "00:35", "800000", "110420" ], + "210036" : [ "00:36", "800000", "110420" ], + "210037" : [ "00:37", "800000", "110420" ], + "210038" : [ "00:38", "800000", "110420" ], + "210039" : [ "00:39", "800000", "110420" ], + "210040" : [ "00:40", "800000", "110420" ], + "210041" : [ "00:41", "800000", "110420" ], + "210042" : [ "00:42", "800000", "110420" ], + "210043" : [ "00:43", "800000", "110420" ], + "210044" : [ "00:44", "800000", "110420" ], + "210045" : [ "00:45", "800000", "110420" ], + "210046" : [ "00:46", "800000", "110420" ], + "210047" : [ "00:47", "800000", "110420" ], + "210048" : [ "00:48", "800000", "110420" ], + "210049" : [ "00:49", "800000", "110420" ], + "210050" : [ "00:50", "800000", "110420" ], + "210051" : [ "00:51", "800000", "110420" ], + "210052" : [ "00:52", "800000", "110420" ], + "210053" : [ "00:53", "800000", "110420" ], + "210054" : [ "00:54", "800000", "110420" ], + "210055" : [ "00:55", "800000", "110420" ], + "210056" : [ "00:56", "800000", "110420" ], + "210057" : [ "00:57", "800000", "110420" ], + "210058" : [ "00:58", "800000", "110420" ], + "210059" : [ "00:59", "800000", "110420" ], + "210060" : [ "01:00", "800000", "110420" ], + "210061" : [ "01:01", "800000", "110420" ], + "210062" : [ "01:02", "800000", "110420" ], + "210063" : [ "01:03", "800000", "110420" ], + "210064" : [ "01:04", "800000", "110420" ], + "210065" : [ "01:05", "800000", "110420" ], + "210066" : [ "01:06", "800000", "110420" ], + "210067" : [ "01:07", "800000", "110420" ], + "210068" : [ "01:08", "800000", "110420" ], + "210069" : [ "01:09", "800000", "110420" ], + "210070" : [ "01:10", "800000", "110420" ], + "210071" : [ "01:11", "800000", "110420" ], + "210072" : [ "01:12", "800000", "110420" ], + "210073" : [ "01:13", "800000", "110420" ], + "210074" : [ "01:14", "800000", "110420" ], + "210075" : [ "01:15", "800000", "110420" ], + "210076" : [ "01:16", "800000", "110420" ], + "210077" : [ "01:17", "800000", "110420" ], + "210078" : [ "01:18", "800000", "110420" ], + "210079" : [ "01:19", "800000", "110420" ], + "210080" : [ "01:20", "800000", "110420" ], + "210081" : [ "01:21", "800000", "110420" ], + "210082" : [ "01:22", "800000", "110420" ], + "210083" : [ "01:23", "800000", "110420" ], + "210084" : [ "01:24", "800000", "110420" ], + "210085" : [ "01:25", "800000", "110420" ], + "210086" : [ "01:26", "800000", "110420" ], + "210087" : [ "01:27", "800000", "110420" ], + "210088" : [ "01:28", "800000", "110420" ], + "210089" : [ "01:29", "800000", "110420" ], + "210090" : [ "01:30", "800000", "110420" ], + "210091" : [ "01:31", "800000", "110420" ], + "210092" : [ "01:32", "800000", "110420" ], + "210093" : [ "01:33", "800000", "110420" ], + "210094" : [ "01:34", "800000", "110420" ], + "210095" : [ "01:35", "800000", "110420" ], + "210096" : [ "01:36", "800000", "110420" ], + "210097" : [ "01:37", "800000", "110420" ], + "210098" : [ "01:38", "800000", "110420" ], + "210099" : [ "01:39", "800000", "110420" ], + "210100" : [ "01:40", "800000", "110420" ], + "210101" : [ "01:41", "800000", "110420" ], + "210102" : [ "01:42", "800000", "110420" ], + "210103" : [ "01:43", "800000", "110420" ], + "210104" : [ "01:44", "800000", "110420" ], + "210105" : [ "01:45", "800000", "110420" ], + "210106" : [ "01:46", "800000", "110420" ], + "210107" : [ "01:47", "800000", "110420" ], + "210108" : [ "01:48", "800000", "110420" ], + "210109" : [ "01:49", "800000", "110420" ], + "210110" : [ "01:50", "800000", "110420" ], + "210111" : [ "01:51", "800000", "110420" ], + "210112" : [ "01:52", "800000", "110420" ], + "210113" : [ "01:53", "800000", "110420" ], + "210114" : [ "01:54", "800000", "110420" ], + "210115" : [ "01:55", "800000", "110420" ], + "210116" : [ "01:56", "800000", "110420" ], + "210117" : [ "01:57", "800000", "110420" ], + "210118" : [ "01:58", "800000", "110420" ], + "210119" : [ "01:59", "800000", "110420" ], + "210120" : [ "02:00", "800000", "110420" ], + "210121" : [ "02:01", "800000", "110420" ], + "210122" : [ "02:02", "800000", "110420" ], + "210123" : [ "02:03", "800000", "110420" ], + "210124" : [ "02:04", "800000", "110420" ], + "210125" : [ "02:05", "800000", "110420" ], + "210126" : [ "02:06", "800000", "110420" ], + "210127" : [ "02:07", "800000", "110420" ], + "210128" : [ "02:08", "800000", "110420" ], + "210129" : [ "02:09", "800000", "110420" ], + "210130" : [ "02:10", "800000", "110420" ], + "210131" : [ "02:11", "800000", "110420" ], + "210132" : [ "02:12", "800000", "110420" ], + "210133" : [ "02:13", "800000", "110420" ], + "210134" : [ "02:14", "800000", "110420" ], + "210135" : [ "02:15", "800000", "110420" ], + "210136" : [ "02:16", "800000", "110420" ], + "210137" : [ "02:17", "800000", "110420" ], + "210138" : [ "02:18", "800000", "110420" ], + "210139" : [ "02:19", "800000", "110420" ], + "210140" : [ "02:20", "800000", "110420" ], + "210141" : [ "02:21", "800000", "110420" ], + "210142" : [ "02:22", "800000", "110420" ], + "210143" : [ "02:23", "800000", "110420" ], + "210144" : [ "02:24", "800000", "110420" ], + "210145" : [ "02:25", "800000", "110420" ], + "210146" : [ "02:26", "800000", "110420" ], + "210147" : [ "02:27", "800000", "110420" ], + "210148" : [ "02:28", "800000", "110420" ], + "210149" : [ "02:29", "800000", "110420" ], + "210150" : [ "02:30", "800000", "110420" ], + "210151" : [ "02:31", "800000", "110420" ], + "210152" : [ "02:32", "800000", "110420" ], + "210153" : [ "02:33", "800000", "110420" ], + "210154" : [ "02:34", "800000", "110420" ], + "210155" : [ "02:35", "800000", "110420" ], + "210156" : [ "02:36", "800000", "110420" ], + "210157" : [ "02:37", "800000", "110420" ], + "210158" : [ "02:38", "800000", "110420" ], + "210159" : [ "02:39", "800000", "110420" ], + "210160" : [ "02:40", "800000", "110420" ], + "210161" : [ "02:41", "800000", "110420" ], + "210162" : [ "02:42", "800000", "110420" ], + "210163" : [ "02:43", "800000", "110420" ], + "210164" : [ "02:44", "800000", "110420" ], + "210165" : [ "02:45", "800000", "110420" ], + "210166" : [ "02:46", "800000", "110420" ], + "210167" : [ "02:47", "800000", "110420" ], + "210168" : [ "02:48", "800000", "110420" ], + "210169" : [ "02:49", "800000", "110420" ], + "210170" : [ "02:50", "800000", "110420" ], + "210171" : [ "02:51", "800000", "110420" ], + "210172" : [ "02:52", "800000", "110420" ], + "210173" : [ "02:53", "800000", "110420" ], + "210174" : [ "02:54", "800000", "110420" ], + "210175" : [ "02:55", "800000", "110420" ], + "210176" : [ "02:56", "800000", "110420" ], + "210177" : [ "02:57", "800000", "110420" ], + "210178" : [ "02:58", "800000", "110420" ], + "210179" : [ "02:59", "800000", "110420" ], + "210180" : [ "03:00", "800000", "110420" ], + "210181" : [ "03:01", "800000", "110420" ], + "210182" : [ "03:02", "800000", "110420" ], + "210183" : [ "03:03", "800000", "110420" ], + "210184" : [ "03:04", "800000", "110420" ], + "210185" : [ "03:05", "800000", "110420" ], + "210186" : [ "03:06", "800000", "110420" ], + "210187" : [ "03:07", "800000", "110420" ], + "210188" : [ "03:08", "800000", "110420" ], + "210189" : [ "03:09", "800000", "110420" ], + "210190" : [ "03:10", "800000", "110420" ], + "210191" : [ "03:11", "800000", "110420" ], + "210192" : [ "03:12", "800000", "110420" ], + "210193" : [ "03:13", "800000", "110420" ], + "210194" : [ "03:14", "800000", "110420" ], + "210195" : [ "03:15", "800000", "110420" ], + "210196" : [ "03:16", "800000", "110420" ], + "210197" : [ "03:17", "800000", "110420" ], + "210198" : [ "03:18", "800000", "110420" ], + "210199" : [ "03:19", "800000", "110420" ], + "210200" : [ "03:20", "800000", "110420" ], + "210201" : [ "03:21", "800000", "110420" ], + "210202" : [ "03:22", "800000", "110420" ], + "210203" : [ "03:23", "800000", "110420" ], + "210204" : [ "03:24", "800000", "110420" ], + "210205" : [ "03:25", "800000", "110420" ], + "210206" : [ "03:26", "800000", "110420" ], + "210207" : [ "03:27", "800000", "110420" ], + "210208" : [ "03:28", "800000", "110420" ], + "210209" : [ "03:29", "800000", "110420" ], + "210210" : [ "03:30", "800000", "110420" ], + "210211" : [ "03:31", "800000", "110420" ], + "210212" : [ "03:32", "800000", "110420" ], + "210213" : [ "03:33", "800000", "110420" ], + "210214" : [ "03:34", "800000", "110420" ], + "210215" : [ "03:35", "800000", "110420" ], + "210216" : [ "03:36", "800000", "110420" ], + "210217" : [ "03:37", "800000", "110420" ], + "210218" : [ "03:38", "800000", "110420" ], + "210219" : [ "03:39", "800000", "110420" ], + "210220" : [ "03:40", "800000", "110420" ], + "210221" : [ "03:41", "800000", "110420" ], + "210222" : [ "03:42", "800000", "110420" ], + "210223" : [ "03:43", "800000", "110420" ], + "210224" : [ "03:44", "800000", "110420" ], + "210225" : [ "03:45", "800000", "110420" ], + "210226" : [ "03:46", "800000", "110420" ], + "210227" : [ "03:47", "800000", "110420" ], + "210228" : [ "03:48", "800000", "110420" ], + "210229" : [ "03:49", "800000", "110420" ], + "210230" : [ "03:50", "800000", "110420" ], + "210231" : [ "03:51", "800000", "110420" ], + "210232" : [ "03:52", "800000", "110420" ], + "210233" : [ "03:53", "800000", "110420" ], + "210234" : [ "03:54", "800000", "110420" ], + "210235" : [ "03:55", "800000", "110420" ], + "210236" : [ "03:56", "800000", "110420" ], + "210237" : [ "03:57", "800000", "110420" ], + "210238" : [ "03:58", "800000", "110420" ], + "210239" : [ "03:59", "800000", "110420" ], + "210240" : [ "04:00", "800000", "110420" ], + "210241" : [ "04:01", "800000", "110420" ], + "210242" : [ "04:02", "800000", "110420" ], + "210243" : [ "04:03", "800000", "110420" ], + "210244" : [ "04:04", "800000", "110420" ], + "210245" : [ "04:05", "800000", "110420" ], + "210246" : [ "04:06", "800000", "110420" ], + "210247" : [ "04:07", "800000", "110420" ], + "210248" : [ "04:08", "800000", "110420" ], + "210249" : [ "04:09", "800000", "110420" ], + "210250" : [ "04:10", "800000", "110420" ], + "210251" : [ "04:11", "800000", "110420" ], + "210252" : [ "04:12", "800000", "110420" ], + "210253" : [ "04:13", "800000", "110420" ], + "210254" : [ "04:14", "800000", "110420" ], + "210255" : [ "04:15", "800000", "110420" ], + "210256" : [ "04:16", "800000", "110420" ], + "210257" : [ "04:17", "800000", "110420" ], + "210258" : [ "04:18", "800000", "110420" ], + "210259" : [ "04:19", "800000", "110420" ], + "210260" : [ "04:20", "800000", "110420" ], + "210261" : [ "04:21", "800000", "110420" ], + "210262" : [ "04:22", "800000", "110420" ], + "210263" : [ "04:23", "800000", "110420" ], + "210264" : [ "04:24", "800000", "110420" ], + "210265" : [ "04:25", "800000", "110420" ], + "210266" : [ "04:26", "800000", "110420" ], + "210267" : [ "04:27", "800000", "110420" ], + "210268" : [ "04:28", "800000", "110420" ], + "210269" : [ "04:29", "800000", "110420" ], + "210270" : [ "04:30", "800000", "110420" ], + "210271" : [ "04:31", "800000", "110420" ], + "210272" : [ "04:32", "800000", "110420" ], + "210273" : [ "04:33", "800000", "110420" ], + "210274" : [ "04:34", "800000", "110420" ], + "210275" : [ "04:35", "800000", "110420" ], + "210276" : [ "04:36", "800000", "110420" ], + "210277" : [ "04:37", "800000", "110420" ], + "210278" : [ "04:38", "800000", "110420" ], + "210279" : [ "04:39", "800000", "110420" ], + "210280" : [ "04:40", "800000", "110420" ], + "210281" : [ "04:41", "800000", "110420" ], + "210282" : [ "04:42", "800000", "110420" ], + "210283" : [ "04:43", "800000", "110420" ], + "210284" : [ "04:44", "800000", "110420" ], + "210285" : [ "04:45", "800000", "110420" ], + "210286" : [ "04:46", "800000", "110420" ], + "210287" : [ "04:47", "800000", "110420" ], + "210288" : [ "04:48", "800000", "110420" ], + "210289" : [ "04:49", "800000", "110420" ], + "210290" : [ "04:50", "800000", "110420" ], + "210291" : [ "04:51", "800000", "110420" ], + "210292" : [ "04:52", "800000", "110420" ], + "210293" : [ "04:53", "800000", "110420" ], + "210294" : [ "04:54", "800000", "110420" ], + "210295" : [ "04:55", "800000", "110420" ], + "210296" : [ "04:56", "800000", "110420" ], + "210297" : [ "04:57", "800000", "110420" ], + "210298" : [ "04:58", "800000", "110420" ], + "210299" : [ "04:59", "800000", "110420" ], + "210300" : [ "05:00", "800000", "110420" ], + "210301" : [ "05:01", "800000", "110420" ], + "210302" : [ "05:02", "800000", "110420" ], + "210303" : [ "05:03", "800000", "110420" ], + "210304" : [ "05:04", "800000", "110420" ], + "210305" : [ "05:05", "800000", "110420" ], + "210306" : [ "05:06", "800000", "110420" ], + "210307" : [ "05:07", "800000", "110420" ], + "210308" : [ "05:08", "800000", "110420" ], + "210309" : [ "05:09", "800000", "110420" ], + "210310" : [ "05:10", "800000", "110420" ], + "210311" : [ "05:11", "800000", "110420" ], + "210312" : [ "05:12", "800000", "110420" ], + "210313" : [ "05:13", "800000", "110420" ], + "210314" : [ "05:14", "800000", "110420" ], + "210315" : [ "05:15", "800000", "110420" ], + "210316" : [ "05:16", "800000", "110420" ], + "210317" : [ "05:17", "800000", "110420" ], + "210318" : [ "05:18", "800000", "110420" ], + "210319" : [ "05:19", "800000", "110420" ], + "210320" : [ "05:20", "800000", "110420" ], + "210321" : [ "05:21", "800000", "110420" ], + "210322" : [ "05:22", "800000", "110420" ], + "210323" : [ "05:23", "800000", "110420" ], + "210324" : [ "05:24", "800000", "110420" ], + "210325" : [ "05:25", "800000", "110420" ], + "210326" : [ "05:26", "800000", "110420" ], + "210327" : [ "05:27", "800000", "110420" ], + "210328" : [ "05:28", "800000", "110420" ], + "210329" : [ "05:29", "800000", "110420" ], + "210330" : [ "05:30", "800000", "110420" ], + "210331" : [ "05:31", "800000", "110420" ], + "210332" : [ "05:32", "800000", "110420" ], + "210333" : [ "05:33", "800000", "110420" ], + "210334" : [ "05:34", "800000", "110420" ], + "210335" : [ "05:35", "800000", "110420" ], + "210336" : [ "05:36", "800000", "110420" ], + "210337" : [ "05:37", "800000", "110420" ], + "210338" : [ "05:38", "800000", "110420" ], + "210339" : [ "05:39", "800000", "110420" ], + "210340" : [ "05:40", "800000", "110420" ], + "210341" : [ "05:41", "800000", "110420" ], + "210342" : [ "05:42", "800000", "110420" ], + "210343" : [ "05:43", "800000", "110420" ], + "210344" : [ "05:44", "800000", "110420" ], + "210345" : [ "05:45", "800000", "110420" ], + "210346" : [ "05:46", "800000", "110420" ], + "210347" : [ "05:47", "800000", "110420" ], + "210348" : [ "05:48", "800000", "110420" ], + "210349" : [ "05:49", "800000", "110420" ], + "210350" : [ "05:50", "800000", "110420" ], + "210351" : [ "05:51", "800000", "110420" ], + "210352" : [ "05:52", "800000", "110420" ], + "210353" : [ "05:53", "800000", "110420" ], + "210354" : [ "05:54", "800000", "110420" ], + "210355" : [ "05:55", "800000", "110420" ], + "210356" : [ "05:56", "800000", "110420" ], + "210357" : [ "05:57", "800000", "110420" ], + "210358" : [ "05:58", "800000", "110420" ], + "210359" : [ "05:59", "800000", "110420" ], + "210360" : [ "06:00", "800000", "110420" ], + "210361" : [ "06:01", "800000", "110420" ], + "210362" : [ "06:02", "800000", "110420" ], + "210363" : [ "06:03", "800000", "110420" ], + "210364" : [ "06:04", "800000", "110420" ], + "210365" : [ "06:05", "800000", "110420" ], + "210366" : [ "06:06", "800000", "110420" ], + "210367" : [ "06:07", "800000", "110420" ], + "210368" : [ "06:08", "800000", "110420" ], + "210369" : [ "06:09", "800000", "110420" ], + "210370" : [ "06:10", "800000", "110420" ], + "210371" : [ "06:11", "800000", "110420" ], + "210372" : [ "06:12", "800000", "110420" ], + "210373" : [ "06:13", "800000", "110420" ], + "210374" : [ "06:14", "800000", "110420" ], + "210375" : [ "06:15", "800000", "110420" ], + "210376" : [ "06:16", "800000", "110420" ], + "210377" : [ "06:17", "800000", "110420" ], + "210378" : [ "06:18", "800000", "110420" ], + "210379" : [ "06:19", "800000", "110420" ], + "210380" : [ "06:20", "800000", "110420" ], + "210381" : [ "06:21", "800000", "110420" ], + "210382" : [ "06:22", "800000", "110420" ], + "210383" : [ "06:23", "800000", "110420" ], + "210384" : [ "06:24", "800000", "110420" ], + "210385" : [ "06:25", "800000", "110420" ], + "210386" : [ "06:26", "800000", "110420" ], + "210387" : [ "06:27", "800000", "110420" ], + "210388" : [ "06:28", "800000", "110420" ], + "210389" : [ "06:29", "800000", "110420" ], + "210390" : [ "06:30", "800000", "110420" ], + "210391" : [ "06:31", "800000", "110420" ], + "210392" : [ "06:32", "800000", "110420" ], + "210393" : [ "06:33", "800000", "110420" ], + "210394" : [ "06:34", "800000", "110420" ], + "210395" : [ "06:35", "800000", "110420" ], + "210396" : [ "06:36", "800000", "110420" ], + "210397" : [ "06:37", "800000", "110420" ], + "210398" : [ "06:38", "800000", "110420" ], + "210399" : [ "06:39", "800000", "110420" ], + "210400" : [ "06:40", "800000", "110420" ], + "210401" : [ "06:41", "800000", "110420" ], + "210402" : [ "06:42", "800000", "110420" ], + "210403" : [ "06:43", "800000", "110420" ], + "210404" : [ "06:44", "800000", "110420" ], + "210405" : [ "06:45", "800000", "110420" ], + "210406" : [ "06:46", "800000", "110420" ], + "210407" : [ "06:47", "800000", "110420" ], + "210408" : [ "06:48", "800000", "110420" ], + "210409" : [ "06:49", "800000", "110420" ], + "210410" : [ "06:50", "800000", "110420" ], + "210411" : [ "06:51", "800000", "110420" ], + "210412" : [ "06:52", "800000", "110420" ], + "210413" : [ "06:53", "800000", "110420" ], + "210414" : [ "06:54", "800000", "110420" ], + "210415" : [ "06:55", "800000", "110420" ], + "210416" : [ "06:56", "800000", "110420" ], + "210417" : [ "06:57", "800000", "110420" ], + "210418" : [ "06:58", "800000", "110420" ], + "210419" : [ "06:59", "800000", "110420" ], + "210420" : [ "07:00", "350000", "110480" ], + "210421" : [ "07:01", "350000", "110481" ], + "210422" : [ "07:02", "350000", "110482" ], + "210423" : [ "07:03", "350000", "110483" ], + "210424" : [ "07:04", "350000", "110484" ], + "210425" : [ "07:05", "350000", "110485" ], + "210426" : [ "07:06", "350000", "110486" ], + "210427" : [ "07:07", "350000", "110487" ], + "210428" : [ "07:08", "350000", "110488" ], + "210429" : [ "07:09", "350000", "110489" ], + "210430" : [ "07:10", "350000", "110490" ], + "210431" : [ "07:11", "350000", "110491" ], + "210432" : [ "07:12", "350000", "110492" ], + "210433" : [ "07:13", "350000", "110493" ], + "210434" : [ "07:14", "350000", "110494" ], + "210435" : [ "07:15", "350000", "110495" ], + "210436" : [ "07:16", "350000", "110496" ], + "210437" : [ "07:17", "350000", "110497" ], + "210438" : [ "07:18", "350000", "110498" ], + "210439" : [ "07:19", "350000", "110499" ], + "210440" : [ "07:20", "350000", "110500" ], + "210441" : [ "07:21", "350000", "110501" ], + "210442" : [ "07:22", "350000", "110502" ], + "210443" : [ "07:23", "350000", "110503" ], + "210444" : [ "07:24", "350000", "110504" ], + "210445" : [ "07:25", "350000", "110505" ], + "210446" : [ "07:26", "350000", "110506" ], + "210447" : [ "07:27", "350000", "110507" ], + "210448" : [ "07:28", "350000", "110508" ], + "210449" : [ "07:29", "350000", "110509" ], + "210450" : [ "07:30", "350000", "110510" ], + "210451" : [ "07:31", "350000", "110511" ], + "210452" : [ "07:32", "350000", "110512" ], + "210453" : [ "07:33", "350000", "110513" ], + "210454" : [ "07:34", "350000", "110514" ], + "210455" : [ "07:35", "350000", "110515" ], + "210456" : [ "07:36", "350000", "110516" ], + "210457" : [ "07:37", "350000", "110517" ], + "210458" : [ "07:38", "350000", "110518" ], + "210459" : [ "07:39", "350000", "110519" ], + "210460" : [ "07:40", "350000", "110520" ], + "210461" : [ "07:41", "350000", "110521" ], + "210462" : [ "07:42", "350000", "110522" ], + "210463" : [ "07:43", "350000", "110523" ], + "210464" : [ "07:44", "350000", "110524" ], + "210465" : [ "07:45", "350000", "110525" ], + "210466" : [ "07:46", "350000", "110526" ], + "210467" : [ "07:47", "350000", "110527" ], + "210468" : [ "07:48", "350000", "110528" ], + "210469" : [ "07:49", "350000", "110529" ], + "210470" : [ "07:50", "350000", "110530" ], + "210471" : [ "07:51", "350000", "110531" ], + "210472" : [ "07:52", "350000", "110532" ], + "210473" : [ "07:53", "350000", "110533" ], + "210474" : [ "07:54", "350000", "110534" ], + "210475" : [ "07:55", "350000", "110535" ], + "210476" : [ "07:56", "350000", "110536" ], + "210477" : [ "07:57", "350000", "110537" ], + "210478" : [ "07:58", "350000", "110538" ], + "210479" : [ "07:59", "350000", "110539" ], + "210480" : [ "08:00", "350000", "110540" ], + "210481" : [ "08:01", "350000", "110541" ], + "210482" : [ "08:02", "350000", "110542" ], + "210483" : [ "08:03", "350000", "110543" ], + "210484" : [ "08:04", "350000", "110544" ], + "210485" : [ "08:05", "350000", "110545" ], + "210486" : [ "08:06", "350000", "110546" ], + "210487" : [ "08:07", "350000", "110547" ], + "210488" : [ "08:08", "350000", "110548" ], + "210489" : [ "08:09", "350000", "110549" ], + "210490" : [ "08:10", "350000", "110550" ], + "210491" : [ "08:11", "350000", "110551" ], + "210492" : [ "08:12", "350000", "110552" ], + "210493" : [ "08:13", "350000", "110553" ], + "210494" : [ "08:14", "350000", "110554" ], + "210495" : [ "08:15", "350000", "110555" ], + "210496" : [ "08:16", "350000", "110556" ], + "210497" : [ "08:17", "350000", "110557" ], + "210498" : [ "08:18", "350000", "110558" ], + "210499" : [ "08:19", "350000", "110559" ], + "210500" : [ "08:20", "350000", "110560" ], + "210501" : [ "08:21", "350000", "110561" ], + "210502" : [ "08:22", "350000", "110562" ], + "210503" : [ "08:23", "350000", "110563" ], + "210504" : [ "08:24", "350000", "110564" ], + "210505" : [ "08:25", "350000", "110565" ], + "210506" : [ "08:26", "350000", "110566" ], + "210507" : [ "08:27", "350000", "110567" ], + "210508" : [ "08:28", "350000", "110568" ], + "210509" : [ "08:29", "350000", "110569" ], + "210510" : [ "08:30", "350000", "110570" ], + "210511" : [ "08:31", "350000", "110571" ], + "210512" : [ "08:32", "350000", "110572" ], + "210513" : [ "08:33", "350000", "110573" ], + "210514" : [ "08:34", "350000", "110574" ], + "210515" : [ "08:35", "350000", "110575" ], + "210516" : [ "08:36", "350000", "110576" ], + "210517" : [ "08:37", "350000", "110577" ], + "210518" : [ "08:38", "350000", "110578" ], + "210519" : [ "08:39", "350000", "110579" ], + "210520" : [ "08:40", "350000", "110580" ], + "210521" : [ "08:41", "350000", "110581" ], + "210522" : [ "08:42", "350000", "110582" ], + "210523" : [ "08:43", "350000", "110583" ], + "210524" : [ "08:44", "350000", "110584" ], + "210525" : [ "08:45", "350000", "110585" ], + "210526" : [ "08:46", "350000", "110586" ], + "210527" : [ "08:47", "350000", "110587" ], + "210528" : [ "08:48", "350000", "110588" ], + "210529" : [ "08:49", "350000", "110589" ], + "210530" : [ "08:50", "350000", "110590" ], + "210531" : [ "08:51", "350000", "110591" ], + "210532" : [ "08:52", "350000", "110592" ], + "210533" : [ "08:53", "350000", "110593" ], + "210534" : [ "08:54", "350000", "110594" ], + "210535" : [ "08:55", "350000", "110595" ], + "210536" : [ "08:56", "350000", "110596" ], + "210537" : [ "08:57", "350000", "110597" ], + "210538" : [ "08:58", "350000", "110598" ], + "210539" : [ "08:59", "350000", "110599" ], + "210540" : [ "09:00", "350000", "110600" ], + "210541" : [ "09:01", "350000", "110601" ], + "210542" : [ "09:02", "350000", "110602" ], + "210543" : [ "09:03", "350000", "110603" ], + "210544" : [ "09:04", "350000", "110604" ], + "210545" : [ "09:05", "350000", "110605" ], + "210546" : [ "09:06", "350000", "110606" ], + "210547" : [ "09:07", "350000", "110607" ], + "210548" : [ "09:08", "350000", "110608" ], + "210549" : [ "09:09", "350000", "110609" ], + "210550" : [ "09:10", "350000", "110610" ], + "210551" : [ "09:11", "350000", "110611" ], + "210552" : [ "09:12", "350000", "110612" ], + "210553" : [ "09:13", "350000", "110613" ], + "210554" : [ "09:14", "350000", "110614" ], + "210555" : [ "09:15", "350000", "110615" ], + "210556" : [ "09:16", "350000", "110616" ], + "210557" : [ "09:17", "350000", "110617" ], + "210558" : [ "09:18", "350000", "110618" ], + "210559" : [ "09:19", "350000", "110619" ], + "210560" : [ "09:20", "350000", "110620" ], + "210561" : [ "09:21", "350000", "110621" ], + "210562" : [ "09:22", "350000", "110622" ], + "210563" : [ "09:23", "350000", "110623" ], + "210564" : [ "09:24", "350000", "110624" ], + "210565" : [ "09:25", "350000", "110625" ], + "210566" : [ "09:26", "350000", "110626" ], + "210567" : [ "09:27", "350000", "110627" ], + "210568" : [ "09:28", "350000", "110628" ], + "210569" : [ "09:29", "350000", "110629" ], + "210570" : [ "09:30", "350000", "110630" ], + "210571" : [ "09:31", "350000", "110631" ], + "210572" : [ "09:32", "350000", "110632" ], + "210573" : [ "09:33", "350000", "110633" ], + "210574" : [ "09:34", "350000", "110634" ], + "210575" : [ "09:35", "350000", "110635" ], + "210576" : [ "09:36", "350000", "110636" ], + "210577" : [ "09:37", "350000", "110637" ], + "210578" : [ "09:38", "350000", "110638" ], + "210579" : [ "09:39", "350000", "110639" ], + "210580" : [ "09:40", "350000", "110640" ], + "210581" : [ "09:41", "350000", "110641" ], + "210582" : [ "09:42", "350000", "110642" ], + "210583" : [ "09:43", "350000", "110643" ], + "210584" : [ "09:44", "350000", "110644" ], + "210585" : [ "09:45", "350000", "110645" ], + "210586" : [ "09:46", "350000", "110646" ], + "210587" : [ "09:47", "350000", "110647" ], + "210588" : [ "09:48", "350000", "110648" ], + "210589" : [ "09:49", "350000", "110649" ], + "210590" : [ "09:50", "350000", "110650" ], + "210591" : [ "09:51", "350000", "110651" ], + "210592" : [ "09:52", "350000", "110652" ], + "210593" : [ "09:53", "350000", "110653" ], + "210594" : [ "09:54", "350000", "110654" ], + "210595" : [ "09:55", "350000", "110655" ], + "210596" : [ "09:56", "350000", "110656" ], + "210597" : [ "09:57", "350000", "110657" ], + "210598" : [ "09:58", "350000", "110658" ], + "210599" : [ "09:59", "350000", "110659" ], + "210600" : [ "10:00", "350000", "110660" ], + "210601" : [ "10:01", "350000", "110661" ], + "210602" : [ "10:02", "350000", "110662" ], + "210603" : [ "10:03", "350000", "110663" ], + "210604" : [ "10:04", "350000", "110664" ], + "210605" : [ "10:05", "350000", "110665" ], + "210606" : [ "10:06", "350000", "110666" ], + "210607" : [ "10:07", "350000", "110667" ], + "210608" : [ "10:08", "350000", "110668" ], + "210609" : [ "10:09", "350000", "110669" ], + "210610" : [ "10:10", "350000", "110670" ], + "210611" : [ "10:11", "350000", "110671" ], + "210612" : [ "10:12", "350000", "110672" ], + "210613" : [ "10:13", "350000", "110673" ], + "210614" : [ "10:14", "350000", "110674" ], + "210615" : [ "10:15", "350000", "110675" ], + "210616" : [ "10:16", "350000", "110676" ], + "210617" : [ "10:17", "350000", "110677" ], + "210618" : [ "10:18", "350000", "110678" ], + "210619" : [ "10:19", "350000", "110679" ], + "210620" : [ "10:20", "350000", "110680" ], + "210621" : [ "10:21", "350000", "110681" ], + "210622" : [ "10:22", "350000", "110682" ], + "210623" : [ "10:23", "350000", "110683" ], + "210624" : [ "10:24", "350000", "110684" ], + "210625" : [ "10:25", "350000", "110685" ], + "210626" : [ "10:26", "350000", "110686" ], + "210627" : [ "10:27", "350000", "110687" ], + "210628" : [ "10:28", "350000", "110688" ], + "210629" : [ "10:29", "350000", "110689" ], + "210630" : [ "10:30", "350000", "110690" ], + "210631" : [ "10:31", "350000", "110691" ], + "210632" : [ "10:32", "350000", "110692" ], + "210633" : [ "10:33", "350000", "110693" ], + "210634" : [ "10:34", "350000", "110694" ], + "210635" : [ "10:35", "350000", "110695" ], + "210636" : [ "10:36", "350000", "110696" ], + "210637" : [ "10:37", "350000", "110697" ], + "210638" : [ "10:38", "350000", "110698" ], + "210639" : [ "10:39", "350000", "110699" ], + "210640" : [ "10:40", "350000", "110700" ], + "210641" : [ "10:41", "350000", "110701" ], + "210642" : [ "10:42", "350000", "110702" ], + "210643" : [ "10:43", "350000", "110703" ], + "210644" : [ "10:44", "350000", "110704" ], + "210645" : [ "10:45", "350000", "110705" ], + "210646" : [ "10:46", "350000", "110706" ], + "210647" : [ "10:47", "350000", "110707" ], + "210648" : [ "10:48", "350000", "110708" ], + "210649" : [ "10:49", "350000", "110709" ], + "210650" : [ "10:50", "350000", "110710" ], + "210651" : [ "10:51", "350000", "110711" ], + "210652" : [ "10:52", "350000", "110712" ], + "210653" : [ "10:53", "350000", "110713" ], + "210654" : [ "10:54", "350000", "110714" ], + "210655" : [ "10:55", "350000", "110715" ], + "210656" : [ "10:56", "350000", "110716" ], + "210657" : [ "10:57", "350000", "110717" ], + "210658" : [ "10:58", "350000", "110718" ], + "210659" : [ "10:59", "350000", "110719" ], + "210660" : [ "11:00", "350000", "110720" ], + "210661" : [ "11:01", "350000", "110721" ], + "210662" : [ "11:02", "350000", "110722" ], + "210663" : [ "11:03", "350000", "110723" ], + "210664" : [ "11:04", "350000", "110724" ], + "210665" : [ "11:05", "350000", "110725" ], + "210666" : [ "11:06", "350000", "110726" ], + "210667" : [ "11:07", "350000", "110727" ], + "210668" : [ "11:08", "350000", "110728" ], + "210669" : [ "11:09", "350000", "110729" ], + "210670" : [ "11:10", "350000", "110730" ], + "210671" : [ "11:11", "350000", "110731" ], + "210672" : [ "11:12", "350000", "110732" ], + "210673" : [ "11:13", "350000", "110733" ], + "210674" : [ "11:14", "350000", "110734" ], + "210675" : [ "11:15", "350000", "110735" ], + "210676" : [ "11:16", "350000", "110736" ], + "210677" : [ "11:17", "350000", "110737" ], + "210678" : [ "11:18", "350000", "110738" ], + "210679" : [ "11:19", "350000", "110739" ], + "210680" : [ "11:20", "350000", "110740" ], + "210681" : [ "11:21", "350000", "110741" ], + "210682" : [ "11:22", "350000", "110742" ], + "210683" : [ "11:23", "350000", "110743" ], + "210684" : [ "11:24", "350000", "110744" ], + "210685" : [ "11:25", "350000", "110745" ], + "210686" : [ "11:26", "350000", "110746" ], + "210687" : [ "11:27", "350000", "110747" ], + "210688" : [ "11:28", "350000", "110748" ], + "210689" : [ "11:29", "350000", "110749" ], + "210690" : [ "11:30", "350000", "110750" ], + "210691" : [ "11:31", "350000", "110751" ], + "210692" : [ "11:32", "350000", "110752" ], + "210693" : [ "11:33", "350000", "110753" ], + "210694" : [ "11:34", "350000", "110754" ], + "210695" : [ "11:35", "350000", "110755" ], + "210696" : [ "11:36", "350000", "110756" ], + "210697" : [ "11:37", "350000", "110757" ], + "210698" : [ "11:38", "350000", "110758" ], + "210699" : [ "11:39", "350000", "110759" ], + "210700" : [ "11:40", "350000", "110760" ], + "210701" : [ "11:41", "350000", "110761" ], + "210702" : [ "11:42", "350000", "110762" ], + "210703" : [ "11:43", "350000", "110763" ], + "210704" : [ "11:44", "350000", "110764" ], + "210705" : [ "11:45", "350000", "110765" ], + "210706" : [ "11:46", "350000", "110766" ], + "210707" : [ "11:47", "350000", "110767" ], + "210708" : [ "11:48", "350000", "110768" ], + "210709" : [ "11:49", "350000", "110769" ], + "210710" : [ "11:50", "350000", "110770" ], + "210711" : [ "11:51", "350000", "110771" ], + "210712" : [ "11:52", "350000", "110772" ], + "210713" : [ "11:53", "350000", "110773" ], + "210714" : [ "11:54", "350000", "110774" ], + "210715" : [ "11:55", "350000", "110775" ], + "210716" : [ "11:56", "350000", "110776" ], + "210717" : [ "11:57", "350000", "110777" ], + "210718" : [ "11:58", "350000", "110778" ], + "210719" : [ "11:59", "350000", "110779" ], + "210720" : [ "12:00", "350000", "110780" ], + "210721" : [ "12:01", "350000", "110781" ], + "210722" : [ "12:02", "350000", "110782" ], + "210723" : [ "12:03", "350000", "110783" ], + "210724" : [ "12:04", "350000", "110784" ], + "210725" : [ "12:05", "350000", "110785" ], + "210726" : [ "12:06", "350000", "110786" ], + "210727" : [ "12:07", "350000", "110787" ], + "210728" : [ "12:08", "350000", "110788" ], + "210729" : [ "12:09", "350000", "110789" ], + "210730" : [ "12:10", "350000", "110790" ], + "210731" : [ "12:11", "350000", "110791" ], + "210732" : [ "12:12", "350000", "110792" ], + "210733" : [ "12:13", "350000", "110793" ], + "210734" : [ "12:14", "350000", "110794" ], + "210735" : [ "12:15", "350000", "110795" ], + "210736" : [ "12:16", "350000", "110796" ], + "210737" : [ "12:17", "350000", "110797" ], + "210738" : [ "12:18", "350000", "110798" ], + "210739" : [ "12:19", "350000", "110799" ], + "210740" : [ "12:20", "350000", "110800" ], + "210741" : [ "12:21", "350000", "110801" ], + "210742" : [ "12:22", "350000", "110802" ], + "210743" : [ "12:23", "350000", "110803" ], + "210744" : [ "12:24", "350000", "110804" ], + "210745" : [ "12:25", "350000", "110805" ], + "210746" : [ "12:26", "350000", "110806" ], + "210747" : [ "12:27", "350000", "110807" ], + "210748" : [ "12:28", "350000", "110808" ], + "210749" : [ "12:29", "350000", "110809" ], + "210750" : [ "12:30", "350000", "110810" ], + "210751" : [ "12:31", "350000", "110811" ], + "210752" : [ "12:32", "350000", "110812" ], + "210753" : [ "12:33", "350000", "110813" ], + "210754" : [ "12:34", "350000", "110814" ], + "210755" : [ "12:35", "350000", "110815" ], + "210756" : [ "12:36", "350000", "110816" ], + "210757" : [ "12:37", "350000", "110817" ], + "210758" : [ "12:38", "350000", "110818" ], + "210759" : [ "12:39", "350000", "110819" ], + "210760" : [ "12:40", "350000", "110820" ], + "210761" : [ "12:41", "350000", "110821" ], + "210762" : [ "12:42", "350000", "110822" ], + "210763" : [ "12:43", "350000", "110823" ], + "210764" : [ "12:44", "350000", "110824" ], + "210765" : [ "12:45", "350000", "110825" ], + "210766" : [ "12:46", "350000", "110826" ], + "210767" : [ "12:47", "350000", "110827" ], + "210768" : [ "12:48", "350000", "110828" ], + "210769" : [ "12:49", "350000", "110829" ], + "210770" : [ "12:50", "350000", "110830" ], + "210771" : [ "12:51", "350000", "110831" ], + "210772" : [ "12:52", "350000", "110832" ], + "210773" : [ "12:53", "350000", "110833" ], + "210774" : [ "12:54", "350000", "110834" ], + "210775" : [ "12:55", "350000", "110835" ], + "210776" : [ "12:56", "350000", "110836" ], + "210777" : [ "12:57", "350000", "110837" ], + "210778" : [ "12:58", "350000", "110838" ], + "210779" : [ "12:59", "350000", "110839" ], + "210780" : [ "13:00", "350000", "110840" ], + "210781" : [ "13:01", "350000", "110841" ], + "210782" : [ "13:02", "350000", "110842" ], + "210783" : [ "13:03", "350000", "110843" ], + "210784" : [ "13:04", "350000", "110844" ], + "210785" : [ "13:05", "350000", "110845" ], + "210786" : [ "13:06", "350000", "110846" ], + "210787" : [ "13:07", "350000", "110847" ], + "210788" : [ "13:08", "350000", "110848" ], + "210789" : [ "13:09", "350000", "110849" ], + "210790" : [ "13:10", "350000", "110850" ], + "210791" : [ "13:11", "350000", "110851" ], + "210792" : [ "13:12", "350000", "110852" ], + "210793" : [ "13:13", "350000", "110853" ], + "210794" : [ "13:14", "350000", "110854" ], + "210795" : [ "13:15", "350000", "110855" ], + "210796" : [ "13:16", "350000", "110856" ], + "210797" : [ "13:17", "350000", "110857" ], + "210798" : [ "13:18", "350000", "110858" ], + "210799" : [ "13:19", "350000", "110859" ], + "210800" : [ "13:20", "350000", "110860" ], + "210801" : [ "13:21", "350000", "110861" ], + "210802" : [ "13:22", "350000", "110862" ], + "210803" : [ "13:23", "350000", "110863" ], + "210804" : [ "13:24", "350000", "110864" ], + "210805" : [ "13:25", "350000", "110865" ], + "210806" : [ "13:26", "350000", "110866" ], + "210807" : [ "13:27", "350000", "110867" ], + "210808" : [ "13:28", "350000", "110868" ], + "210809" : [ "13:29", "350000", "110869" ], + "210810" : [ "13:30", "350000", "110870" ], + "210811" : [ "13:31", "350000", "110871" ], + "210812" : [ "13:32", "350000", "110872" ], + "210813" : [ "13:33", "350000", "110873" ], + "210814" : [ "13:34", "350000", "110874" ], + "210815" : [ "13:35", "350000", "110875" ], + "210816" : [ "13:36", "350000", "110876" ], + "210817" : [ "13:37", "350000", "110877" ], + "210818" : [ "13:38", "350000", "110878" ], + "210819" : [ "13:39", "350000", "110879" ], + "210820" : [ "13:40", "350000", "110880" ], + "210821" : [ "13:41", "350000", "110881" ], + "210822" : [ "13:42", "350000", "110882" ], + "210823" : [ "13:43", "350000", "110883" ], + "210824" : [ "13:44", "350000", "110884" ], + "210825" : [ "13:45", "350000", "110885" ], + "210826" : [ "13:46", "350000", "110886" ], + "210827" : [ "13:47", "350000", "110887" ], + "210828" : [ "13:48", "350000", "110888" ], + "210829" : [ "13:49", "350000", "110889" ], + "210830" : [ "13:50", "350000", "110890" ], + "210831" : [ "13:51", "350000", "110891" ], + "210832" : [ "13:52", "350000", "110892" ], + "210833" : [ "13:53", "350000", "110893" ], + "210834" : [ "13:54", "350000", "110894" ], + "210835" : [ "13:55", "350000", "110895" ], + "210836" : [ "13:56", "350000", "110896" ], + "210837" : [ "13:57", "350000", "110897" ], + "210838" : [ "13:58", "350000", "110898" ], + "210839" : [ "13:59", "350000", "110899" ], + "210840" : [ "14:00", "350000", "110900" ], + "210841" : [ "14:01", "350000", "110901" ], + "210842" : [ "14:02", "350000", "110902" ], + "210843" : [ "14:03", "350000", "110903" ], + "210844" : [ "14:04", "350000", "110904" ], + "210845" : [ "14:05", "350000", "110905" ], + "210846" : [ "14:06", "350000", "110906" ], + "210847" : [ "14:07", "350000", "110907" ], + "210848" : [ "14:08", "350000", "110908" ], + "210849" : [ "14:09", "350000", "110909" ], + "210850" : [ "14:10", "350000", "110910" ], + "210851" : [ "14:11", "350000", "110911" ], + "210852" : [ "14:12", "350000", "110912" ], + "210853" : [ "14:13", "350000", "110913" ], + "210854" : [ "14:14", "350000", "110914" ], + "210855" : [ "14:15", "350000", "110915" ], + "210856" : [ "14:16", "350000", "110916" ], + "210857" : [ "14:17", "350000", "110917" ], + "210858" : [ "14:18", "350000", "110918" ], + "210859" : [ "14:19", "350000", "110919" ], + "210860" : [ "14:20", "350000", "110920" ], + "210861" : [ "14:21", "350000", "110921" ], + "210862" : [ "14:22", "350000", "110922" ], + "210863" : [ "14:23", "350000", "110923" ], + "210864" : [ "14:24", "350000", "110924" ], + "210865" : [ "14:25", "350000", "110925" ], + "210866" : [ "14:26", "350000", "110926" ], + "210867" : [ "14:27", "350000", "110927" ], + "210868" : [ "14:28", "350000", "110928" ], + "210869" : [ "14:29", "350000", "110929" ], + "210870" : [ "14:30", "350000", "110930" ], + "210871" : [ "14:31", "350000", "110931" ], + "210872" : [ "14:32", "350000", "110932" ], + "210873" : [ "14:33", "350000", "110933" ], + "210874" : [ "14:34", "350000", "110934" ], + "210875" : [ "14:35", "350000", "110935" ], + "210876" : [ "14:36", "350000", "110936" ], + "210877" : [ "14:37", "350000", "110937" ], + "210878" : [ "14:38", "350000", "110938" ], + "210879" : [ "14:39", "350000", "110939" ], + "210880" : [ "14:40", "350000", "110940" ], + "210881" : [ "14:41", "350000", "110941" ], + "210882" : [ "14:42", "350000", "110942" ], + "210883" : [ "14:43", "350000", "110943" ], + "210884" : [ "14:44", "350000", "110944" ], + "210885" : [ "14:45", "350000", "110945" ], + "210886" : [ "14:46", "350000", "110946" ], + "210887" : [ "14:47", "350000", "110947" ], + "210888" : [ "14:48", "350000", "110948" ], + "210889" : [ "14:49", "350000", "110949" ], + "210890" : [ "14:50", "350000", "110950" ], + "210891" : [ "14:51", "350000", "110951" ], + "210892" : [ "14:52", "350000", "110952" ], + "210893" : [ "14:53", "350000", "110953" ], + "210894" : [ "14:54", "350000", "110954" ], + "210895" : [ "14:55", "350000", "110955" ], + "210896" : [ "14:56", "350000", "110956" ], + "210897" : [ "14:57", "350000", "110957" ], + "210898" : [ "14:58", "350000", "110958" ], + "210899" : [ "14:59", "350000", "110959" ], + "210900" : [ "15:00", "350000", "110960" ], + "210901" : [ "15:01", "350000", "110961" ], + "210902" : [ "15:02", "350000", "110962" ], + "210903" : [ "15:03", "350000", "110963" ], + "210904" : [ "15:04", "350000", "110964" ], + "210905" : [ "15:05", "350000", "110965" ], + "210906" : [ "15:06", "350000", "110966" ], + "210907" : [ "15:07", "350000", "110967" ], + "210908" : [ "15:08", "350000", "110968" ], + "210909" : [ "15:09", "350000", "110969" ], + "210910" : [ "15:10", "350000", "110970" ], + "210911" : [ "15:11", "350000", "110971" ], + "210912" : [ "15:12", "350000", "110972" ], + "210913" : [ "15:13", "350000", "110973" ], + "210914" : [ "15:14", "350000", "110974" ], + "210915" : [ "15:15", "350000", "110975" ], + "210916" : [ "15:16", "350000", "110976" ], + "210917" : [ "15:17", "350000", "110977" ], + "210918" : [ "15:18", "350000", "110978" ], + "210919" : [ "15:19", "350000", "110979" ], + "210920" : [ "15:20", "350000", "110980" ], + "210921" : [ "15:21", "350000", "110981" ], + "210922" : [ "15:22", "350000", "110982" ], + "210923" : [ "15:23", "350000", "110983" ], + "210924" : [ "15:24", "350000", "110984" ], + "210925" : [ "15:25", "350000", "110985" ], + "210926" : [ "15:26", "350000", "110986" ], + "210927" : [ "15:27", "350000", "110987" ], + "210928" : [ "15:28", "350000", "110988" ], + "210929" : [ "15:29", "350000", "110989" ], + "210930" : [ "15:30", "350000", "110990" ], + "210931" : [ "15:31", "350000", "110991" ], + "210932" : [ "15:32", "350000", "110992" ], + "210933" : [ "15:33", "350000", "110993" ], + "210934" : [ "15:34", "350000", "110994" ], + "210935" : [ "15:35", "350000", "110995" ], + "210936" : [ "15:36", "350000", "110996" ], + "210937" : [ "15:37", "350000", "110997" ], + "210938" : [ "15:38", "350000", "110998" ], + "210939" : [ "15:39", "350000", "110999" ], + "210940" : [ "15:40", "350000", "111000" ], + "210941" : [ "15:41", "350000", "111001" ], + "210942" : [ "15:42", "350000", "111002" ], + "210943" : [ "15:43", "350000", "111003" ], + "210944" : [ "15:44", "350000", "111004" ], + "210945" : [ "15:45", "350000", "111005" ], + "210946" : [ "15:46", "350000", "111006" ], + "210947" : [ "15:47", "350000", "111007" ], + "210948" : [ "15:48", "350000", "111008" ], + "210949" : [ "15:49", "350000", "111009" ], + "210950" : [ "15:50", "350000", "111010" ], + "210951" : [ "15:51", "350000", "111011" ], + "210952" : [ "15:52", "350000", "111012" ], + "210953" : [ "15:53", "350000", "111013" ], + "210954" : [ "15:54", "350000", "111014" ], + "210955" : [ "15:55", "350000", "111015" ], + "210956" : [ "15:56", "350000", "111016" ], + "210957" : [ "15:57", "350000", "111017" ], + "210958" : [ "15:58", "350000", "111018" ], + "210959" : [ "15:59", "350000", "111019" ], + "210960" : [ "16:00", "350000", "111020" ], + "210961" : [ "16:01", "350000", "111021" ], + "210962" : [ "16:02", "350000", "111022" ], + "210963" : [ "16:03", "350000", "111023" ], + "210964" : [ "16:04", "350000", "111024" ], + "210965" : [ "16:05", "350000", "111025" ], + "210966" : [ "16:06", "350000", "111026" ], + "210967" : [ "16:07", "350000", "111027" ], + "210968" : [ "16:08", "350000", "111028" ], + "210969" : [ "16:09", "350000", "111029" ], + "210970" : [ "16:10", "350000", "111030" ], + "210971" : [ "16:11", "350000", "111031" ], + "210972" : [ "16:12", "350000", "111032" ], + "210973" : [ "16:13", "350000", "111033" ], + "210974" : [ "16:14", "350000", "111034" ], + "210975" : [ "16:15", "350000", "111035" ], + "210976" : [ "16:16", "350000", "111036" ], + "210977" : [ "16:17", "350000", "111037" ], + "210978" : [ "16:18", "350000", "111038" ], + "210979" : [ "16:19", "350000", "111039" ], + "210980" : [ "16:20", "350000", "111040" ], + "210981" : [ "16:21", "350000", "111041" ], + "210982" : [ "16:22", "350000", "111042" ], + "210983" : [ "16:23", "350000", "111043" ], + "210984" : [ "16:24", "350000", "111044" ], + "210985" : [ "16:25", "350000", "111045" ], + "210986" : [ "16:26", "350000", "111046" ], + "210987" : [ "16:27", "350000", "111047" ], + "210988" : [ "16:28", "350000", "111048" ], + "210989" : [ "16:29", "350000", "111049" ], + "210990" : [ "16:30", "350000", "111050" ], + "210991" : [ "16:31", "350000", "111051" ], + "210992" : [ "16:32", "350000", "111052" ], + "210993" : [ "16:33", "350000", "111053" ], + "210994" : [ "16:34", "350000", "111054" ], + "210995" : [ "16:35", "350000", "111055" ], + "210996" : [ "16:36", "350000", "111056" ], + "210997" : [ "16:37", "350000", "111057" ], + "210998" : [ "16:38", "350000", "111058" ], + "210999" : [ "16:39", "350000", "111059" ], + "211000" : [ "16:40", "350000", "111060" ], + "211001" : [ "16:41", "350000", "111061" ], + "211002" : [ "16:42", "350000", "111062" ], + "211003" : [ "16:43", "350000", "111063" ], + "211004" : [ "16:44", "350000", "111064" ], + "211005" : [ "16:45", "350000", "111065" ], + "211006" : [ "16:46", "350000", "111066" ], + "211007" : [ "16:47", "350000", "111067" ], + "211008" : [ "16:48", "350000", "111068" ], + "211009" : [ "16:49", "350000", "111069" ], + "211010" : [ "16:50", "350000", "111070" ], + "211011" : [ "16:51", "350000", "111071" ], + "211012" : [ "16:52", "350000", "111072" ], + "211013" : [ "16:53", "350000", "111073" ], + "211014" : [ "16:54", "350000", "111074" ], + "211015" : [ "16:55", "350000", "111075" ], + "211016" : [ "16:56", "350000", "111076" ], + "211017" : [ "16:57", "350000", "111077" ], + "211018" : [ "16:58", "350000", "111078" ], + "211019" : [ "16:59", "350000", "111079" ], + "211020" : [ "17:00", "350000", "111080" ], + "211021" : [ "17:01", "350000", "111081" ], + "211022" : [ "17:02", "350000", "111082" ], + "211023" : [ "17:03", "350000", "111083" ], + "211024" : [ "17:04", "350000", "111084" ], + "211025" : [ "17:05", "350000", "111085" ], + "211026" : [ "17:06", "350000", "111086" ], + "211027" : [ "17:07", "350000", "111087" ], + "211028" : [ "17:08", "350000", "111088" ], + "211029" : [ "17:09", "350000", "111089" ], + "211030" : [ "17:10", "350000", "111090" ], + "211031" : [ "17:11", "350000", "111091" ], + "211032" : [ "17:12", "350000", "111092" ], + "211033" : [ "17:13", "350000", "111093" ], + "211034" : [ "17:14", "350000", "111094" ], + "211035" : [ "17:15", "350000", "111095" ], + "211036" : [ "17:16", "350000", "111096" ], + "211037" : [ "17:17", "350000", "111097" ], + "211038" : [ "17:18", "350000", "111098" ], + "211039" : [ "17:19", "350000", "111099" ], + "211040" : [ "17:20", "350000", "111100" ], + "211041" : [ "17:21", "350000", "111101" ], + "211042" : [ "17:22", "350000", "111102" ], + "211043" : [ "17:23", "350000", "111103" ], + "211044" : [ "17:24", "350000", "111104" ], + "211045" : [ "17:25", "350000", "111105" ], + "211046" : [ "17:26", "350000", "111106" ], + "211047" : [ "17:27", "350000", "111107" ], + "211048" : [ "17:28", "350000", "111108" ], + "211049" : [ "17:29", "350000", "111109" ], + "211050" : [ "17:30", "350000", "111110" ], + "211051" : [ "17:31", "350000", "111111" ], + "211052" : [ "17:32", "350000", "111112" ], + "211053" : [ "17:33", "350000", "111113" ], + "211054" : [ "17:34", "350000", "111114" ], + "211055" : [ "17:35", "350000", "111115" ], + "211056" : [ "17:36", "350000", "111116" ], + "211057" : [ "17:37", "350000", "111117" ], + "211058" : [ "17:38", "350000", "111118" ], + "211059" : [ "17:39", "350000", "111119" ], + "211060" : [ "17:40", "350000", "111120" ], + "211061" : [ "17:41", "350000", "111121" ], + "211062" : [ "17:42", "350000", "111122" ], + "211063" : [ "17:43", "350000", "111123" ], + "211064" : [ "17:44", "350000", "111124" ], + "211065" : [ "17:45", "350000", "111125" ], + "211066" : [ "17:46", "350000", "111126" ], + "211067" : [ "17:47", "350000", "111127" ], + "211068" : [ "17:48", "350000", "111128" ], + "211069" : [ "17:49", "350000", "111129" ], + "211070" : [ "17:50", "350000", "111130" ], + "211071" : [ "17:51", "350000", "111131" ], + "211072" : [ "17:52", "350000", "111132" ], + "211073" : [ "17:53", "350000", "111133" ], + "211074" : [ "17:54", "350000", "111134" ], + "211075" : [ "17:55", "350000", "111135" ], + "211076" : [ "17:56", "350000", "111136" ], + "211077" : [ "17:57", "350000", "111137" ], + "211078" : [ "17:58", "350000", "111138" ], + "211079" : [ "17:59", "350000", "111139" ], + "211080" : [ "18:00", "350000", "111140" ], + "211081" : [ "18:01", "350000", "111141" ], + "211082" : [ "18:02", "350000", "111142" ], + "211083" : [ "18:03", "350000", "111143" ], + "211084" : [ "18:04", "350000", "111144" ], + "211085" : [ "18:05", "350000", "111145" ], + "211086" : [ "18:06", "350000", "111146" ], + "211087" : [ "18:07", "350000", "111147" ], + "211088" : [ "18:08", "350000", "111148" ], + "211089" : [ "18:09", "350000", "111149" ], + "211090" : [ "18:10", "350000", "111150" ], + "211091" : [ "18:11", "350000", "111151" ], + "211092" : [ "18:12", "350000", "111152" ], + "211093" : [ "18:13", "350000", "111153" ], + "211094" : [ "18:14", "350000", "111154" ], + "211095" : [ "18:15", "350000", "111155" ], + "211096" : [ "18:16", "350000", "111156" ], + "211097" : [ "18:17", "350000", "111157" ], + "211098" : [ "18:18", "350000", "111158" ], + "211099" : [ "18:19", "350000", "111159" ], + "211100" : [ "18:20", "350000", "111160" ], + "211101" : [ "18:21", "350000", "111161" ], + "211102" : [ "18:22", "350000", "111162" ], + "211103" : [ "18:23", "350000", "111163" ], + "211104" : [ "18:24", "350000", "111164" ], + "211105" : [ "18:25", "350000", "111165" ], + "211106" : [ "18:26", "350000", "111166" ], + "211107" : [ "18:27", "350000", "111167" ], + "211108" : [ "18:28", "350000", "111168" ], + "211109" : [ "18:29", "350000", "111169" ], + "211110" : [ "18:30", "350000", "111170" ], + "211111" : [ "18:31", "350000", "111171" ], + "211112" : [ "18:32", "350000", "111172" ], + "211113" : [ "18:33", "350000", "111173" ], + "211114" : [ "18:34", "350000", "111174" ], + "211115" : [ "18:35", "350000", "111175" ], + "211116" : [ "18:36", "350000", "111176" ], + "211117" : [ "18:37", "350000", "111177" ], + "211118" : [ "18:38", "350000", "111178" ], + "211119" : [ "18:39", "350000", "111179" ], + "211120" : [ "18:40", "350000", "111180" ], + "211121" : [ "18:41", "350000", "111181" ], + "211122" : [ "18:42", "350000", "111182" ], + "211123" : [ "18:43", "350000", "111183" ], + "211124" : [ "18:44", "350000", "111184" ], + "211125" : [ "18:45", "350000", "111185" ], + "211126" : [ "18:46", "350000", "111186" ], + "211127" : [ "18:47", "350000", "111187" ], + "211128" : [ "18:48", "350000", "111188" ], + "211129" : [ "18:49", "350000", "111189" ], + "211130" : [ "18:50", "350000", "111190" ], + "211131" : [ "18:51", "350000", "111191" ], + "211132" : [ "18:52", "350000", "111192" ], + "211133" : [ "18:53", "350000", "111193" ], + "211134" : [ "18:54", "350000", "111194" ], + "211135" : [ "18:55", "350000", "111195" ], + "211136" : [ "18:56", "350000", "111196" ], + "211137" : [ "18:57", "350000", "111197" ], + "211138" : [ "18:58", "350000", "111198" ], + "211139" : [ "18:59", "350000", "111199" ], + "211140" : [ "19:00", "350000", "111200" ], + "211141" : [ "19:01", "350000", "111200" ], + "211142" : [ "19:02", "350000", "111200" ], + "211143" : [ "19:03", "350000", "111200" ], + "211144" : [ "19:04", "350000", "111200" ], + "211145" : [ "19:05", "350000", "111200" ], + "211146" : [ "19:06", "350000", "111200" ], + "211147" : [ "19:07", "350000", "111200" ], + "211148" : [ "19:08", "350000", "111200" ], + "211149" : [ "19:09", "350000", "111200" ], + "211150" : [ "19:10", "350000", "111200" ], + "211151" : [ "19:11", "350000", "111200" ], + "211152" : [ "19:12", "350000", "111200" ], + "211153" : [ "19:13", "350000", "111200" ], + "211154" : [ "19:14", "350000", "111200" ], + "211155" : [ "19:15", "350000", "111200" ], + "211156" : [ "19:16", "350000", "111200" ], + "211157" : [ "19:17", "350000", "111200" ], + "211158" : [ "19:18", "350000", "111200" ], + "211159" : [ "19:19", "350000", "111200" ], + "211160" : [ "19:20", "350000", "111200" ], + "211161" : [ "19:21", "350000", "111200" ], + "211162" : [ "19:22", "350000", "111200" ], + "211163" : [ "19:23", "350000", "111200" ], + "211164" : [ "19:24", "350000", "111200" ], + "211165" : [ "19:25", "350000", "111200" ], + "211166" : [ "19:26", "350000", "111200" ], + "211167" : [ "19:27", "350000", "111200" ], + "211168" : [ "19:28", "350000", "111200" ], + "211169" : [ "19:29", "350000", "111200" ], + "211170" : [ "19:30", "350000", "111200" ], + "211171" : [ "19:31", "350000", "111200" ], + "211172" : [ "19:32", "350000", "111200" ], + "211173" : [ "19:33", "350000", "111200" ], + "211174" : [ "19:34", "350000", "111200" ], + "211175" : [ "19:35", "350000", "111200" ], + "211176" : [ "19:36", "350000", "111200" ], + "211177" : [ "19:37", "350000", "111200" ], + "211178" : [ "19:38", "350000", "111200" ], + "211179" : [ "19:39", "350000", "111200" ], + "211180" : [ "19:40", "350000", "111200" ], + "211181" : [ "19:41", "350000", "111200" ], + "211182" : [ "19:42", "350000", "111200" ], + "211183" : [ "19:43", "350000", "111200" ], + "211184" : [ "19:44", "350000", "111200" ], + "211185" : [ "19:45", "350000", "111200" ], + "211186" : [ "19:46", "350000", "111200" ], + "211187" : [ "19:47", "350000", "111200" ], + "211188" : [ "19:48", "350000", "111200" ], + "211189" : [ "19:49", "350000", "111200" ], + "211190" : [ "19:50", "350000", "111200" ], + "211191" : [ "19:51", "350000", "111200" ], + "211192" : [ "19:52", "350000", "111200" ], + "211193" : [ "19:53", "350000", "111200" ], + "211194" : [ "19:54", "350000", "111200" ], + "211195" : [ "19:55", "350000", "111200" ], + "211196" : [ "19:56", "350000", "111200" ], + "211197" : [ "19:57", "350000", "111200" ], + "211198" : [ "19:58", "350000", "111200" ], + "211199" : [ "19:59", "350000", "111200" ], + "211200" : [ "20:00", "800000", "120420" ], + "211201" : [ "20:01", "800000", "120420" ], + "211202" : [ "20:02", "800000", "120420" ], + "211203" : [ "20:03", "800000", "120420" ], + "211204" : [ "20:04", "800000", "120420" ], + "211205" : [ "20:05", "800000", "120420" ], + "211206" : [ "20:06", "800000", "120420" ], + "211207" : [ "20:07", "800000", "120420" ], + "211208" : [ "20:08", "800000", "120420" ], + "211209" : [ "20:09", "800000", "120420" ], + "211210" : [ "20:10", "800000", "120420" ], + "211211" : [ "20:11", "800000", "120420" ], + "211212" : [ "20:12", "800000", "120420" ], + "211213" : [ "20:13", "800000", "120420" ], + "211214" : [ "20:14", "800000", "120420" ], + "211215" : [ "20:15", "800000", "120420" ], + "211216" : [ "20:16", "800000", "120420" ], + "211217" : [ "20:17", "800000", "120420" ], + "211218" : [ "20:18", "800000", "120420" ], + "211219" : [ "20:19", "800000", "120420" ], + "211220" : [ "20:20", "800000", "120420" ], + "211221" : [ "20:21", "800000", "120420" ], + "211222" : [ "20:22", "800000", "120420" ], + "211223" : [ "20:23", "800000", "120420" ], + "211224" : [ "20:24", "800000", "120420" ], + "211225" : [ "20:25", "800000", "120420" ], + "211226" : [ "20:26", "800000", "120420" ], + "211227" : [ "20:27", "800000", "120420" ], + "211228" : [ "20:28", "800000", "120420" ], + "211229" : [ "20:29", "800000", "120420" ], + "211230" : [ "20:30", "800000", "120420" ], + "211231" : [ "20:31", "800000", "120420" ], + "211232" : [ "20:32", "800000", "120420" ], + "211233" : [ "20:33", "800000", "120420" ], + "211234" : [ "20:34", "800000", "120420" ], + "211235" : [ "20:35", "800000", "120420" ], + "211236" : [ "20:36", "800000", "120420" ], + "211237" : [ "20:37", "800000", "120420" ], + "211238" : [ "20:38", "800000", "120420" ], + "211239" : [ "20:39", "800000", "120420" ], + "211240" : [ "20:40", "800000", "120420" ], + "211241" : [ "20:41", "800000", "120420" ], + "211242" : [ "20:42", "800000", "120420" ], + "211243" : [ "20:43", "800000", "120420" ], + "211244" : [ "20:44", "800000", "120420" ], + "211245" : [ "20:45", "800000", "120420" ], + "211246" : [ "20:46", "800000", "120420" ], + "211247" : [ "20:47", "800000", "120420" ], + "211248" : [ "20:48", "800000", "120420" ], + "211249" : [ "20:49", "800000", "120420" ], + "211250" : [ "20:50", "800000", "120420" ], + "211251" : [ "20:51", "800000", "120420" ], + "211252" : [ "20:52", "800000", "120420" ], + "211253" : [ "20:53", "800000", "120420" ], + "211254" : [ "20:54", "800000", "120420" ], + "211255" : [ "20:55", "800000", "120420" ], + "211256" : [ "20:56", "800000", "120420" ], + "211257" : [ "20:57", "800000", "120420" ], + "211258" : [ "20:58", "800000", "120420" ], + "211259" : [ "20:59", "800000", "120420" ], + "211260" : [ "21:00", "800000", "120420" ], + "211261" : [ "21:01", "800000", "120420" ], + "211262" : [ "21:02", "800000", "120420" ], + "211263" : [ "21:03", "800000", "120420" ], + "211264" : [ "21:04", "800000", "120420" ], + "211265" : [ "21:05", "800000", "120420" ], + "211266" : [ "21:06", "800000", "120420" ], + "211267" : [ "21:07", "800000", "120420" ], + "211268" : [ "21:08", "800000", "120420" ], + "211269" : [ "21:09", "800000", "120420" ], + "211270" : [ "21:10", "800000", "120420" ], + "211271" : [ "21:11", "800000", "120420" ], + "211272" : [ "21:12", "800000", "120420" ], + "211273" : [ "21:13", "800000", "120420" ], + "211274" : [ "21:14", "800000", "120420" ], + "211275" : [ "21:15", "800000", "120420" ], + "211276" : [ "21:16", "800000", "120420" ], + "211277" : [ "21:17", "800000", "120420" ], + "211278" : [ "21:18", "800000", "120420" ], + "211279" : [ "21:19", "800000", "120420" ], + "211280" : [ "21:20", "800000", "120420" ], + "211281" : [ "21:21", "800000", "120420" ], + "211282" : [ "21:22", "800000", "120420" ], + "211283" : [ "21:23", "800000", "120420" ], + "211284" : [ "21:24", "800000", "120420" ], + "211285" : [ "21:25", "800000", "120420" ], + "211286" : [ "21:26", "800000", "120420" ], + "211287" : [ "21:27", "800000", "120420" ], + "211288" : [ "21:28", "800000", "120420" ], + "211289" : [ "21:29", "800000", "120420" ], + "211290" : [ "21:30", "800000", "120420" ], + "211291" : [ "21:31", "800000", "120420" ], + "211292" : [ "21:32", "800000", "120420" ], + "211293" : [ "21:33", "800000", "120420" ], + "211294" : [ "21:34", "800000", "120420" ], + "211295" : [ "21:35", "800000", "120420" ], + "211296" : [ "21:36", "800000", "120420" ], + "211297" : [ "21:37", "800000", "120420" ], + "211298" : [ "21:38", "800000", "120420" ], + "211299" : [ "21:39", "800000", "120420" ], + "211300" : [ "21:40", "800000", "120420" ], + "211301" : [ "21:41", "800000", "120420" ], + "211302" : [ "21:42", "800000", "120420" ], + "211303" : [ "21:43", "800000", "120420" ], + "211304" : [ "21:44", "800000", "120420" ], + "211305" : [ "21:45", "800000", "120420" ], + "211306" : [ "21:46", "800000", "120420" ], + "211307" : [ "21:47", "800000", "120420" ], + "211308" : [ "21:48", "800000", "120420" ], + "211309" : [ "21:49", "800000", "120420" ], + "211310" : [ "21:50", "800000", "120420" ], + "211311" : [ "21:51", "800000", "120420" ], + "211312" : [ "21:52", "800000", "120420" ], + "211313" : [ "21:53", "800000", "120420" ], + "211314" : [ "21:54", "800000", "120420" ], + "211315" : [ "21:55", "800000", "120420" ], + "211316" : [ "21:56", "800000", "120420" ], + "211317" : [ "21:57", "800000", "120420" ], + "211318" : [ "21:58", "800000", "120420" ], + "211319" : [ "21:59", "800000", "120420" ], + "211320" : [ "22:00", "800000", "120420" ], + "211321" : [ "22:01", "800000", "120420" ], + "211322" : [ "22:02", "800000", "120420" ], + "211323" : [ "22:03", "800000", "120420" ], + "211324" : [ "22:04", "800000", "120420" ], + "211325" : [ "22:05", "800000", "120420" ], + "211326" : [ "22:06", "800000", "120420" ], + "211327" : [ "22:07", "800000", "120420" ], + "211328" : [ "22:08", "800000", "120420" ], + "211329" : [ "22:09", "800000", "120420" ], + "211330" : [ "22:10", "800000", "120420" ], + "211331" : [ "22:11", "800000", "120420" ], + "211332" : [ "22:12", "800000", "120420" ], + "211333" : [ "22:13", "800000", "120420" ], + "211334" : [ "22:14", "800000", "120420" ], + "211335" : [ "22:15", "800000", "120420" ], + "211336" : [ "22:16", "800000", "120420" ], + "211337" : [ "22:17", "800000", "120420" ], + "211338" : [ "22:18", "800000", "120420" ], + "211339" : [ "22:19", "800000", "120420" ], + "211340" : [ "22:20", "800000", "120420" ], + "211341" : [ "22:21", "800000", "120420" ], + "211342" : [ "22:22", "800000", "120420" ], + "211343" : [ "22:23", "800000", "120420" ], + "211344" : [ "22:24", "800000", "120420" ], + "211345" : [ "22:25", "800000", "120420" ], + "211346" : [ "22:26", "800000", "120420" ], + "211347" : [ "22:27", "800000", "120420" ], + "211348" : [ "22:28", "800000", "120420" ], + "211349" : [ "22:29", "800000", "120420" ], + "211350" : [ "22:30", "800000", "120420" ], + "211351" : [ "22:31", "800000", "120420" ], + "211352" : [ "22:32", "800000", "120420" ], + "211353" : [ "22:33", "800000", "120420" ], + "211354" : [ "22:34", "800000", "120420" ], + "211355" : [ "22:35", "800000", "120420" ], + "211356" : [ "22:36", "800000", "120420" ], + "211357" : [ "22:37", "800000", "120420" ], + "211358" : [ "22:38", "800000", "120420" ], + "211359" : [ "22:39", "800000", "120420" ], + "211360" : [ "22:40", "800000", "120420" ], + "211361" : [ "22:41", "800000", "120420" ], + "211362" : [ "22:42", "800000", "120420" ], + "211363" : [ "22:43", "800000", "120420" ], + "211364" : [ "22:44", "800000", "120420" ], + "211365" : [ "22:45", "800000", "120420" ], + "211366" : [ "22:46", "800000", "120420" ], + "211367" : [ "22:47", "800000", "120420" ], + "211368" : [ "22:48", "800000", "120420" ], + "211369" : [ "22:49", "800000", "120420" ], + "211370" : [ "22:50", "800000", "120420" ], + "211371" : [ "22:51", "800000", "120420" ], + "211372" : [ "22:52", "800000", "120420" ], + "211373" : [ "22:53", "800000", "120420" ], + "211374" : [ "22:54", "800000", "120420" ], + "211375" : [ "22:55", "800000", "120420" ], + "211376" : [ "22:56", "800000", "120420" ], + "211377" : [ "22:57", "800000", "120420" ], + "211378" : [ "22:58", "800000", "120420" ], + "211379" : [ "22:59", "800000", "120420" ], + "211380" : [ "23:00", "800000", "120420" ], + "211381" : [ "23:01", "800000", "120420" ], + "211382" : [ "23:02", "800000", "120420" ], + "211383" : [ "23:03", "800000", "120420" ], + "211384" : [ "23:04", "800000", "120420" ], + "211385" : [ "23:05", "800000", "120420" ], + "211386" : [ "23:06", "800000", "120420" ], + "211387" : [ "23:07", "800000", "120420" ], + "211388" : [ "23:08", "800000", "120420" ], + "211389" : [ "23:09", "800000", "120420" ], + "211390" : [ "23:10", "800000", "120420" ], + "211391" : [ "23:11", "800000", "120420" ], + "211392" : [ "23:12", "800000", "120420" ], + "211393" : [ "23:13", "800000", "120420" ], + "211394" : [ "23:14", "800000", "120420" ], + "211395" : [ "23:15", "800000", "120420" ], + "211396" : [ "23:16", "800000", "120420" ], + "211397" : [ "23:17", "800000", "120420" ], + "211398" : [ "23:18", "800000", "120420" ], + "211399" : [ "23:19", "800000", "120420" ], + "211400" : [ "23:20", "800000", "120420" ], + "211401" : [ "23:21", "800000", "120420" ], + "211402" : [ "23:22", "800000", "120420" ], + "211403" : [ "23:23", "800000", "120420" ], + "211404" : [ "23:24", "800000", "120420" ], + "211405" : [ "23:25", "800000", "120420" ], + "211406" : [ "23:26", "800000", "120420" ], + "211407" : [ "23:27", "800000", "120420" ], + "211408" : [ "23:28", "800000", "120420" ], + "211409" : [ "23:29", "800000", "120420" ], + "211410" : [ "23:30", "800000", "120420" ], + "211411" : [ "23:31", "800000", "120420" ], + "211412" : [ "23:32", "800000", "120420" ], + "211413" : [ "23:33", "800000", "120420" ], + "211414" : [ "23:34", "800000", "120420" ], + "211415" : [ "23:35", "800000", "120420" ], + "211416" : [ "23:36", "800000", "120420" ], + "211417" : [ "23:37", "800000", "120420" ], + "211418" : [ "23:38", "800000", "120420" ], + "211419" : [ "23:39", "800000", "120420" ], + "211420" : [ "23:40", "800000", "120420" ], + "211421" : [ "23:41", "800000", "120420" ], + "211422" : [ "23:42", "800000", "120420" ], + "211423" : [ "23:43", "800000", "120420" ], + "211424" : [ "23:44", "800000", "120420" ], + "211425" : [ "23:45", "800000", "120420" ], + "211426" : [ "23:46", "800000", "120420" ], + "211427" : [ "23:47", "800000", "120420" ], + "211428" : [ "23:48", "800000", "120420" ], + "211429" : [ "23:49", "800000", "120420" ], + "211430" : [ "23:50", "800000", "120420" ], + "211431" : [ "23:51", "800000", "120420" ], + "211432" : [ "23:52", "800000", "120420" ], + "211433" : [ "23:53", "800000", "120420" ], + "211434" : [ "23:54", "800000", "120420" ], + "211435" : [ "23:55", "800000", "120420" ], + "211436" : [ "23:56", "800000", "120420" ], + "211437" : [ "23:57", "800000", "120420" ], + "211438" : [ "23:58", "800000", "120420" ], + "211439" : [ "23:59", "800000", "120420" ] + }, + "Wednesday": { + "220000" : [ "00:00", "800000", "120420" ], + "220001" : [ "00:01", "800000", "120420" ], + "220002" : [ "00:02", "800000", "120420" ], + "220003" : [ "00:03", "800000", "120420" ], + "220004" : [ "00:04", "800000", "120420" ], + "220005" : [ "00:05", "800000", "120420" ], + "220006" : [ "00:06", "800000", "120420" ], + "220007" : [ "00:07", "800000", "120420" ], + "220008" : [ "00:08", "800000", "120420" ], + "220009" : [ "00:09", "800000", "120420" ], + "220010" : [ "00:10", "800000", "120420" ], + "220011" : [ "00:11", "800000", "120420" ], + "220012" : [ "00:12", "800000", "120420" ], + "220013" : [ "00:13", "800000", "120420" ], + "220014" : [ "00:14", "800000", "120420" ], + "220015" : [ "00:15", "800000", "120420" ], + "220016" : [ "00:16", "800000", "120420" ], + "220017" : [ "00:17", "800000", "120420" ], + "220018" : [ "00:18", "800000", "120420" ], + "220019" : [ "00:19", "800000", "120420" ], + "220020" : [ "00:20", "800000", "120420" ], + "220021" : [ "00:21", "800000", "120420" ], + "220022" : [ "00:22", "800000", "120420" ], + "220023" : [ "00:23", "800000", "120420" ], + "220024" : [ "00:24", "800000", "120420" ], + "220025" : [ "00:25", "800000", "120420" ], + "220026" : [ "00:26", "800000", "120420" ], + "220027" : [ "00:27", "800000", "120420" ], + "220028" : [ "00:28", "800000", "120420" ], + "220029" : [ "00:29", "800000", "120420" ], + "220030" : [ "00:30", "800000", "120420" ], + "220031" : [ "00:31", "800000", "120420" ], + "220032" : [ "00:32", "800000", "120420" ], + "220033" : [ "00:33", "800000", "120420" ], + "220034" : [ "00:34", "800000", "120420" ], + "220035" : [ "00:35", "800000", "120420" ], + "220036" : [ "00:36", "800000", "120420" ], + "220037" : [ "00:37", "800000", "120420" ], + "220038" : [ "00:38", "800000", "120420" ], + "220039" : [ "00:39", "800000", "120420" ], + "220040" : [ "00:40", "800000", "120420" ], + "220041" : [ "00:41", "800000", "120420" ], + "220042" : [ "00:42", "800000", "120420" ], + "220043" : [ "00:43", "800000", "120420" ], + "220044" : [ "00:44", "800000", "120420" ], + "220045" : [ "00:45", "800000", "120420" ], + "220046" : [ "00:46", "800000", "120420" ], + "220047" : [ "00:47", "800000", "120420" ], + "220048" : [ "00:48", "800000", "120420" ], + "220049" : [ "00:49", "800000", "120420" ], + "220050" : [ "00:50", "800000", "120420" ], + "220051" : [ "00:51", "800000", "120420" ], + "220052" : [ "00:52", "800000", "120420" ], + "220053" : [ "00:53", "800000", "120420" ], + "220054" : [ "00:54", "800000", "120420" ], + "220055" : [ "00:55", "800000", "120420" ], + "220056" : [ "00:56", "800000", "120420" ], + "220057" : [ "00:57", "800000", "120420" ], + "220058" : [ "00:58", "800000", "120420" ], + "220059" : [ "00:59", "800000", "120420" ], + "220060" : [ "01:00", "800000", "120420" ], + "220061" : [ "01:01", "800000", "120420" ], + "220062" : [ "01:02", "800000", "120420" ], + "220063" : [ "01:03", "800000", "120420" ], + "220064" : [ "01:04", "800000", "120420" ], + "220065" : [ "01:05", "800000", "120420" ], + "220066" : [ "01:06", "800000", "120420" ], + "220067" : [ "01:07", "800000", "120420" ], + "220068" : [ "01:08", "800000", "120420" ], + "220069" : [ "01:09", "800000", "120420" ], + "220070" : [ "01:10", "800000", "120420" ], + "220071" : [ "01:11", "800000", "120420" ], + "220072" : [ "01:12", "800000", "120420" ], + "220073" : [ "01:13", "800000", "120420" ], + "220074" : [ "01:14", "800000", "120420" ], + "220075" : [ "01:15", "800000", "120420" ], + "220076" : [ "01:16", "800000", "120420" ], + "220077" : [ "01:17", "800000", "120420" ], + "220078" : [ "01:18", "800000", "120420" ], + "220079" : [ "01:19", "800000", "120420" ], + "220080" : [ "01:20", "800000", "120420" ], + "220081" : [ "01:21", "800000", "120420" ], + "220082" : [ "01:22", "800000", "120420" ], + "220083" : [ "01:23", "800000", "120420" ], + "220084" : [ "01:24", "800000", "120420" ], + "220085" : [ "01:25", "800000", "120420" ], + "220086" : [ "01:26", "800000", "120420" ], + "220087" : [ "01:27", "800000", "120420" ], + "220088" : [ "01:28", "800000", "120420" ], + "220089" : [ "01:29", "800000", "120420" ], + "220090" : [ "01:30", "800000", "120420" ], + "220091" : [ "01:31", "800000", "120420" ], + "220092" : [ "01:32", "800000", "120420" ], + "220093" : [ "01:33", "800000", "120420" ], + "220094" : [ "01:34", "800000", "120420" ], + "220095" : [ "01:35", "800000", "120420" ], + "220096" : [ "01:36", "800000", "120420" ], + "220097" : [ "01:37", "800000", "120420" ], + "220098" : [ "01:38", "800000", "120420" ], + "220099" : [ "01:39", "800000", "120420" ], + "220100" : [ "01:40", "800000", "120420" ], + "220101" : [ "01:41", "800000", "120420" ], + "220102" : [ "01:42", "800000", "120420" ], + "220103" : [ "01:43", "800000", "120420" ], + "220104" : [ "01:44", "800000", "120420" ], + "220105" : [ "01:45", "800000", "120420" ], + "220106" : [ "01:46", "800000", "120420" ], + "220107" : [ "01:47", "800000", "120420" ], + "220108" : [ "01:48", "800000", "120420" ], + "220109" : [ "01:49", "800000", "120420" ], + "220110" : [ "01:50", "800000", "120420" ], + "220111" : [ "01:51", "800000", "120420" ], + "220112" : [ "01:52", "800000", "120420" ], + "220113" : [ "01:53", "800000", "120420" ], + "220114" : [ "01:54", "800000", "120420" ], + "220115" : [ "01:55", "800000", "120420" ], + "220116" : [ "01:56", "800000", "120420" ], + "220117" : [ "01:57", "800000", "120420" ], + "220118" : [ "01:58", "800000", "120420" ], + "220119" : [ "01:59", "800000", "120420" ], + "220120" : [ "02:00", "800000", "120420" ], + "220121" : [ "02:01", "800000", "120420" ], + "220122" : [ "02:02", "800000", "120420" ], + "220123" : [ "02:03", "800000", "120420" ], + "220124" : [ "02:04", "800000", "120420" ], + "220125" : [ "02:05", "800000", "120420" ], + "220126" : [ "02:06", "800000", "120420" ], + "220127" : [ "02:07", "800000", "120420" ], + "220128" : [ "02:08", "800000", "120420" ], + "220129" : [ "02:09", "800000", "120420" ], + "220130" : [ "02:10", "800000", "120420" ], + "220131" : [ "02:11", "800000", "120420" ], + "220132" : [ "02:12", "800000", "120420" ], + "220133" : [ "02:13", "800000", "120420" ], + "220134" : [ "02:14", "800000", "120420" ], + "220135" : [ "02:15", "800000", "120420" ], + "220136" : [ "02:16", "800000", "120420" ], + "220137" : [ "02:17", "800000", "120420" ], + "220138" : [ "02:18", "800000", "120420" ], + "220139" : [ "02:19", "800000", "120420" ], + "220140" : [ "02:20", "800000", "120420" ], + "220141" : [ "02:21", "800000", "120420" ], + "220142" : [ "02:22", "800000", "120420" ], + "220143" : [ "02:23", "800000", "120420" ], + "220144" : [ "02:24", "800000", "120420" ], + "220145" : [ "02:25", "800000", "120420" ], + "220146" : [ "02:26", "800000", "120420" ], + "220147" : [ "02:27", "800000", "120420" ], + "220148" : [ "02:28", "800000", "120420" ], + "220149" : [ "02:29", "800000", "120420" ], + "220150" : [ "02:30", "800000", "120420" ], + "220151" : [ "02:31", "800000", "120420" ], + "220152" : [ "02:32", "800000", "120420" ], + "220153" : [ "02:33", "800000", "120420" ], + "220154" : [ "02:34", "800000", "120420" ], + "220155" : [ "02:35", "800000", "120420" ], + "220156" : [ "02:36", "800000", "120420" ], + "220157" : [ "02:37", "800000", "120420" ], + "220158" : [ "02:38", "800000", "120420" ], + "220159" : [ "02:39", "800000", "120420" ], + "220160" : [ "02:40", "800000", "120420" ], + "220161" : [ "02:41", "800000", "120420" ], + "220162" : [ "02:42", "800000", "120420" ], + "220163" : [ "02:43", "800000", "120420" ], + "220164" : [ "02:44", "800000", "120420" ], + "220165" : [ "02:45", "800000", "120420" ], + "220166" : [ "02:46", "800000", "120420" ], + "220167" : [ "02:47", "800000", "120420" ], + "220168" : [ "02:48", "800000", "120420" ], + "220169" : [ "02:49", "800000", "120420" ], + "220170" : [ "02:50", "800000", "120420" ], + "220171" : [ "02:51", "800000", "120420" ], + "220172" : [ "02:52", "800000", "120420" ], + "220173" : [ "02:53", "800000", "120420" ], + "220174" : [ "02:54", "800000", "120420" ], + "220175" : [ "02:55", "800000", "120420" ], + "220176" : [ "02:56", "800000", "120420" ], + "220177" : [ "02:57", "800000", "120420" ], + "220178" : [ "02:58", "800000", "120420" ], + "220179" : [ "02:59", "800000", "120420" ], + "220180" : [ "03:00", "800000", "120420" ], + "220181" : [ "03:01", "800000", "120420" ], + "220182" : [ "03:02", "800000", "120420" ], + "220183" : [ "03:03", "800000", "120420" ], + "220184" : [ "03:04", "800000", "120420" ], + "220185" : [ "03:05", "800000", "120420" ], + "220186" : [ "03:06", "800000", "120420" ], + "220187" : [ "03:07", "800000", "120420" ], + "220188" : [ "03:08", "800000", "120420" ], + "220189" : [ "03:09", "800000", "120420" ], + "220190" : [ "03:10", "800000", "120420" ], + "220191" : [ "03:11", "800000", "120420" ], + "220192" : [ "03:12", "800000", "120420" ], + "220193" : [ "03:13", "800000", "120420" ], + "220194" : [ "03:14", "800000", "120420" ], + "220195" : [ "03:15", "800000", "120420" ], + "220196" : [ "03:16", "800000", "120420" ], + "220197" : [ "03:17", "800000", "120420" ], + "220198" : [ "03:18", "800000", "120420" ], + "220199" : [ "03:19", "800000", "120420" ], + "220200" : [ "03:20", "800000", "120420" ], + "220201" : [ "03:21", "800000", "120420" ], + "220202" : [ "03:22", "800000", "120420" ], + "220203" : [ "03:23", "800000", "120420" ], + "220204" : [ "03:24", "800000", "120420" ], + "220205" : [ "03:25", "800000", "120420" ], + "220206" : [ "03:26", "800000", "120420" ], + "220207" : [ "03:27", "800000", "120420" ], + "220208" : [ "03:28", "800000", "120420" ], + "220209" : [ "03:29", "800000", "120420" ], + "220210" : [ "03:30", "800000", "120420" ], + "220211" : [ "03:31", "800000", "120420" ], + "220212" : [ "03:32", "800000", "120420" ], + "220213" : [ "03:33", "800000", "120420" ], + "220214" : [ "03:34", "800000", "120420" ], + "220215" : [ "03:35", "800000", "120420" ], + "220216" : [ "03:36", "800000", "120420" ], + "220217" : [ "03:37", "800000", "120420" ], + "220218" : [ "03:38", "800000", "120420" ], + "220219" : [ "03:39", "800000", "120420" ], + "220220" : [ "03:40", "800000", "120420" ], + "220221" : [ "03:41", "800000", "120420" ], + "220222" : [ "03:42", "800000", "120420" ], + "220223" : [ "03:43", "800000", "120420" ], + "220224" : [ "03:44", "800000", "120420" ], + "220225" : [ "03:45", "800000", "120420" ], + "220226" : [ "03:46", "800000", "120420" ], + "220227" : [ "03:47", "800000", "120420" ], + "220228" : [ "03:48", "800000", "120420" ], + "220229" : [ "03:49", "800000", "120420" ], + "220230" : [ "03:50", "800000", "120420" ], + "220231" : [ "03:51", "800000", "120420" ], + "220232" : [ "03:52", "800000", "120420" ], + "220233" : [ "03:53", "800000", "120420" ], + "220234" : [ "03:54", "800000", "120420" ], + "220235" : [ "03:55", "800000", "120420" ], + "220236" : [ "03:56", "800000", "120420" ], + "220237" : [ "03:57", "800000", "120420" ], + "220238" : [ "03:58", "800000", "120420" ], + "220239" : [ "03:59", "800000", "120420" ], + "220240" : [ "04:00", "800000", "120420" ], + "220241" : [ "04:01", "800000", "120420" ], + "220242" : [ "04:02", "800000", "120420" ], + "220243" : [ "04:03", "800000", "120420" ], + "220244" : [ "04:04", "800000", "120420" ], + "220245" : [ "04:05", "800000", "120420" ], + "220246" : [ "04:06", "800000", "120420" ], + "220247" : [ "04:07", "800000", "120420" ], + "220248" : [ "04:08", "800000", "120420" ], + "220249" : [ "04:09", "800000", "120420" ], + "220250" : [ "04:10", "800000", "120420" ], + "220251" : [ "04:11", "800000", "120420" ], + "220252" : [ "04:12", "800000", "120420" ], + "220253" : [ "04:13", "800000", "120420" ], + "220254" : [ "04:14", "800000", "120420" ], + "220255" : [ "04:15", "800000", "120420" ], + "220256" : [ "04:16", "800000", "120420" ], + "220257" : [ "04:17", "800000", "120420" ], + "220258" : [ "04:18", "800000", "120420" ], + "220259" : [ "04:19", "800000", "120420" ], + "220260" : [ "04:20", "800000", "120420" ], + "220261" : [ "04:21", "800000", "120420" ], + "220262" : [ "04:22", "800000", "120420" ], + "220263" : [ "04:23", "800000", "120420" ], + "220264" : [ "04:24", "800000", "120420" ], + "220265" : [ "04:25", "800000", "120420" ], + "220266" : [ "04:26", "800000", "120420" ], + "220267" : [ "04:27", "800000", "120420" ], + "220268" : [ "04:28", "800000", "120420" ], + "220269" : [ "04:29", "800000", "120420" ], + "220270" : [ "04:30", "800000", "120420" ], + "220271" : [ "04:31", "800000", "120420" ], + "220272" : [ "04:32", "800000", "120420" ], + "220273" : [ "04:33", "800000", "120420" ], + "220274" : [ "04:34", "800000", "120420" ], + "220275" : [ "04:35", "800000", "120420" ], + "220276" : [ "04:36", "800000", "120420" ], + "220277" : [ "04:37", "800000", "120420" ], + "220278" : [ "04:38", "800000", "120420" ], + "220279" : [ "04:39", "800000", "120420" ], + "220280" : [ "04:40", "800000", "120420" ], + "220281" : [ "04:41", "800000", "120420" ], + "220282" : [ "04:42", "800000", "120420" ], + "220283" : [ "04:43", "800000", "120420" ], + "220284" : [ "04:44", "800000", "120420" ], + "220285" : [ "04:45", "800000", "120420" ], + "220286" : [ "04:46", "800000", "120420" ], + "220287" : [ "04:47", "800000", "120420" ], + "220288" : [ "04:48", "800000", "120420" ], + "220289" : [ "04:49", "800000", "120420" ], + "220290" : [ "04:50", "800000", "120420" ], + "220291" : [ "04:51", "800000", "120420" ], + "220292" : [ "04:52", "800000", "120420" ], + "220293" : [ "04:53", "800000", "120420" ], + "220294" : [ "04:54", "800000", "120420" ], + "220295" : [ "04:55", "800000", "120420" ], + "220296" : [ "04:56", "800000", "120420" ], + "220297" : [ "04:57", "800000", "120420" ], + "220298" : [ "04:58", "800000", "120420" ], + "220299" : [ "04:59", "800000", "120420" ], + "220300" : [ "05:00", "800000", "120420" ], + "220301" : [ "05:01", "800000", "120420" ], + "220302" : [ "05:02", "800000", "120420" ], + "220303" : [ "05:03", "800000", "120420" ], + "220304" : [ "05:04", "800000", "120420" ], + "220305" : [ "05:05", "800000", "120420" ], + "220306" : [ "05:06", "800000", "120420" ], + "220307" : [ "05:07", "800000", "120420" ], + "220308" : [ "05:08", "800000", "120420" ], + "220309" : [ "05:09", "800000", "120420" ], + "220310" : [ "05:10", "800000", "120420" ], + "220311" : [ "05:11", "800000", "120420" ], + "220312" : [ "05:12", "800000", "120420" ], + "220313" : [ "05:13", "800000", "120420" ], + "220314" : [ "05:14", "800000", "120420" ], + "220315" : [ "05:15", "800000", "120420" ], + "220316" : [ "05:16", "800000", "120420" ], + "220317" : [ "05:17", "800000", "120420" ], + "220318" : [ "05:18", "800000", "120420" ], + "220319" : [ "05:19", "800000", "120420" ], + "220320" : [ "05:20", "800000", "120420" ], + "220321" : [ "05:21", "800000", "120420" ], + "220322" : [ "05:22", "800000", "120420" ], + "220323" : [ "05:23", "800000", "120420" ], + "220324" : [ "05:24", "800000", "120420" ], + "220325" : [ "05:25", "800000", "120420" ], + "220326" : [ "05:26", "800000", "120420" ], + "220327" : [ "05:27", "800000", "120420" ], + "220328" : [ "05:28", "800000", "120420" ], + "220329" : [ "05:29", "800000", "120420" ], + "220330" : [ "05:30", "800000", "120420" ], + "220331" : [ "05:31", "800000", "120420" ], + "220332" : [ "05:32", "800000", "120420" ], + "220333" : [ "05:33", "800000", "120420" ], + "220334" : [ "05:34", "800000", "120420" ], + "220335" : [ "05:35", "800000", "120420" ], + "220336" : [ "05:36", "800000", "120420" ], + "220337" : [ "05:37", "800000", "120420" ], + "220338" : [ "05:38", "800000", "120420" ], + "220339" : [ "05:39", "800000", "120420" ], + "220340" : [ "05:40", "800000", "120420" ], + "220341" : [ "05:41", "800000", "120420" ], + "220342" : [ "05:42", "800000", "120420" ], + "220343" : [ "05:43", "800000", "120420" ], + "220344" : [ "05:44", "800000", "120420" ], + "220345" : [ "05:45", "800000", "120420" ], + "220346" : [ "05:46", "800000", "120420" ], + "220347" : [ "05:47", "800000", "120420" ], + "220348" : [ "05:48", "800000", "120420" ], + "220349" : [ "05:49", "800000", "120420" ], + "220350" : [ "05:50", "800000", "120420" ], + "220351" : [ "05:51", "800000", "120420" ], + "220352" : [ "05:52", "800000", "120420" ], + "220353" : [ "05:53", "800000", "120420" ], + "220354" : [ "05:54", "800000", "120420" ], + "220355" : [ "05:55", "800000", "120420" ], + "220356" : [ "05:56", "800000", "120420" ], + "220357" : [ "05:57", "800000", "120420" ], + "220358" : [ "05:58", "800000", "120420" ], + "220359" : [ "05:59", "800000", "120420" ], + "220360" : [ "06:00", "800000", "120420" ], + "220361" : [ "06:01", "800000", "120420" ], + "220362" : [ "06:02", "800000", "120420" ], + "220363" : [ "06:03", "800000", "120420" ], + "220364" : [ "06:04", "800000", "120420" ], + "220365" : [ "06:05", "800000", "120420" ], + "220366" : [ "06:06", "800000", "120420" ], + "220367" : [ "06:07", "800000", "120420" ], + "220368" : [ "06:08", "800000", "120420" ], + "220369" : [ "06:09", "800000", "120420" ], + "220370" : [ "06:10", "800000", "120420" ], + "220371" : [ "06:11", "800000", "120420" ], + "220372" : [ "06:12", "800000", "120420" ], + "220373" : [ "06:13", "800000", "120420" ], + "220374" : [ "06:14", "800000", "120420" ], + "220375" : [ "06:15", "800000", "120420" ], + "220376" : [ "06:16", "800000", "120420" ], + "220377" : [ "06:17", "800000", "120420" ], + "220378" : [ "06:18", "800000", "120420" ], + "220379" : [ "06:19", "800000", "120420" ], + "220380" : [ "06:20", "800000", "120420" ], + "220381" : [ "06:21", "800000", "120420" ], + "220382" : [ "06:22", "800000", "120420" ], + "220383" : [ "06:23", "800000", "120420" ], + "220384" : [ "06:24", "800000", "120420" ], + "220385" : [ "06:25", "800000", "120420" ], + "220386" : [ "06:26", "800000", "120420" ], + "220387" : [ "06:27", "800000", "120420" ], + "220388" : [ "06:28", "800000", "120420" ], + "220389" : [ "06:29", "800000", "120420" ], + "220390" : [ "06:30", "800000", "120420" ], + "220391" : [ "06:31", "800000", "120420" ], + "220392" : [ "06:32", "800000", "120420" ], + "220393" : [ "06:33", "800000", "120420" ], + "220394" : [ "06:34", "800000", "120420" ], + "220395" : [ "06:35", "800000", "120420" ], + "220396" : [ "06:36", "800000", "120420" ], + "220397" : [ "06:37", "800000", "120420" ], + "220398" : [ "06:38", "800000", "120420" ], + "220399" : [ "06:39", "800000", "120420" ], + "220400" : [ "06:40", "800000", "120420" ], + "220401" : [ "06:41", "800000", "120420" ], + "220402" : [ "06:42", "800000", "120420" ], + "220403" : [ "06:43", "800000", "120420" ], + "220404" : [ "06:44", "800000", "120420" ], + "220405" : [ "06:45", "800000", "120420" ], + "220406" : [ "06:46", "800000", "120420" ], + "220407" : [ "06:47", "800000", "120420" ], + "220408" : [ "06:48", "800000", "120420" ], + "220409" : [ "06:49", "800000", "120420" ], + "220410" : [ "06:50", "800000", "120420" ], + "220411" : [ "06:51", "800000", "120420" ], + "220412" : [ "06:52", "800000", "120420" ], + "220413" : [ "06:53", "800000", "120420" ], + "220414" : [ "06:54", "800000", "120420" ], + "220415" : [ "06:55", "800000", "120420" ], + "220416" : [ "06:56", "800000", "120420" ], + "220417" : [ "06:57", "800000", "120420" ], + "220418" : [ "06:58", "800000", "120420" ], + "220419" : [ "06:59", "800000", "120420" ], + "220420" : [ "07:00", "350000", "120480" ], + "220421" : [ "07:01", "350000", "120481" ], + "220422" : [ "07:02", "350000", "120482" ], + "220423" : [ "07:03", "350000", "120483" ], + "220424" : [ "07:04", "350000", "120484" ], + "220425" : [ "07:05", "350000", "120485" ], + "220426" : [ "07:06", "350000", "120486" ], + "220427" : [ "07:07", "350000", "120487" ], + "220428" : [ "07:08", "350000", "120488" ], + "220429" : [ "07:09", "350000", "120489" ], + "220430" : [ "07:10", "350000", "120490" ], + "220431" : [ "07:11", "350000", "120491" ], + "220432" : [ "07:12", "350000", "120492" ], + "220433" : [ "07:13", "350000", "120493" ], + "220434" : [ "07:14", "350000", "120494" ], + "220435" : [ "07:15", "350000", "120495" ], + "220436" : [ "07:16", "350000", "120496" ], + "220437" : [ "07:17", "350000", "120497" ], + "220438" : [ "07:18", "350000", "120498" ], + "220439" : [ "07:19", "350000", "120499" ], + "220440" : [ "07:20", "350000", "120500" ], + "220441" : [ "07:21", "350000", "120501" ], + "220442" : [ "07:22", "350000", "120502" ], + "220443" : [ "07:23", "350000", "120503" ], + "220444" : [ "07:24", "350000", "120504" ], + "220445" : [ "07:25", "350000", "120505" ], + "220446" : [ "07:26", "350000", "120506" ], + "220447" : [ "07:27", "350000", "120507" ], + "220448" : [ "07:28", "350000", "120508" ], + "220449" : [ "07:29", "350000", "120509" ], + "220450" : [ "07:30", "350000", "120510" ], + "220451" : [ "07:31", "350000", "120511" ], + "220452" : [ "07:32", "350000", "120512" ], + "220453" : [ "07:33", "350000", "120513" ], + "220454" : [ "07:34", "350000", "120514" ], + "220455" : [ "07:35", "350000", "120515" ], + "220456" : [ "07:36", "350000", "120516" ], + "220457" : [ "07:37", "350000", "120517" ], + "220458" : [ "07:38", "350000", "120518" ], + "220459" : [ "07:39", "350000", "120519" ], + "220460" : [ "07:40", "350000", "120520" ], + "220461" : [ "07:41", "350000", "120521" ], + "220462" : [ "07:42", "350000", "120522" ], + "220463" : [ "07:43", "350000", "120523" ], + "220464" : [ "07:44", "350000", "120524" ], + "220465" : [ "07:45", "350000", "120525" ], + "220466" : [ "07:46", "350000", "120526" ], + "220467" : [ "07:47", "350000", "120527" ], + "220468" : [ "07:48", "350000", "120528" ], + "220469" : [ "07:49", "350000", "120529" ], + "220470" : [ "07:50", "350000", "120530" ], + "220471" : [ "07:51", "350000", "120531" ], + "220472" : [ "07:52", "350000", "120532" ], + "220473" : [ "07:53", "350000", "120533" ], + "220474" : [ "07:54", "350000", "120534" ], + "220475" : [ "07:55", "350000", "120535" ], + "220476" : [ "07:56", "350000", "120536" ], + "220477" : [ "07:57", "350000", "120537" ], + "220478" : [ "07:58", "350000", "120538" ], + "220479" : [ "07:59", "350000", "120539" ], + "220480" : [ "08:00", "350000", "120540" ], + "220481" : [ "08:01", "350000", "120541" ], + "220482" : [ "08:02", "350000", "120542" ], + "220483" : [ "08:03", "350000", "120543" ], + "220484" : [ "08:04", "350000", "120544" ], + "220485" : [ "08:05", "350000", "120545" ], + "220486" : [ "08:06", "350000", "120546" ], + "220487" : [ "08:07", "350000", "120547" ], + "220488" : [ "08:08", "350000", "120548" ], + "220489" : [ "08:09", "350000", "120549" ], + "220490" : [ "08:10", "350000", "120550" ], + "220491" : [ "08:11", "350000", "120551" ], + "220492" : [ "08:12", "350000", "120552" ], + "220493" : [ "08:13", "350000", "120553" ], + "220494" : [ "08:14", "350000", "120554" ], + "220495" : [ "08:15", "350000", "120555" ], + "220496" : [ "08:16", "350000", "120556" ], + "220497" : [ "08:17", "350000", "120557" ], + "220498" : [ "08:18", "350000", "120558" ], + "220499" : [ "08:19", "350000", "120559" ], + "220500" : [ "08:20", "350000", "120560" ], + "220501" : [ "08:21", "350000", "120561" ], + "220502" : [ "08:22", "350000", "120562" ], + "220503" : [ "08:23", "350000", "120563" ], + "220504" : [ "08:24", "350000", "120564" ], + "220505" : [ "08:25", "350000", "120565" ], + "220506" : [ "08:26", "350000", "120566" ], + "220507" : [ "08:27", "350000", "120567" ], + "220508" : [ "08:28", "350000", "120568" ], + "220509" : [ "08:29", "350000", "120569" ], + "220510" : [ "08:30", "350000", "120570" ], + "220511" : [ "08:31", "350000", "120571" ], + "220512" : [ "08:32", "350000", "120572" ], + "220513" : [ "08:33", "350000", "120573" ], + "220514" : [ "08:34", "350000", "120574" ], + "220515" : [ "08:35", "350000", "120575" ], + "220516" : [ "08:36", "350000", "120576" ], + "220517" : [ "08:37", "350000", "120577" ], + "220518" : [ "08:38", "350000", "120578" ], + "220519" : [ "08:39", "350000", "120579" ], + "220520" : [ "08:40", "350000", "120580" ], + "220521" : [ "08:41", "350000", "120581" ], + "220522" : [ "08:42", "350000", "120582" ], + "220523" : [ "08:43", "350000", "120583" ], + "220524" : [ "08:44", "350000", "120584" ], + "220525" : [ "08:45", "350000", "120585" ], + "220526" : [ "08:46", "350000", "120586" ], + "220527" : [ "08:47", "350000", "120587" ], + "220528" : [ "08:48", "350000", "120588" ], + "220529" : [ "08:49", "350000", "120589" ], + "220530" : [ "08:50", "350000", "120590" ], + "220531" : [ "08:51", "350000", "120591" ], + "220532" : [ "08:52", "350000", "120592" ], + "220533" : [ "08:53", "350000", "120593" ], + "220534" : [ "08:54", "350000", "120594" ], + "220535" : [ "08:55", "350000", "120595" ], + "220536" : [ "08:56", "350000", "120596" ], + "220537" : [ "08:57", "350000", "120597" ], + "220538" : [ "08:58", "350000", "120598" ], + "220539" : [ "08:59", "350000", "120599" ], + "220540" : [ "09:00", "350000", "120600" ], + "220541" : [ "09:01", "350000", "120601" ], + "220542" : [ "09:02", "350000", "120602" ], + "220543" : [ "09:03", "350000", "120603" ], + "220544" : [ "09:04", "350000", "120604" ], + "220545" : [ "09:05", "350000", "120605" ], + "220546" : [ "09:06", "350000", "120606" ], + "220547" : [ "09:07", "350000", "120607" ], + "220548" : [ "09:08", "350000", "120608" ], + "220549" : [ "09:09", "350000", "120609" ], + "220550" : [ "09:10", "350000", "120610" ], + "220551" : [ "09:11", "350000", "120611" ], + "220552" : [ "09:12", "350000", "120612" ], + "220553" : [ "09:13", "350000", "120613" ], + "220554" : [ "09:14", "350000", "120614" ], + "220555" : [ "09:15", "350000", "120615" ], + "220556" : [ "09:16", "350000", "120616" ], + "220557" : [ "09:17", "350000", "120617" ], + "220558" : [ "09:18", "350000", "120618" ], + "220559" : [ "09:19", "350000", "120619" ], + "220560" : [ "09:20", "350000", "120620" ], + "220561" : [ "09:21", "350000", "120621" ], + "220562" : [ "09:22", "350000", "120622" ], + "220563" : [ "09:23", "350000", "120623" ], + "220564" : [ "09:24", "350000", "120624" ], + "220565" : [ "09:25", "350000", "120625" ], + "220566" : [ "09:26", "350000", "120626" ], + "220567" : [ "09:27", "350000", "120627" ], + "220568" : [ "09:28", "350000", "120628" ], + "220569" : [ "09:29", "350000", "120629" ], + "220570" : [ "09:30", "350000", "120630" ], + "220571" : [ "09:31", "350000", "120631" ], + "220572" : [ "09:32", "350000", "120632" ], + "220573" : [ "09:33", "350000", "120633" ], + "220574" : [ "09:34", "350000", "120634" ], + "220575" : [ "09:35", "350000", "120635" ], + "220576" : [ "09:36", "350000", "120636" ], + "220577" : [ "09:37", "350000", "120637" ], + "220578" : [ "09:38", "350000", "120638" ], + "220579" : [ "09:39", "350000", "120639" ], + "220580" : [ "09:40", "350000", "120640" ], + "220581" : [ "09:41", "350000", "120641" ], + "220582" : [ "09:42", "350000", "120642" ], + "220583" : [ "09:43", "350000", "120643" ], + "220584" : [ "09:44", "350000", "120644" ], + "220585" : [ "09:45", "350000", "120645" ], + "220586" : [ "09:46", "350000", "120646" ], + "220587" : [ "09:47", "350000", "120647" ], + "220588" : [ "09:48", "350000", "120648" ], + "220589" : [ "09:49", "350000", "120649" ], + "220590" : [ "09:50", "350000", "120650" ], + "220591" : [ "09:51", "350000", "120651" ], + "220592" : [ "09:52", "350000", "120652" ], + "220593" : [ "09:53", "350000", "120653" ], + "220594" : [ "09:54", "350000", "120654" ], + "220595" : [ "09:55", "350000", "120655" ], + "220596" : [ "09:56", "350000", "120656" ], + "220597" : [ "09:57", "350000", "120657" ], + "220598" : [ "09:58", "350000", "120658" ], + "220599" : [ "09:59", "350000", "120659" ], + "220600" : [ "10:00", "350000", "120660" ], + "220601" : [ "10:01", "350000", "120661" ], + "220602" : [ "10:02", "350000", "120662" ], + "220603" : [ "10:03", "350000", "120663" ], + "220604" : [ "10:04", "350000", "120664" ], + "220605" : [ "10:05", "350000", "120665" ], + "220606" : [ "10:06", "350000", "120666" ], + "220607" : [ "10:07", "350000", "120667" ], + "220608" : [ "10:08", "350000", "120668" ], + "220609" : [ "10:09", "350000", "120669" ], + "220610" : [ "10:10", "350000", "120670" ], + "220611" : [ "10:11", "350000", "120671" ], + "220612" : [ "10:12", "350000", "120672" ], + "220613" : [ "10:13", "350000", "120673" ], + "220614" : [ "10:14", "350000", "120674" ], + "220615" : [ "10:15", "350000", "120675" ], + "220616" : [ "10:16", "350000", "120676" ], + "220617" : [ "10:17", "350000", "120677" ], + "220618" : [ "10:18", "350000", "120678" ], + "220619" : [ "10:19", "350000", "120679" ], + "220620" : [ "10:20", "350000", "120680" ], + "220621" : [ "10:21", "350000", "120681" ], + "220622" : [ "10:22", "350000", "120682" ], + "220623" : [ "10:23", "350000", "120683" ], + "220624" : [ "10:24", "350000", "120684" ], + "220625" : [ "10:25", "350000", "120685" ], + "220626" : [ "10:26", "350000", "120686" ], + "220627" : [ "10:27", "350000", "120687" ], + "220628" : [ "10:28", "350000", "120688" ], + "220629" : [ "10:29", "350000", "120689" ], + "220630" : [ "10:30", "350000", "120690" ], + "220631" : [ "10:31", "350000", "120691" ], + "220632" : [ "10:32", "350000", "120692" ], + "220633" : [ "10:33", "350000", "120693" ], + "220634" : [ "10:34", "350000", "120694" ], + "220635" : [ "10:35", "350000", "120695" ], + "220636" : [ "10:36", "350000", "120696" ], + "220637" : [ "10:37", "350000", "120697" ], + "220638" : [ "10:38", "350000", "120698" ], + "220639" : [ "10:39", "350000", "120699" ], + "220640" : [ "10:40", "350000", "120700" ], + "220641" : [ "10:41", "350000", "120701" ], + "220642" : [ "10:42", "350000", "120702" ], + "220643" : [ "10:43", "350000", "120703" ], + "220644" : [ "10:44", "350000", "120704" ], + "220645" : [ "10:45", "350000", "120705" ], + "220646" : [ "10:46", "350000", "120706" ], + "220647" : [ "10:47", "350000", "120707" ], + "220648" : [ "10:48", "350000", "120708" ], + "220649" : [ "10:49", "350000", "120709" ], + "220650" : [ "10:50", "350000", "120710" ], + "220651" : [ "10:51", "350000", "120711" ], + "220652" : [ "10:52", "350000", "120712" ], + "220653" : [ "10:53", "350000", "120713" ], + "220654" : [ "10:54", "350000", "120714" ], + "220655" : [ "10:55", "350000", "120715" ], + "220656" : [ "10:56", "350000", "120716" ], + "220657" : [ "10:57", "350000", "120717" ], + "220658" : [ "10:58", "350000", "120718" ], + "220659" : [ "10:59", "350000", "120719" ], + "220660" : [ "11:00", "350000", "120720" ], + "220661" : [ "11:01", "350000", "120721" ], + "220662" : [ "11:02", "350000", "120722" ], + "220663" : [ "11:03", "350000", "120723" ], + "220664" : [ "11:04", "350000", "120724" ], + "220665" : [ "11:05", "350000", "120725" ], + "220666" : [ "11:06", "350000", "120726" ], + "220667" : [ "11:07", "350000", "120727" ], + "220668" : [ "11:08", "350000", "120728" ], + "220669" : [ "11:09", "350000", "120729" ], + "220670" : [ "11:10", "350000", "120730" ], + "220671" : [ "11:11", "350000", "120731" ], + "220672" : [ "11:12", "350000", "120732" ], + "220673" : [ "11:13", "350000", "120733" ], + "220674" : [ "11:14", "350000", "120734" ], + "220675" : [ "11:15", "350000", "120735" ], + "220676" : [ "11:16", "350000", "120736" ], + "220677" : [ "11:17", "350000", "120737" ], + "220678" : [ "11:18", "350000", "120738" ], + "220679" : [ "11:19", "350000", "120739" ], + "220680" : [ "11:20", "350000", "120740" ], + "220681" : [ "11:21", "350000", "120741" ], + "220682" : [ "11:22", "350000", "120742" ], + "220683" : [ "11:23", "350000", "120743" ], + "220684" : [ "11:24", "350000", "120744" ], + "220685" : [ "11:25", "350000", "120745" ], + "220686" : [ "11:26", "350000", "120746" ], + "220687" : [ "11:27", "350000", "120747" ], + "220688" : [ "11:28", "350000", "120748" ], + "220689" : [ "11:29", "350000", "120749" ], + "220690" : [ "11:30", "350000", "120750" ], + "220691" : [ "11:31", "350000", "120751" ], + "220692" : [ "11:32", "350000", "120752" ], + "220693" : [ "11:33", "350000", "120753" ], + "220694" : [ "11:34", "350000", "120754" ], + "220695" : [ "11:35", "350000", "120755" ], + "220696" : [ "11:36", "350000", "120756" ], + "220697" : [ "11:37", "350000", "120757" ], + "220698" : [ "11:38", "350000", "120758" ], + "220699" : [ "11:39", "350000", "120759" ], + "220700" : [ "11:40", "350000", "120760" ], + "220701" : [ "11:41", "350000", "120761" ], + "220702" : [ "11:42", "350000", "120762" ], + "220703" : [ "11:43", "350000", "120763" ], + "220704" : [ "11:44", "350000", "120764" ], + "220705" : [ "11:45", "350000", "120765" ], + "220706" : [ "11:46", "350000", "120766" ], + "220707" : [ "11:47", "350000", "120767" ], + "220708" : [ "11:48", "350000", "120768" ], + "220709" : [ "11:49", "350000", "120769" ], + "220710" : [ "11:50", "350000", "120770" ], + "220711" : [ "11:51", "350000", "120771" ], + "220712" : [ "11:52", "350000", "120772" ], + "220713" : [ "11:53", "350000", "120773" ], + "220714" : [ "11:54", "350000", "120774" ], + "220715" : [ "11:55", "350000", "120775" ], + "220716" : [ "11:56", "350000", "120776" ], + "220717" : [ "11:57", "350000", "120777" ], + "220718" : [ "11:58", "350000", "120778" ], + "220719" : [ "11:59", "350000", "120779" ], + "220720" : [ "12:00", "350000", "120780" ], + "220721" : [ "12:01", "350000", "120781" ], + "220722" : [ "12:02", "350000", "120782" ], + "220723" : [ "12:03", "350000", "120783" ], + "220724" : [ "12:04", "350000", "120784" ], + "220725" : [ "12:05", "350000", "120785" ], + "220726" : [ "12:06", "350000", "120786" ], + "220727" : [ "12:07", "350000", "120787" ], + "220728" : [ "12:08", "350000", "120788" ], + "220729" : [ "12:09", "350000", "120789" ], + "220730" : [ "12:10", "350000", "120790" ], + "220731" : [ "12:11", "350000", "120791" ], + "220732" : [ "12:12", "350000", "120792" ], + "220733" : [ "12:13", "350000", "120793" ], + "220734" : [ "12:14", "350000", "120794" ], + "220735" : [ "12:15", "350000", "120795" ], + "220736" : [ "12:16", "350000", "120796" ], + "220737" : [ "12:17", "350000", "120797" ], + "220738" : [ "12:18", "350000", "120798" ], + "220739" : [ "12:19", "350000", "120799" ], + "220740" : [ "12:20", "350000", "120800" ], + "220741" : [ "12:21", "350000", "120801" ], + "220742" : [ "12:22", "350000", "120802" ], + "220743" : [ "12:23", "350000", "120803" ], + "220744" : [ "12:24", "350000", "120804" ], + "220745" : [ "12:25", "350000", "120805" ], + "220746" : [ "12:26", "350000", "120806" ], + "220747" : [ "12:27", "350000", "120807" ], + "220748" : [ "12:28", "350000", "120808" ], + "220749" : [ "12:29", "350000", "120809" ], + "220750" : [ "12:30", "350000", "120810" ], + "220751" : [ "12:31", "350000", "120811" ], + "220752" : [ "12:32", "350000", "120812" ], + "220753" : [ "12:33", "350000", "120813" ], + "220754" : [ "12:34", "350000", "120814" ], + "220755" : [ "12:35", "350000", "120815" ], + "220756" : [ "12:36", "350000", "120816" ], + "220757" : [ "12:37", "350000", "120817" ], + "220758" : [ "12:38", "350000", "120818" ], + "220759" : [ "12:39", "350000", "120819" ], + "220760" : [ "12:40", "350000", "120820" ], + "220761" : [ "12:41", "350000", "120821" ], + "220762" : [ "12:42", "350000", "120822" ], + "220763" : [ "12:43", "350000", "120823" ], + "220764" : [ "12:44", "350000", "120824" ], + "220765" : [ "12:45", "350000", "120825" ], + "220766" : [ "12:46", "350000", "120826" ], + "220767" : [ "12:47", "350000", "120827" ], + "220768" : [ "12:48", "350000", "120828" ], + "220769" : [ "12:49", "350000", "120829" ], + "220770" : [ "12:50", "350000", "120830" ], + "220771" : [ "12:51", "350000", "120831" ], + "220772" : [ "12:52", "350000", "120832" ], + "220773" : [ "12:53", "350000", "120833" ], + "220774" : [ "12:54", "350000", "120834" ], + "220775" : [ "12:55", "350000", "120835" ], + "220776" : [ "12:56", "350000", "120836" ], + "220777" : [ "12:57", "350000", "120837" ], + "220778" : [ "12:58", "350000", "120838" ], + "220779" : [ "12:59", "350000", "120839" ], + "220780" : [ "13:00", "350000", "120840" ], + "220781" : [ "13:01", "350000", "120841" ], + "220782" : [ "13:02", "350000", "120842" ], + "220783" : [ "13:03", "350000", "120843" ], + "220784" : [ "13:04", "350000", "120844" ], + "220785" : [ "13:05", "350000", "120845" ], + "220786" : [ "13:06", "350000", "120846" ], + "220787" : [ "13:07", "350000", "120847" ], + "220788" : [ "13:08", "350000", "120848" ], + "220789" : [ "13:09", "350000", "120849" ], + "220790" : [ "13:10", "350000", "120850" ], + "220791" : [ "13:11", "350000", "120851" ], + "220792" : [ "13:12", "350000", "120852" ], + "220793" : [ "13:13", "350000", "120853" ], + "220794" : [ "13:14", "350000", "120854" ], + "220795" : [ "13:15", "350000", "120855" ], + "220796" : [ "13:16", "350000", "120856" ], + "220797" : [ "13:17", "350000", "120857" ], + "220798" : [ "13:18", "350000", "120858" ], + "220799" : [ "13:19", "350000", "120859" ], + "220800" : [ "13:20", "350000", "120860" ], + "220801" : [ "13:21", "350000", "120861" ], + "220802" : [ "13:22", "350000", "120862" ], + "220803" : [ "13:23", "350000", "120863" ], + "220804" : [ "13:24", "350000", "120864" ], + "220805" : [ "13:25", "350000", "120865" ], + "220806" : [ "13:26", "350000", "120866" ], + "220807" : [ "13:27", "350000", "120867" ], + "220808" : [ "13:28", "350000", "120868" ], + "220809" : [ "13:29", "350000", "120869" ], + "220810" : [ "13:30", "350000", "120870" ], + "220811" : [ "13:31", "350000", "120871" ], + "220812" : [ "13:32", "350000", "120872" ], + "220813" : [ "13:33", "350000", "120873" ], + "220814" : [ "13:34", "350000", "120874" ], + "220815" : [ "13:35", "350000", "120875" ], + "220816" : [ "13:36", "350000", "120876" ], + "220817" : [ "13:37", "350000", "120877" ], + "220818" : [ "13:38", "350000", "120878" ], + "220819" : [ "13:39", "350000", "120879" ], + "220820" : [ "13:40", "350000", "120880" ], + "220821" : [ "13:41", "350000", "120881" ], + "220822" : [ "13:42", "350000", "120882" ], + "220823" : [ "13:43", "350000", "120883" ], + "220824" : [ "13:44", "350000", "120884" ], + "220825" : [ "13:45", "350000", "120885" ], + "220826" : [ "13:46", "350000", "120886" ], + "220827" : [ "13:47", "350000", "120887" ], + "220828" : [ "13:48", "350000", "120888" ], + "220829" : [ "13:49", "350000", "120889" ], + "220830" : [ "13:50", "350000", "120890" ], + "220831" : [ "13:51", "350000", "120891" ], + "220832" : [ "13:52", "350000", "120892" ], + "220833" : [ "13:53", "350000", "120893" ], + "220834" : [ "13:54", "350000", "120894" ], + "220835" : [ "13:55", "350000", "120895" ], + "220836" : [ "13:56", "350000", "120896" ], + "220837" : [ "13:57", "350000", "120897" ], + "220838" : [ "13:58", "350000", "120898" ], + "220839" : [ "13:59", "350000", "120899" ], + "220840" : [ "14:00", "350000", "120900" ], + "220841" : [ "14:01", "350000", "120901" ], + "220842" : [ "14:02", "350000", "120902" ], + "220843" : [ "14:03", "350000", "120903" ], + "220844" : [ "14:04", "350000", "120904" ], + "220845" : [ "14:05", "350000", "120905" ], + "220846" : [ "14:06", "350000", "120906" ], + "220847" : [ "14:07", "350000", "120907" ], + "220848" : [ "14:08", "350000", "120908" ], + "220849" : [ "14:09", "350000", "120909" ], + "220850" : [ "14:10", "350000", "120910" ], + "220851" : [ "14:11", "350000", "120911" ], + "220852" : [ "14:12", "350000", "120912" ], + "220853" : [ "14:13", "350000", "120913" ], + "220854" : [ "14:14", "350000", "120914" ], + "220855" : [ "14:15", "350000", "120915" ], + "220856" : [ "14:16", "350000", "120916" ], + "220857" : [ "14:17", "350000", "120917" ], + "220858" : [ "14:18", "350000", "120918" ], + "220859" : [ "14:19", "350000", "120919" ], + "220860" : [ "14:20", "350000", "120920" ], + "220861" : [ "14:21", "350000", "120921" ], + "220862" : [ "14:22", "350000", "120922" ], + "220863" : [ "14:23", "350000", "120923" ], + "220864" : [ "14:24", "350000", "120924" ], + "220865" : [ "14:25", "350000", "120925" ], + "220866" : [ "14:26", "350000", "120926" ], + "220867" : [ "14:27", "350000", "120927" ], + "220868" : [ "14:28", "350000", "120928" ], + "220869" : [ "14:29", "350000", "120929" ], + "220870" : [ "14:30", "350000", "120930" ], + "220871" : [ "14:31", "350000", "120931" ], + "220872" : [ "14:32", "350000", "120932" ], + "220873" : [ "14:33", "350000", "120933" ], + "220874" : [ "14:34", "350000", "120934" ], + "220875" : [ "14:35", "350000", "120935" ], + "220876" : [ "14:36", "350000", "120936" ], + "220877" : [ "14:37", "350000", "120937" ], + "220878" : [ "14:38", "350000", "120938" ], + "220879" : [ "14:39", "350000", "120939" ], + "220880" : [ "14:40", "350000", "120940" ], + "220881" : [ "14:41", "350000", "120941" ], + "220882" : [ "14:42", "350000", "120942" ], + "220883" : [ "14:43", "350000", "120943" ], + "220884" : [ "14:44", "350000", "120944" ], + "220885" : [ "14:45", "350000", "120945" ], + "220886" : [ "14:46", "350000", "120946" ], + "220887" : [ "14:47", "350000", "120947" ], + "220888" : [ "14:48", "350000", "120948" ], + "220889" : [ "14:49", "350000", "120949" ], + "220890" : [ "14:50", "350000", "120950" ], + "220891" : [ "14:51", "350000", "120951" ], + "220892" : [ "14:52", "350000", "120952" ], + "220893" : [ "14:53", "350000", "120953" ], + "220894" : [ "14:54", "350000", "120954" ], + "220895" : [ "14:55", "350000", "120955" ], + "220896" : [ "14:56", "350000", "120956" ], + "220897" : [ "14:57", "350000", "120957" ], + "220898" : [ "14:58", "350000", "120958" ], + "220899" : [ "14:59", "350000", "120959" ], + "220900" : [ "15:00", "350000", "120960" ], + "220901" : [ "15:01", "350000", "120961" ], + "220902" : [ "15:02", "350000", "120962" ], + "220903" : [ "15:03", "350000", "120963" ], + "220904" : [ "15:04", "350000", "120964" ], + "220905" : [ "15:05", "350000", "120965" ], + "220906" : [ "15:06", "350000", "120966" ], + "220907" : [ "15:07", "350000", "120967" ], + "220908" : [ "15:08", "350000", "120968" ], + "220909" : [ "15:09", "350000", "120969" ], + "220910" : [ "15:10", "350000", "120970" ], + "220911" : [ "15:11", "350000", "120971" ], + "220912" : [ "15:12", "350000", "120972" ], + "220913" : [ "15:13", "350000", "120973" ], + "220914" : [ "15:14", "350000", "120974" ], + "220915" : [ "15:15", "350000", "120975" ], + "220916" : [ "15:16", "350000", "120976" ], + "220917" : [ "15:17", "350000", "120977" ], + "220918" : [ "15:18", "350000", "120978" ], + "220919" : [ "15:19", "350000", "120979" ], + "220920" : [ "15:20", "350000", "120980" ], + "220921" : [ "15:21", "350000", "120981" ], + "220922" : [ "15:22", "350000", "120982" ], + "220923" : [ "15:23", "350000", "120983" ], + "220924" : [ "15:24", "350000", "120984" ], + "220925" : [ "15:25", "350000", "120985" ], + "220926" : [ "15:26", "350000", "120986" ], + "220927" : [ "15:27", "350000", "120987" ], + "220928" : [ "15:28", "350000", "120988" ], + "220929" : [ "15:29", "350000", "120989" ], + "220930" : [ "15:30", "350000", "120990" ], + "220931" : [ "15:31", "350000", "120991" ], + "220932" : [ "15:32", "350000", "120992" ], + "220933" : [ "15:33", "350000", "120993" ], + "220934" : [ "15:34", "350000", "120994" ], + "220935" : [ "15:35", "350000", "120995" ], + "220936" : [ "15:36", "350000", "120996" ], + "220937" : [ "15:37", "350000", "120997" ], + "220938" : [ "15:38", "350000", "120998" ], + "220939" : [ "15:39", "350000", "120999" ], + "220940" : [ "15:40", "350000", "121000" ], + "220941" : [ "15:41", "350000", "121001" ], + "220942" : [ "15:42", "350000", "121002" ], + "220943" : [ "15:43", "350000", "121003" ], + "220944" : [ "15:44", "350000", "121004" ], + "220945" : [ "15:45", "350000", "121005" ], + "220946" : [ "15:46", "350000", "121006" ], + "220947" : [ "15:47", "350000", "121007" ], + "220948" : [ "15:48", "350000", "121008" ], + "220949" : [ "15:49", "350000", "121009" ], + "220950" : [ "15:50", "350000", "121010" ], + "220951" : [ "15:51", "350000", "121011" ], + "220952" : [ "15:52", "350000", "121012" ], + "220953" : [ "15:53", "350000", "121013" ], + "220954" : [ "15:54", "350000", "121014" ], + "220955" : [ "15:55", "350000", "121015" ], + "220956" : [ "15:56", "350000", "121016" ], + "220957" : [ "15:57", "350000", "121017" ], + "220958" : [ "15:58", "350000", "121018" ], + "220959" : [ "15:59", "350000", "121019" ], + "220960" : [ "16:00", "350000", "121020" ], + "220961" : [ "16:01", "350000", "121021" ], + "220962" : [ "16:02", "350000", "121022" ], + "220963" : [ "16:03", "350000", "121023" ], + "220964" : [ "16:04", "350000", "121024" ], + "220965" : [ "16:05", "350000", "121025" ], + "220966" : [ "16:06", "350000", "121026" ], + "220967" : [ "16:07", "350000", "121027" ], + "220968" : [ "16:08", "350000", "121028" ], + "220969" : [ "16:09", "350000", "121029" ], + "220970" : [ "16:10", "350000", "121030" ], + "220971" : [ "16:11", "350000", "121031" ], + "220972" : [ "16:12", "350000", "121032" ], + "220973" : [ "16:13", "350000", "121033" ], + "220974" : [ "16:14", "350000", "121034" ], + "220975" : [ "16:15", "350000", "121035" ], + "220976" : [ "16:16", "350000", "121036" ], + "220977" : [ "16:17", "350000", "121037" ], + "220978" : [ "16:18", "350000", "121038" ], + "220979" : [ "16:19", "350000", "121039" ], + "220980" : [ "16:20", "350000", "121040" ], + "220981" : [ "16:21", "350000", "121041" ], + "220982" : [ "16:22", "350000", "121042" ], + "220983" : [ "16:23", "350000", "121043" ], + "220984" : [ "16:24", "350000", "121044" ], + "220985" : [ "16:25", "350000", "121045" ], + "220986" : [ "16:26", "350000", "121046" ], + "220987" : [ "16:27", "350000", "121047" ], + "220988" : [ "16:28", "350000", "121048" ], + "220989" : [ "16:29", "350000", "121049" ], + "220990" : [ "16:30", "350000", "121050" ], + "220991" : [ "16:31", "350000", "121051" ], + "220992" : [ "16:32", "350000", "121052" ], + "220993" : [ "16:33", "350000", "121053" ], + "220994" : [ "16:34", "350000", "121054" ], + "220995" : [ "16:35", "350000", "121055" ], + "220996" : [ "16:36", "350000", "121056" ], + "220997" : [ "16:37", "350000", "121057" ], + "220998" : [ "16:38", "350000", "121058" ], + "220999" : [ "16:39", "350000", "121059" ], + "221000" : [ "16:40", "350000", "121060" ], + "221001" : [ "16:41", "350000", "121061" ], + "221002" : [ "16:42", "350000", "121062" ], + "221003" : [ "16:43", "350000", "121063" ], + "221004" : [ "16:44", "350000", "121064" ], + "221005" : [ "16:45", "350000", "121065" ], + "221006" : [ "16:46", "350000", "121066" ], + "221007" : [ "16:47", "350000", "121067" ], + "221008" : [ "16:48", "350000", "121068" ], + "221009" : [ "16:49", "350000", "121069" ], + "221010" : [ "16:50", "350000", "121070" ], + "221011" : [ "16:51", "350000", "121071" ], + "221012" : [ "16:52", "350000", "121072" ], + "221013" : [ "16:53", "350000", "121073" ], + "221014" : [ "16:54", "350000", "121074" ], + "221015" : [ "16:55", "350000", "121075" ], + "221016" : [ "16:56", "350000", "121076" ], + "221017" : [ "16:57", "350000", "121077" ], + "221018" : [ "16:58", "350000", "121078" ], + "221019" : [ "16:59", "350000", "121079" ], + "221020" : [ "17:00", "350000", "121080" ], + "221021" : [ "17:01", "350000", "121081" ], + "221022" : [ "17:02", "350000", "121082" ], + "221023" : [ "17:03", "350000", "121083" ], + "221024" : [ "17:04", "350000", "121084" ], + "221025" : [ "17:05", "350000", "121085" ], + "221026" : [ "17:06", "350000", "121086" ], + "221027" : [ "17:07", "350000", "121087" ], + "221028" : [ "17:08", "350000", "121088" ], + "221029" : [ "17:09", "350000", "121089" ], + "221030" : [ "17:10", "350000", "121090" ], + "221031" : [ "17:11", "350000", "121091" ], + "221032" : [ "17:12", "350000", "121092" ], + "221033" : [ "17:13", "350000", "121093" ], + "221034" : [ "17:14", "350000", "121094" ], + "221035" : [ "17:15", "350000", "121095" ], + "221036" : [ "17:16", "350000", "121096" ], + "221037" : [ "17:17", "350000", "121097" ], + "221038" : [ "17:18", "350000", "121098" ], + "221039" : [ "17:19", "350000", "121099" ], + "221040" : [ "17:20", "350000", "121100" ], + "221041" : [ "17:21", "350000", "121101" ], + "221042" : [ "17:22", "350000", "121102" ], + "221043" : [ "17:23", "350000", "121103" ], + "221044" : [ "17:24", "350000", "121104" ], + "221045" : [ "17:25", "350000", "121105" ], + "221046" : [ "17:26", "350000", "121106" ], + "221047" : [ "17:27", "350000", "121107" ], + "221048" : [ "17:28", "350000", "121108" ], + "221049" : [ "17:29", "350000", "121109" ], + "221050" : [ "17:30", "350000", "121110" ], + "221051" : [ "17:31", "350000", "121111" ], + "221052" : [ "17:32", "350000", "121112" ], + "221053" : [ "17:33", "350000", "121113" ], + "221054" : [ "17:34", "350000", "121114" ], + "221055" : [ "17:35", "350000", "121115" ], + "221056" : [ "17:36", "350000", "121116" ], + "221057" : [ "17:37", "350000", "121117" ], + "221058" : [ "17:38", "350000", "121118" ], + "221059" : [ "17:39", "350000", "121119" ], + "221060" : [ "17:40", "350000", "121120" ], + "221061" : [ "17:41", "350000", "121121" ], + "221062" : [ "17:42", "350000", "121122" ], + "221063" : [ "17:43", "350000", "121123" ], + "221064" : [ "17:44", "350000", "121124" ], + "221065" : [ "17:45", "350000", "121125" ], + "221066" : [ "17:46", "350000", "121126" ], + "221067" : [ "17:47", "350000", "121127" ], + "221068" : [ "17:48", "350000", "121128" ], + "221069" : [ "17:49", "350000", "121129" ], + "221070" : [ "17:50", "350000", "121130" ], + "221071" : [ "17:51", "350000", "121131" ], + "221072" : [ "17:52", "350000", "121132" ], + "221073" : [ "17:53", "350000", "121133" ], + "221074" : [ "17:54", "350000", "121134" ], + "221075" : [ "17:55", "350000", "121135" ], + "221076" : [ "17:56", "350000", "121136" ], + "221077" : [ "17:57", "350000", "121137" ], + "221078" : [ "17:58", "350000", "121138" ], + "221079" : [ "17:59", "350000", "121139" ], + "221080" : [ "18:00", "350000", "121140" ], + "221081" : [ "18:01", "350000", "121141" ], + "221082" : [ "18:02", "350000", "121142" ], + "221083" : [ "18:03", "350000", "121143" ], + "221084" : [ "18:04", "350000", "121144" ], + "221085" : [ "18:05", "350000", "121145" ], + "221086" : [ "18:06", "350000", "121146" ], + "221087" : [ "18:07", "350000", "121147" ], + "221088" : [ "18:08", "350000", "121148" ], + "221089" : [ "18:09", "350000", "121149" ], + "221090" : [ "18:10", "350000", "121150" ], + "221091" : [ "18:11", "350000", "121151" ], + "221092" : [ "18:12", "350000", "121152" ], + "221093" : [ "18:13", "350000", "121153" ], + "221094" : [ "18:14", "350000", "121154" ], + "221095" : [ "18:15", "350000", "121155" ], + "221096" : [ "18:16", "350000", "121156" ], + "221097" : [ "18:17", "350000", "121157" ], + "221098" : [ "18:18", "350000", "121158" ], + "221099" : [ "18:19", "350000", "121159" ], + "221100" : [ "18:20", "350000", "121160" ], + "221101" : [ "18:21", "350000", "121161" ], + "221102" : [ "18:22", "350000", "121162" ], + "221103" : [ "18:23", "350000", "121163" ], + "221104" : [ "18:24", "350000", "121164" ], + "221105" : [ "18:25", "350000", "121165" ], + "221106" : [ "18:26", "350000", "121166" ], + "221107" : [ "18:27", "350000", "121167" ], + "221108" : [ "18:28", "350000", "121168" ], + "221109" : [ "18:29", "350000", "121169" ], + "221110" : [ "18:30", "350000", "121170" ], + "221111" : [ "18:31", "350000", "121171" ], + "221112" : [ "18:32", "350000", "121172" ], + "221113" : [ "18:33", "350000", "121173" ], + "221114" : [ "18:34", "350000", "121174" ], + "221115" : [ "18:35", "350000", "121175" ], + "221116" : [ "18:36", "350000", "121176" ], + "221117" : [ "18:37", "350000", "121177" ], + "221118" : [ "18:38", "350000", "121178" ], + "221119" : [ "18:39", "350000", "121179" ], + "221120" : [ "18:40", "350000", "121180" ], + "221121" : [ "18:41", "350000", "121181" ], + "221122" : [ "18:42", "350000", "121182" ], + "221123" : [ "18:43", "350000", "121183" ], + "221124" : [ "18:44", "350000", "121184" ], + "221125" : [ "18:45", "350000", "121185" ], + "221126" : [ "18:46", "350000", "121186" ], + "221127" : [ "18:47", "350000", "121187" ], + "221128" : [ "18:48", "350000", "121188" ], + "221129" : [ "18:49", "350000", "121189" ], + "221130" : [ "18:50", "350000", "121190" ], + "221131" : [ "18:51", "350000", "121191" ], + "221132" : [ "18:52", "350000", "121192" ], + "221133" : [ "18:53", "350000", "121193" ], + "221134" : [ "18:54", "350000", "121194" ], + "221135" : [ "18:55", "350000", "121195" ], + "221136" : [ "18:56", "350000", "121196" ], + "221137" : [ "18:57", "350000", "121197" ], + "221138" : [ "18:58", "350000", "121198" ], + "221139" : [ "18:59", "350000", "121199" ], + "221140" : [ "19:00", "350000", "121200" ], + "221141" : [ "19:01", "350000", "121200" ], + "221142" : [ "19:02", "350000", "121200" ], + "221143" : [ "19:03", "350000", "121200" ], + "221144" : [ "19:04", "350000", "121200" ], + "221145" : [ "19:05", "350000", "121200" ], + "221146" : [ "19:06", "350000", "121200" ], + "221147" : [ "19:07", "350000", "121200" ], + "221148" : [ "19:08", "350000", "121200" ], + "221149" : [ "19:09", "350000", "121200" ], + "221150" : [ "19:10", "350000", "121200" ], + "221151" : [ "19:11", "350000", "121200" ], + "221152" : [ "19:12", "350000", "121200" ], + "221153" : [ "19:13", "350000", "121200" ], + "221154" : [ "19:14", "350000", "121200" ], + "221155" : [ "19:15", "350000", "121200" ], + "221156" : [ "19:16", "350000", "121200" ], + "221157" : [ "19:17", "350000", "121200" ], + "221158" : [ "19:18", "350000", "121200" ], + "221159" : [ "19:19", "350000", "121200" ], + "221160" : [ "19:20", "350000", "121200" ], + "221161" : [ "19:21", "350000", "121200" ], + "221162" : [ "19:22", "350000", "121200" ], + "221163" : [ "19:23", "350000", "121200" ], + "221164" : [ "19:24", "350000", "121200" ], + "221165" : [ "19:25", "350000", "121200" ], + "221166" : [ "19:26", "350000", "121200" ], + "221167" : [ "19:27", "350000", "121200" ], + "221168" : [ "19:28", "350000", "121200" ], + "221169" : [ "19:29", "350000", "121200" ], + "221170" : [ "19:30", "350000", "121200" ], + "221171" : [ "19:31", "350000", "121200" ], + "221172" : [ "19:32", "350000", "121200" ], + "221173" : [ "19:33", "350000", "121200" ], + "221174" : [ "19:34", "350000", "121200" ], + "221175" : [ "19:35", "350000", "121200" ], + "221176" : [ "19:36", "350000", "121200" ], + "221177" : [ "19:37", "350000", "121200" ], + "221178" : [ "19:38", "350000", "121200" ], + "221179" : [ "19:39", "350000", "121200" ], + "221180" : [ "19:40", "350000", "121200" ], + "221181" : [ "19:41", "350000", "121200" ], + "221182" : [ "19:42", "350000", "121200" ], + "221183" : [ "19:43", "350000", "121200" ], + "221184" : [ "19:44", "350000", "121200" ], + "221185" : [ "19:45", "350000", "121200" ], + "221186" : [ "19:46", "350000", "121200" ], + "221187" : [ "19:47", "350000", "121200" ], + "221188" : [ "19:48", "350000", "121200" ], + "221189" : [ "19:49", "350000", "121200" ], + "221190" : [ "19:50", "350000", "121200" ], + "221191" : [ "19:51", "350000", "121200" ], + "221192" : [ "19:52", "350000", "121200" ], + "221193" : [ "19:53", "350000", "121200" ], + "221194" : [ "19:54", "350000", "121200" ], + "221195" : [ "19:55", "350000", "121200" ], + "221196" : [ "19:56", "350000", "121200" ], + "221197" : [ "19:57", "350000", "121200" ], + "221198" : [ "19:58", "350000", "121200" ], + "221199" : [ "19:59", "350000", "121200" ], + "221200" : [ "20:00", "800000", "130420" ], + "221201" : [ "20:01", "800000", "130420" ], + "221202" : [ "20:02", "800000", "130420" ], + "221203" : [ "20:03", "800000", "130420" ], + "221204" : [ "20:04", "800000", "130420" ], + "221205" : [ "20:05", "800000", "130420" ], + "221206" : [ "20:06", "800000", "130420" ], + "221207" : [ "20:07", "800000", "130420" ], + "221208" : [ "20:08", "800000", "130420" ], + "221209" : [ "20:09", "800000", "130420" ], + "221210" : [ "20:10", "800000", "130420" ], + "221211" : [ "20:11", "800000", "130420" ], + "221212" : [ "20:12", "800000", "130420" ], + "221213" : [ "20:13", "800000", "130420" ], + "221214" : [ "20:14", "800000", "130420" ], + "221215" : [ "20:15", "800000", "130420" ], + "221216" : [ "20:16", "800000", "130420" ], + "221217" : [ "20:17", "800000", "130420" ], + "221218" : [ "20:18", "800000", "130420" ], + "221219" : [ "20:19", "800000", "130420" ], + "221220" : [ "20:20", "800000", "130420" ], + "221221" : [ "20:21", "800000", "130420" ], + "221222" : [ "20:22", "800000", "130420" ], + "221223" : [ "20:23", "800000", "130420" ], + "221224" : [ "20:24", "800000", "130420" ], + "221225" : [ "20:25", "800000", "130420" ], + "221226" : [ "20:26", "800000", "130420" ], + "221227" : [ "20:27", "800000", "130420" ], + "221228" : [ "20:28", "800000", "130420" ], + "221229" : [ "20:29", "800000", "130420" ], + "221230" : [ "20:30", "800000", "130420" ], + "221231" : [ "20:31", "800000", "130420" ], + "221232" : [ "20:32", "800000", "130420" ], + "221233" : [ "20:33", "800000", "130420" ], + "221234" : [ "20:34", "800000", "130420" ], + "221235" : [ "20:35", "800000", "130420" ], + "221236" : [ "20:36", "800000", "130420" ], + "221237" : [ "20:37", "800000", "130420" ], + "221238" : [ "20:38", "800000", "130420" ], + "221239" : [ "20:39", "800000", "130420" ], + "221240" : [ "20:40", "800000", "130420" ], + "221241" : [ "20:41", "800000", "130420" ], + "221242" : [ "20:42", "800000", "130420" ], + "221243" : [ "20:43", "800000", "130420" ], + "221244" : [ "20:44", "800000", "130420" ], + "221245" : [ "20:45", "800000", "130420" ], + "221246" : [ "20:46", "800000", "130420" ], + "221247" : [ "20:47", "800000", "130420" ], + "221248" : [ "20:48", "800000", "130420" ], + "221249" : [ "20:49", "800000", "130420" ], + "221250" : [ "20:50", "800000", "130420" ], + "221251" : [ "20:51", "800000", "130420" ], + "221252" : [ "20:52", "800000", "130420" ], + "221253" : [ "20:53", "800000", "130420" ], + "221254" : [ "20:54", "800000", "130420" ], + "221255" : [ "20:55", "800000", "130420" ], + "221256" : [ "20:56", "800000", "130420" ], + "221257" : [ "20:57", "800000", "130420" ], + "221258" : [ "20:58", "800000", "130420" ], + "221259" : [ "20:59", "800000", "130420" ], + "221260" : [ "21:00", "800000", "130420" ], + "221261" : [ "21:01", "800000", "130420" ], + "221262" : [ "21:02", "800000", "130420" ], + "221263" : [ "21:03", "800000", "130420" ], + "221264" : [ "21:04", "800000", "130420" ], + "221265" : [ "21:05", "800000", "130420" ], + "221266" : [ "21:06", "800000", "130420" ], + "221267" : [ "21:07", "800000", "130420" ], + "221268" : [ "21:08", "800000", "130420" ], + "221269" : [ "21:09", "800000", "130420" ], + "221270" : [ "21:10", "800000", "130420" ], + "221271" : [ "21:11", "800000", "130420" ], + "221272" : [ "21:12", "800000", "130420" ], + "221273" : [ "21:13", "800000", "130420" ], + "221274" : [ "21:14", "800000", "130420" ], + "221275" : [ "21:15", "800000", "130420" ], + "221276" : [ "21:16", "800000", "130420" ], + "221277" : [ "21:17", "800000", "130420" ], + "221278" : [ "21:18", "800000", "130420" ], + "221279" : [ "21:19", "800000", "130420" ], + "221280" : [ "21:20", "800000", "130420" ], + "221281" : [ "21:21", "800000", "130420" ], + "221282" : [ "21:22", "800000", "130420" ], + "221283" : [ "21:23", "800000", "130420" ], + "221284" : [ "21:24", "800000", "130420" ], + "221285" : [ "21:25", "800000", "130420" ], + "221286" : [ "21:26", "800000", "130420" ], + "221287" : [ "21:27", "800000", "130420" ], + "221288" : [ "21:28", "800000", "130420" ], + "221289" : [ "21:29", "800000", "130420" ], + "221290" : [ "21:30", "800000", "130420" ], + "221291" : [ "21:31", "800000", "130420" ], + "221292" : [ "21:32", "800000", "130420" ], + "221293" : [ "21:33", "800000", "130420" ], + "221294" : [ "21:34", "800000", "130420" ], + "221295" : [ "21:35", "800000", "130420" ], + "221296" : [ "21:36", "800000", "130420" ], + "221297" : [ "21:37", "800000", "130420" ], + "221298" : [ "21:38", "800000", "130420" ], + "221299" : [ "21:39", "800000", "130420" ], + "221300" : [ "21:40", "800000", "130420" ], + "221301" : [ "21:41", "800000", "130420" ], + "221302" : [ "21:42", "800000", "130420" ], + "221303" : [ "21:43", "800000", "130420" ], + "221304" : [ "21:44", "800000", "130420" ], + "221305" : [ "21:45", "800000", "130420" ], + "221306" : [ "21:46", "800000", "130420" ], + "221307" : [ "21:47", "800000", "130420" ], + "221308" : [ "21:48", "800000", "130420" ], + "221309" : [ "21:49", "800000", "130420" ], + "221310" : [ "21:50", "800000", "130420" ], + "221311" : [ "21:51", "800000", "130420" ], + "221312" : [ "21:52", "800000", "130420" ], + "221313" : [ "21:53", "800000", "130420" ], + "221314" : [ "21:54", "800000", "130420" ], + "221315" : [ "21:55", "800000", "130420" ], + "221316" : [ "21:56", "800000", "130420" ], + "221317" : [ "21:57", "800000", "130420" ], + "221318" : [ "21:58", "800000", "130420" ], + "221319" : [ "21:59", "800000", "130420" ], + "221320" : [ "22:00", "800000", "130420" ], + "221321" : [ "22:01", "800000", "130420" ], + "221322" : [ "22:02", "800000", "130420" ], + "221323" : [ "22:03", "800000", "130420" ], + "221324" : [ "22:04", "800000", "130420" ], + "221325" : [ "22:05", "800000", "130420" ], + "221326" : [ "22:06", "800000", "130420" ], + "221327" : [ "22:07", "800000", "130420" ], + "221328" : [ "22:08", "800000", "130420" ], + "221329" : [ "22:09", "800000", "130420" ], + "221330" : [ "22:10", "800000", "130420" ], + "221331" : [ "22:11", "800000", "130420" ], + "221332" : [ "22:12", "800000", "130420" ], + "221333" : [ "22:13", "800000", "130420" ], + "221334" : [ "22:14", "800000", "130420" ], + "221335" : [ "22:15", "800000", "130420" ], + "221336" : [ "22:16", "800000", "130420" ], + "221337" : [ "22:17", "800000", "130420" ], + "221338" : [ "22:18", "800000", "130420" ], + "221339" : [ "22:19", "800000", "130420" ], + "221340" : [ "22:20", "800000", "130420" ], + "221341" : [ "22:21", "800000", "130420" ], + "221342" : [ "22:22", "800000", "130420" ], + "221343" : [ "22:23", "800000", "130420" ], + "221344" : [ "22:24", "800000", "130420" ], + "221345" : [ "22:25", "800000", "130420" ], + "221346" : [ "22:26", "800000", "130420" ], + "221347" : [ "22:27", "800000", "130420" ], + "221348" : [ "22:28", "800000", "130420" ], + "221349" : [ "22:29", "800000", "130420" ], + "221350" : [ "22:30", "800000", "130420" ], + "221351" : [ "22:31", "800000", "130420" ], + "221352" : [ "22:32", "800000", "130420" ], + "221353" : [ "22:33", "800000", "130420" ], + "221354" : [ "22:34", "800000", "130420" ], + "221355" : [ "22:35", "800000", "130420" ], + "221356" : [ "22:36", "800000", "130420" ], + "221357" : [ "22:37", "800000", "130420" ], + "221358" : [ "22:38", "800000", "130420" ], + "221359" : [ "22:39", "800000", "130420" ], + "221360" : [ "22:40", "800000", "130420" ], + "221361" : [ "22:41", "800000", "130420" ], + "221362" : [ "22:42", "800000", "130420" ], + "221363" : [ "22:43", "800000", "130420" ], + "221364" : [ "22:44", "800000", "130420" ], + "221365" : [ "22:45", "800000", "130420" ], + "221366" : [ "22:46", "800000", "130420" ], + "221367" : [ "22:47", "800000", "130420" ], + "221368" : [ "22:48", "800000", "130420" ], + "221369" : [ "22:49", "800000", "130420" ], + "221370" : [ "22:50", "800000", "130420" ], + "221371" : [ "22:51", "800000", "130420" ], + "221372" : [ "22:52", "800000", "130420" ], + "221373" : [ "22:53", "800000", "130420" ], + "221374" : [ "22:54", "800000", "130420" ], + "221375" : [ "22:55", "800000", "130420" ], + "221376" : [ "22:56", "800000", "130420" ], + "221377" : [ "22:57", "800000", "130420" ], + "221378" : [ "22:58", "800000", "130420" ], + "221379" : [ "22:59", "800000", "130420" ], + "221380" : [ "23:00", "800000", "130420" ], + "221381" : [ "23:01", "800000", "130420" ], + "221382" : [ "23:02", "800000", "130420" ], + "221383" : [ "23:03", "800000", "130420" ], + "221384" : [ "23:04", "800000", "130420" ], + "221385" : [ "23:05", "800000", "130420" ], + "221386" : [ "23:06", "800000", "130420" ], + "221387" : [ "23:07", "800000", "130420" ], + "221388" : [ "23:08", "800000", "130420" ], + "221389" : [ "23:09", "800000", "130420" ], + "221390" : [ "23:10", "800000", "130420" ], + "221391" : [ "23:11", "800000", "130420" ], + "221392" : [ "23:12", "800000", "130420" ], + "221393" : [ "23:13", "800000", "130420" ], + "221394" : [ "23:14", "800000", "130420" ], + "221395" : [ "23:15", "800000", "130420" ], + "221396" : [ "23:16", "800000", "130420" ], + "221397" : [ "23:17", "800000", "130420" ], + "221398" : [ "23:18", "800000", "130420" ], + "221399" : [ "23:19", "800000", "130420" ], + "221400" : [ "23:20", "800000", "130420" ], + "221401" : [ "23:21", "800000", "130420" ], + "221402" : [ "23:22", "800000", "130420" ], + "221403" : [ "23:23", "800000", "130420" ], + "221404" : [ "23:24", "800000", "130420" ], + "221405" : [ "23:25", "800000", "130420" ], + "221406" : [ "23:26", "800000", "130420" ], + "221407" : [ "23:27", "800000", "130420" ], + "221408" : [ "23:28", "800000", "130420" ], + "221409" : [ "23:29", "800000", "130420" ], + "221410" : [ "23:30", "800000", "130420" ], + "221411" : [ "23:31", "800000", "130420" ], + "221412" : [ "23:32", "800000", "130420" ], + "221413" : [ "23:33", "800000", "130420" ], + "221414" : [ "23:34", "800000", "130420" ], + "221415" : [ "23:35", "800000", "130420" ], + "221416" : [ "23:36", "800000", "130420" ], + "221417" : [ "23:37", "800000", "130420" ], + "221418" : [ "23:38", "800000", "130420" ], + "221419" : [ "23:39", "800000", "130420" ], + "221420" : [ "23:40", "800000", "130420" ], + "221421" : [ "23:41", "800000", "130420" ], + "221422" : [ "23:42", "800000", "130420" ], + "221423" : [ "23:43", "800000", "130420" ], + "221424" : [ "23:44", "800000", "130420" ], + "221425" : [ "23:45", "800000", "130420" ], + "221426" : [ "23:46", "800000", "130420" ], + "221427" : [ "23:47", "800000", "130420" ], + "221428" : [ "23:48", "800000", "130420" ], + "221429" : [ "23:49", "800000", "130420" ], + "221430" : [ "23:50", "800000", "130420" ], + "221431" : [ "23:51", "800000", "130420" ], + "221432" : [ "23:52", "800000", "130420" ], + "221433" : [ "23:53", "800000", "130420" ], + "221434" : [ "23:54", "800000", "130420" ], + "221435" : [ "23:55", "800000", "130420" ], + "221436" : [ "23:56", "800000", "130420" ], + "221437" : [ "23:57", "800000", "130420" ], + "221438" : [ "23:58", "800000", "130420" ], + "221439" : [ "23:59", "800000", "130420" ] + }, + "Thursday": { + "230000" : [ "00:00", "800000", "130420" ], + "230001" : [ "00:01", "800000", "130420" ], + "230002" : [ "00:02", "800000", "130420" ], + "230003" : [ "00:03", "800000", "130420" ], + "230004" : [ "00:04", "800000", "130420" ], + "230005" : [ "00:05", "800000", "130420" ], + "230006" : [ "00:06", "800000", "130420" ], + "230007" : [ "00:07", "800000", "130420" ], + "230008" : [ "00:08", "800000", "130420" ], + "230009" : [ "00:09", "800000", "130420" ], + "230010" : [ "00:10", "800000", "130420" ], + "230011" : [ "00:11", "800000", "130420" ], + "230012" : [ "00:12", "800000", "130420" ], + "230013" : [ "00:13", "800000", "130420" ], + "230014" : [ "00:14", "800000", "130420" ], + "230015" : [ "00:15", "800000", "130420" ], + "230016" : [ "00:16", "800000", "130420" ], + "230017" : [ "00:17", "800000", "130420" ], + "230018" : [ "00:18", "800000", "130420" ], + "230019" : [ "00:19", "800000", "130420" ], + "230020" : [ "00:20", "800000", "130420" ], + "230021" : [ "00:21", "800000", "130420" ], + "230022" : [ "00:22", "800000", "130420" ], + "230023" : [ "00:23", "800000", "130420" ], + "230024" : [ "00:24", "800000", "130420" ], + "230025" : [ "00:25", "800000", "130420" ], + "230026" : [ "00:26", "800000", "130420" ], + "230027" : [ "00:27", "800000", "130420" ], + "230028" : [ "00:28", "800000", "130420" ], + "230029" : [ "00:29", "800000", "130420" ], + "230030" : [ "00:30", "800000", "130420" ], + "230031" : [ "00:31", "800000", "130420" ], + "230032" : [ "00:32", "800000", "130420" ], + "230033" : [ "00:33", "800000", "130420" ], + "230034" : [ "00:34", "800000", "130420" ], + "230035" : [ "00:35", "800000", "130420" ], + "230036" : [ "00:36", "800000", "130420" ], + "230037" : [ "00:37", "800000", "130420" ], + "230038" : [ "00:38", "800000", "130420" ], + "230039" : [ "00:39", "800000", "130420" ], + "230040" : [ "00:40", "800000", "130420" ], + "230041" : [ "00:41", "800000", "130420" ], + "230042" : [ "00:42", "800000", "130420" ], + "230043" : [ "00:43", "800000", "130420" ], + "230044" : [ "00:44", "800000", "130420" ], + "230045" : [ "00:45", "800000", "130420" ], + "230046" : [ "00:46", "800000", "130420" ], + "230047" : [ "00:47", "800000", "130420" ], + "230048" : [ "00:48", "800000", "130420" ], + "230049" : [ "00:49", "800000", "130420" ], + "230050" : [ "00:50", "800000", "130420" ], + "230051" : [ "00:51", "800000", "130420" ], + "230052" : [ "00:52", "800000", "130420" ], + "230053" : [ "00:53", "800000", "130420" ], + "230054" : [ "00:54", "800000", "130420" ], + "230055" : [ "00:55", "800000", "130420" ], + "230056" : [ "00:56", "800000", "130420" ], + "230057" : [ "00:57", "800000", "130420" ], + "230058" : [ "00:58", "800000", "130420" ], + "230059" : [ "00:59", "800000", "130420" ], + "230060" : [ "01:00", "800000", "130420" ], + "230061" : [ "01:01", "800000", "130420" ], + "230062" : [ "01:02", "800000", "130420" ], + "230063" : [ "01:03", "800000", "130420" ], + "230064" : [ "01:04", "800000", "130420" ], + "230065" : [ "01:05", "800000", "130420" ], + "230066" : [ "01:06", "800000", "130420" ], + "230067" : [ "01:07", "800000", "130420" ], + "230068" : [ "01:08", "800000", "130420" ], + "230069" : [ "01:09", "800000", "130420" ], + "230070" : [ "01:10", "800000", "130420" ], + "230071" : [ "01:11", "800000", "130420" ], + "230072" : [ "01:12", "800000", "130420" ], + "230073" : [ "01:13", "800000", "130420" ], + "230074" : [ "01:14", "800000", "130420" ], + "230075" : [ "01:15", "800000", "130420" ], + "230076" : [ "01:16", "800000", "130420" ], + "230077" : [ "01:17", "800000", "130420" ], + "230078" : [ "01:18", "800000", "130420" ], + "230079" : [ "01:19", "800000", "130420" ], + "230080" : [ "01:20", "800000", "130420" ], + "230081" : [ "01:21", "800000", "130420" ], + "230082" : [ "01:22", "800000", "130420" ], + "230083" : [ "01:23", "800000", "130420" ], + "230084" : [ "01:24", "800000", "130420" ], + "230085" : [ "01:25", "800000", "130420" ], + "230086" : [ "01:26", "800000", "130420" ], + "230087" : [ "01:27", "800000", "130420" ], + "230088" : [ "01:28", "800000", "130420" ], + "230089" : [ "01:29", "800000", "130420" ], + "230090" : [ "01:30", "800000", "130420" ], + "230091" : [ "01:31", "800000", "130420" ], + "230092" : [ "01:32", "800000", "130420" ], + "230093" : [ "01:33", "800000", "130420" ], + "230094" : [ "01:34", "800000", "130420" ], + "230095" : [ "01:35", "800000", "130420" ], + "230096" : [ "01:36", "800000", "130420" ], + "230097" : [ "01:37", "800000", "130420" ], + "230098" : [ "01:38", "800000", "130420" ], + "230099" : [ "01:39", "800000", "130420" ], + "230100" : [ "01:40", "800000", "130420" ], + "230101" : [ "01:41", "800000", "130420" ], + "230102" : [ "01:42", "800000", "130420" ], + "230103" : [ "01:43", "800000", "130420" ], + "230104" : [ "01:44", "800000", "130420" ], + "230105" : [ "01:45", "800000", "130420" ], + "230106" : [ "01:46", "800000", "130420" ], + "230107" : [ "01:47", "800000", "130420" ], + "230108" : [ "01:48", "800000", "130420" ], + "230109" : [ "01:49", "800000", "130420" ], + "230110" : [ "01:50", "800000", "130420" ], + "230111" : [ "01:51", "800000", "130420" ], + "230112" : [ "01:52", "800000", "130420" ], + "230113" : [ "01:53", "800000", "130420" ], + "230114" : [ "01:54", "800000", "130420" ], + "230115" : [ "01:55", "800000", "130420" ], + "230116" : [ "01:56", "800000", "130420" ], + "230117" : [ "01:57", "800000", "130420" ], + "230118" : [ "01:58", "800000", "130420" ], + "230119" : [ "01:59", "800000", "130420" ], + "230120" : [ "02:00", "800000", "130420" ], + "230121" : [ "02:01", "800000", "130420" ], + "230122" : [ "02:02", "800000", "130420" ], + "230123" : [ "02:03", "800000", "130420" ], + "230124" : [ "02:04", "800000", "130420" ], + "230125" : [ "02:05", "800000", "130420" ], + "230126" : [ "02:06", "800000", "130420" ], + "230127" : [ "02:07", "800000", "130420" ], + "230128" : [ "02:08", "800000", "130420" ], + "230129" : [ "02:09", "800000", "130420" ], + "230130" : [ "02:10", "800000", "130420" ], + "230131" : [ "02:11", "800000", "130420" ], + "230132" : [ "02:12", "800000", "130420" ], + "230133" : [ "02:13", "800000", "130420" ], + "230134" : [ "02:14", "800000", "130420" ], + "230135" : [ "02:15", "800000", "130420" ], + "230136" : [ "02:16", "800000", "130420" ], + "230137" : [ "02:17", "800000", "130420" ], + "230138" : [ "02:18", "800000", "130420" ], + "230139" : [ "02:19", "800000", "130420" ], + "230140" : [ "02:20", "800000", "130420" ], + "230141" : [ "02:21", "800000", "130420" ], + "230142" : [ "02:22", "800000", "130420" ], + "230143" : [ "02:23", "800000", "130420" ], + "230144" : [ "02:24", "800000", "130420" ], + "230145" : [ "02:25", "800000", "130420" ], + "230146" : [ "02:26", "800000", "130420" ], + "230147" : [ "02:27", "800000", "130420" ], + "230148" : [ "02:28", "800000", "130420" ], + "230149" : [ "02:29", "800000", "130420" ], + "230150" : [ "02:30", "800000", "130420" ], + "230151" : [ "02:31", "800000", "130420" ], + "230152" : [ "02:32", "800000", "130420" ], + "230153" : [ "02:33", "800000", "130420" ], + "230154" : [ "02:34", "800000", "130420" ], + "230155" : [ "02:35", "800000", "130420" ], + "230156" : [ "02:36", "800000", "130420" ], + "230157" : [ "02:37", "800000", "130420" ], + "230158" : [ "02:38", "800000", "130420" ], + "230159" : [ "02:39", "800000", "130420" ], + "230160" : [ "02:40", "800000", "130420" ], + "230161" : [ "02:41", "800000", "130420" ], + "230162" : [ "02:42", "800000", "130420" ], + "230163" : [ "02:43", "800000", "130420" ], + "230164" : [ "02:44", "800000", "130420" ], + "230165" : [ "02:45", "800000", "130420" ], + "230166" : [ "02:46", "800000", "130420" ], + "230167" : [ "02:47", "800000", "130420" ], + "230168" : [ "02:48", "800000", "130420" ], + "230169" : [ "02:49", "800000", "130420" ], + "230170" : [ "02:50", "800000", "130420" ], + "230171" : [ "02:51", "800000", "130420" ], + "230172" : [ "02:52", "800000", "130420" ], + "230173" : [ "02:53", "800000", "130420" ], + "230174" : [ "02:54", "800000", "130420" ], + "230175" : [ "02:55", "800000", "130420" ], + "230176" : [ "02:56", "800000", "130420" ], + "230177" : [ "02:57", "800000", "130420" ], + "230178" : [ "02:58", "800000", "130420" ], + "230179" : [ "02:59", "800000", "130420" ], + "230180" : [ "03:00", "800000", "130420" ], + "230181" : [ "03:01", "800000", "130420" ], + "230182" : [ "03:02", "800000", "130420" ], + "230183" : [ "03:03", "800000", "130420" ], + "230184" : [ "03:04", "800000", "130420" ], + "230185" : [ "03:05", "800000", "130420" ], + "230186" : [ "03:06", "800000", "130420" ], + "230187" : [ "03:07", "800000", "130420" ], + "230188" : [ "03:08", "800000", "130420" ], + "230189" : [ "03:09", "800000", "130420" ], + "230190" : [ "03:10", "800000", "130420" ], + "230191" : [ "03:11", "800000", "130420" ], + "230192" : [ "03:12", "800000", "130420" ], + "230193" : [ "03:13", "800000", "130420" ], + "230194" : [ "03:14", "800000", "130420" ], + "230195" : [ "03:15", "800000", "130420" ], + "230196" : [ "03:16", "800000", "130420" ], + "230197" : [ "03:17", "800000", "130420" ], + "230198" : [ "03:18", "800000", "130420" ], + "230199" : [ "03:19", "800000", "130420" ], + "230200" : [ "03:20", "800000", "130420" ], + "230201" : [ "03:21", "800000", "130420" ], + "230202" : [ "03:22", "800000", "130420" ], + "230203" : [ "03:23", "800000", "130420" ], + "230204" : [ "03:24", "800000", "130420" ], + "230205" : [ "03:25", "800000", "130420" ], + "230206" : [ "03:26", "800000", "130420" ], + "230207" : [ "03:27", "800000", "130420" ], + "230208" : [ "03:28", "800000", "130420" ], + "230209" : [ "03:29", "800000", "130420" ], + "230210" : [ "03:30", "800000", "130420" ], + "230211" : [ "03:31", "800000", "130420" ], + "230212" : [ "03:32", "800000", "130420" ], + "230213" : [ "03:33", "800000", "130420" ], + "230214" : [ "03:34", "800000", "130420" ], + "230215" : [ "03:35", "800000", "130420" ], + "230216" : [ "03:36", "800000", "130420" ], + "230217" : [ "03:37", "800000", "130420" ], + "230218" : [ "03:38", "800000", "130420" ], + "230219" : [ "03:39", "800000", "130420" ], + "230220" : [ "03:40", "800000", "130420" ], + "230221" : [ "03:41", "800000", "130420" ], + "230222" : [ "03:42", "800000", "130420" ], + "230223" : [ "03:43", "800000", "130420" ], + "230224" : [ "03:44", "800000", "130420" ], + "230225" : [ "03:45", "800000", "130420" ], + "230226" : [ "03:46", "800000", "130420" ], + "230227" : [ "03:47", "800000", "130420" ], + "230228" : [ "03:48", "800000", "130420" ], + "230229" : [ "03:49", "800000", "130420" ], + "230230" : [ "03:50", "800000", "130420" ], + "230231" : [ "03:51", "800000", "130420" ], + "230232" : [ "03:52", "800000", "130420" ], + "230233" : [ "03:53", "800000", "130420" ], + "230234" : [ "03:54", "800000", "130420" ], + "230235" : [ "03:55", "800000", "130420" ], + "230236" : [ "03:56", "800000", "130420" ], + "230237" : [ "03:57", "800000", "130420" ], + "230238" : [ "03:58", "800000", "130420" ], + "230239" : [ "03:59", "800000", "130420" ], + "230240" : [ "04:00", "800000", "130420" ], + "230241" : [ "04:01", "800000", "130420" ], + "230242" : [ "04:02", "800000", "130420" ], + "230243" : [ "04:03", "800000", "130420" ], + "230244" : [ "04:04", "800000", "130420" ], + "230245" : [ "04:05", "800000", "130420" ], + "230246" : [ "04:06", "800000", "130420" ], + "230247" : [ "04:07", "800000", "130420" ], + "230248" : [ "04:08", "800000", "130420" ], + "230249" : [ "04:09", "800000", "130420" ], + "230250" : [ "04:10", "800000", "130420" ], + "230251" : [ "04:11", "800000", "130420" ], + "230252" : [ "04:12", "800000", "130420" ], + "230253" : [ "04:13", "800000", "130420" ], + "230254" : [ "04:14", "800000", "130420" ], + "230255" : [ "04:15", "800000", "130420" ], + "230256" : [ "04:16", "800000", "130420" ], + "230257" : [ "04:17", "800000", "130420" ], + "230258" : [ "04:18", "800000", "130420" ], + "230259" : [ "04:19", "800000", "130420" ], + "230260" : [ "04:20", "800000", "130420" ], + "230261" : [ "04:21", "800000", "130420" ], + "230262" : [ "04:22", "800000", "130420" ], + "230263" : [ "04:23", "800000", "130420" ], + "230264" : [ "04:24", "800000", "130420" ], + "230265" : [ "04:25", "800000", "130420" ], + "230266" : [ "04:26", "800000", "130420" ], + "230267" : [ "04:27", "800000", "130420" ], + "230268" : [ "04:28", "800000", "130420" ], + "230269" : [ "04:29", "800000", "130420" ], + "230270" : [ "04:30", "800000", "130420" ], + "230271" : [ "04:31", "800000", "130420" ], + "230272" : [ "04:32", "800000", "130420" ], + "230273" : [ "04:33", "800000", "130420" ], + "230274" : [ "04:34", "800000", "130420" ], + "230275" : [ "04:35", "800000", "130420" ], + "230276" : [ "04:36", "800000", "130420" ], + "230277" : [ "04:37", "800000", "130420" ], + "230278" : [ "04:38", "800000", "130420" ], + "230279" : [ "04:39", "800000", "130420" ], + "230280" : [ "04:40", "800000", "130420" ], + "230281" : [ "04:41", "800000", "130420" ], + "230282" : [ "04:42", "800000", "130420" ], + "230283" : [ "04:43", "800000", "130420" ], + "230284" : [ "04:44", "800000", "130420" ], + "230285" : [ "04:45", "800000", "130420" ], + "230286" : [ "04:46", "800000", "130420" ], + "230287" : [ "04:47", "800000", "130420" ], + "230288" : [ "04:48", "800000", "130420" ], + "230289" : [ "04:49", "800000", "130420" ], + "230290" : [ "04:50", "800000", "130420" ], + "230291" : [ "04:51", "800000", "130420" ], + "230292" : [ "04:52", "800000", "130420" ], + "230293" : [ "04:53", "800000", "130420" ], + "230294" : [ "04:54", "800000", "130420" ], + "230295" : [ "04:55", "800000", "130420" ], + "230296" : [ "04:56", "800000", "130420" ], + "230297" : [ "04:57", "800000", "130420" ], + "230298" : [ "04:58", "800000", "130420" ], + "230299" : [ "04:59", "800000", "130420" ], + "230300" : [ "05:00", "800000", "130420" ], + "230301" : [ "05:01", "800000", "130420" ], + "230302" : [ "05:02", "800000", "130420" ], + "230303" : [ "05:03", "800000", "130420" ], + "230304" : [ "05:04", "800000", "130420" ], + "230305" : [ "05:05", "800000", "130420" ], + "230306" : [ "05:06", "800000", "130420" ], + "230307" : [ "05:07", "800000", "130420" ], + "230308" : [ "05:08", "800000", "130420" ], + "230309" : [ "05:09", "800000", "130420" ], + "230310" : [ "05:10", "800000", "130420" ], + "230311" : [ "05:11", "800000", "130420" ], + "230312" : [ "05:12", "800000", "130420" ], + "230313" : [ "05:13", "800000", "130420" ], + "230314" : [ "05:14", "800000", "130420" ], + "230315" : [ "05:15", "800000", "130420" ], + "230316" : [ "05:16", "800000", "130420" ], + "230317" : [ "05:17", "800000", "130420" ], + "230318" : [ "05:18", "800000", "130420" ], + "230319" : [ "05:19", "800000", "130420" ], + "230320" : [ "05:20", "800000", "130420" ], + "230321" : [ "05:21", "800000", "130420" ], + "230322" : [ "05:22", "800000", "130420" ], + "230323" : [ "05:23", "800000", "130420" ], + "230324" : [ "05:24", "800000", "130420" ], + "230325" : [ "05:25", "800000", "130420" ], + "230326" : [ "05:26", "800000", "130420" ], + "230327" : [ "05:27", "800000", "130420" ], + "230328" : [ "05:28", "800000", "130420" ], + "230329" : [ "05:29", "800000", "130420" ], + "230330" : [ "05:30", "800000", "130420" ], + "230331" : [ "05:31", "800000", "130420" ], + "230332" : [ "05:32", "800000", "130420" ], + "230333" : [ "05:33", "800000", "130420" ], + "230334" : [ "05:34", "800000", "130420" ], + "230335" : [ "05:35", "800000", "130420" ], + "230336" : [ "05:36", "800000", "130420" ], + "230337" : [ "05:37", "800000", "130420" ], + "230338" : [ "05:38", "800000", "130420" ], + "230339" : [ "05:39", "800000", "130420" ], + "230340" : [ "05:40", "800000", "130420" ], + "230341" : [ "05:41", "800000", "130420" ], + "230342" : [ "05:42", "800000", "130420" ], + "230343" : [ "05:43", "800000", "130420" ], + "230344" : [ "05:44", "800000", "130420" ], + "230345" : [ "05:45", "800000", "130420" ], + "230346" : [ "05:46", "800000", "130420" ], + "230347" : [ "05:47", "800000", "130420" ], + "230348" : [ "05:48", "800000", "130420" ], + "230349" : [ "05:49", "800000", "130420" ], + "230350" : [ "05:50", "800000", "130420" ], + "230351" : [ "05:51", "800000", "130420" ], + "230352" : [ "05:52", "800000", "130420" ], + "230353" : [ "05:53", "800000", "130420" ], + "230354" : [ "05:54", "800000", "130420" ], + "230355" : [ "05:55", "800000", "130420" ], + "230356" : [ "05:56", "800000", "130420" ], + "230357" : [ "05:57", "800000", "130420" ], + "230358" : [ "05:58", "800000", "130420" ], + "230359" : [ "05:59", "800000", "130420" ], + "230360" : [ "06:00", "800000", "130420" ], + "230361" : [ "06:01", "800000", "130420" ], + "230362" : [ "06:02", "800000", "130420" ], + "230363" : [ "06:03", "800000", "130420" ], + "230364" : [ "06:04", "800000", "130420" ], + "230365" : [ "06:05", "800000", "130420" ], + "230366" : [ "06:06", "800000", "130420" ], + "230367" : [ "06:07", "800000", "130420" ], + "230368" : [ "06:08", "800000", "130420" ], + "230369" : [ "06:09", "800000", "130420" ], + "230370" : [ "06:10", "800000", "130420" ], + "230371" : [ "06:11", "800000", "130420" ], + "230372" : [ "06:12", "800000", "130420" ], + "230373" : [ "06:13", "800000", "130420" ], + "230374" : [ "06:14", "800000", "130420" ], + "230375" : [ "06:15", "800000", "130420" ], + "230376" : [ "06:16", "800000", "130420" ], + "230377" : [ "06:17", "800000", "130420" ], + "230378" : [ "06:18", "800000", "130420" ], + "230379" : [ "06:19", "800000", "130420" ], + "230380" : [ "06:20", "800000", "130420" ], + "230381" : [ "06:21", "800000", "130420" ], + "230382" : [ "06:22", "800000", "130420" ], + "230383" : [ "06:23", "800000", "130420" ], + "230384" : [ "06:24", "800000", "130420" ], + "230385" : [ "06:25", "800000", "130420" ], + "230386" : [ "06:26", "800000", "130420" ], + "230387" : [ "06:27", "800000", "130420" ], + "230388" : [ "06:28", "800000", "130420" ], + "230389" : [ "06:29", "800000", "130420" ], + "230390" : [ "06:30", "800000", "130420" ], + "230391" : [ "06:31", "800000", "130420" ], + "230392" : [ "06:32", "800000", "130420" ], + "230393" : [ "06:33", "800000", "130420" ], + "230394" : [ "06:34", "800000", "130420" ], + "230395" : [ "06:35", "800000", "130420" ], + "230396" : [ "06:36", "800000", "130420" ], + "230397" : [ "06:37", "800000", "130420" ], + "230398" : [ "06:38", "800000", "130420" ], + "230399" : [ "06:39", "800000", "130420" ], + "230400" : [ "06:40", "800000", "130420" ], + "230401" : [ "06:41", "800000", "130420" ], + "230402" : [ "06:42", "800000", "130420" ], + "230403" : [ "06:43", "800000", "130420" ], + "230404" : [ "06:44", "800000", "130420" ], + "230405" : [ "06:45", "800000", "130420" ], + "230406" : [ "06:46", "800000", "130420" ], + "230407" : [ "06:47", "800000", "130420" ], + "230408" : [ "06:48", "800000", "130420" ], + "230409" : [ "06:49", "800000", "130420" ], + "230410" : [ "06:50", "800000", "130420" ], + "230411" : [ "06:51", "800000", "130420" ], + "230412" : [ "06:52", "800000", "130420" ], + "230413" : [ "06:53", "800000", "130420" ], + "230414" : [ "06:54", "800000", "130420" ], + "230415" : [ "06:55", "800000", "130420" ], + "230416" : [ "06:56", "800000", "130420" ], + "230417" : [ "06:57", "800000", "130420" ], + "230418" : [ "06:58", "800000", "130420" ], + "230419" : [ "06:59", "800000", "130420" ], + "230420" : [ "07:00", "350000", "130480" ], + "230421" : [ "07:01", "350000", "130481" ], + "230422" : [ "07:02", "350000", "130482" ], + "230423" : [ "07:03", "350000", "130483" ], + "230424" : [ "07:04", "350000", "130484" ], + "230425" : [ "07:05", "350000", "130485" ], + "230426" : [ "07:06", "350000", "130486" ], + "230427" : [ "07:07", "350000", "130487" ], + "230428" : [ "07:08", "350000", "130488" ], + "230429" : [ "07:09", "350000", "130489" ], + "230430" : [ "07:10", "350000", "130490" ], + "230431" : [ "07:11", "350000", "130491" ], + "230432" : [ "07:12", "350000", "130492" ], + "230433" : [ "07:13", "350000", "130493" ], + "230434" : [ "07:14", "350000", "130494" ], + "230435" : [ "07:15", "350000", "130495" ], + "230436" : [ "07:16", "350000", "130496" ], + "230437" : [ "07:17", "350000", "130497" ], + "230438" : [ "07:18", "350000", "130498" ], + "230439" : [ "07:19", "350000", "130499" ], + "230440" : [ "07:20", "350000", "130500" ], + "230441" : [ "07:21", "350000", "130501" ], + "230442" : [ "07:22", "350000", "130502" ], + "230443" : [ "07:23", "350000", "130503" ], + "230444" : [ "07:24", "350000", "130504" ], + "230445" : [ "07:25", "350000", "130505" ], + "230446" : [ "07:26", "350000", "130506" ], + "230447" : [ "07:27", "350000", "130507" ], + "230448" : [ "07:28", "350000", "130508" ], + "230449" : [ "07:29", "350000", "130509" ], + "230450" : [ "07:30", "350000", "130510" ], + "230451" : [ "07:31", "350000", "130511" ], + "230452" : [ "07:32", "350000", "130512" ], + "230453" : [ "07:33", "350000", "130513" ], + "230454" : [ "07:34", "350000", "130514" ], + "230455" : [ "07:35", "350000", "130515" ], + "230456" : [ "07:36", "350000", "130516" ], + "230457" : [ "07:37", "350000", "130517" ], + "230458" : [ "07:38", "350000", "130518" ], + "230459" : [ "07:39", "350000", "130519" ], + "230460" : [ "07:40", "350000", "130520" ], + "230461" : [ "07:41", "350000", "130521" ], + "230462" : [ "07:42", "350000", "130522" ], + "230463" : [ "07:43", "350000", "130523" ], + "230464" : [ "07:44", "350000", "130524" ], + "230465" : [ "07:45", "350000", "130525" ], + "230466" : [ "07:46", "350000", "130526" ], + "230467" : [ "07:47", "350000", "130527" ], + "230468" : [ "07:48", "350000", "130528" ], + "230469" : [ "07:49", "350000", "130529" ], + "230470" : [ "07:50", "350000", "130530" ], + "230471" : [ "07:51", "350000", "130531" ], + "230472" : [ "07:52", "350000", "130532" ], + "230473" : [ "07:53", "350000", "130533" ], + "230474" : [ "07:54", "350000", "130534" ], + "230475" : [ "07:55", "350000", "130535" ], + "230476" : [ "07:56", "350000", "130536" ], + "230477" : [ "07:57", "350000", "130537" ], + "230478" : [ "07:58", "350000", "130538" ], + "230479" : [ "07:59", "350000", "130539" ], + "230480" : [ "08:00", "350000", "130540" ], + "230481" : [ "08:01", "350000", "130541" ], + "230482" : [ "08:02", "350000", "130542" ], + "230483" : [ "08:03", "350000", "130543" ], + "230484" : [ "08:04", "350000", "130544" ], + "230485" : [ "08:05", "350000", "130545" ], + "230486" : [ "08:06", "350000", "130546" ], + "230487" : [ "08:07", "350000", "130547" ], + "230488" : [ "08:08", "350000", "130548" ], + "230489" : [ "08:09", "350000", "130549" ], + "230490" : [ "08:10", "350000", "130550" ], + "230491" : [ "08:11", "350000", "130551" ], + "230492" : [ "08:12", "350000", "130552" ], + "230493" : [ "08:13", "350000", "130553" ], + "230494" : [ "08:14", "350000", "130554" ], + "230495" : [ "08:15", "350000", "130555" ], + "230496" : [ "08:16", "350000", "130556" ], + "230497" : [ "08:17", "350000", "130557" ], + "230498" : [ "08:18", "350000", "130558" ], + "230499" : [ "08:19", "350000", "130559" ], + "230500" : [ "08:20", "350000", "130560" ], + "230501" : [ "08:21", "350000", "130561" ], + "230502" : [ "08:22", "350000", "130562" ], + "230503" : [ "08:23", "350000", "130563" ], + "230504" : [ "08:24", "350000", "130564" ], + "230505" : [ "08:25", "350000", "130565" ], + "230506" : [ "08:26", "350000", "130566" ], + "230507" : [ "08:27", "350000", "130567" ], + "230508" : [ "08:28", "350000", "130568" ], + "230509" : [ "08:29", "350000", "130569" ], + "230510" : [ "08:30", "350000", "130570" ], + "230511" : [ "08:31", "350000", "130571" ], + "230512" : [ "08:32", "350000", "130572" ], + "230513" : [ "08:33", "350000", "130573" ], + "230514" : [ "08:34", "350000", "130574" ], + "230515" : [ "08:35", "350000", "130575" ], + "230516" : [ "08:36", "350000", "130576" ], + "230517" : [ "08:37", "350000", "130577" ], + "230518" : [ "08:38", "350000", "130578" ], + "230519" : [ "08:39", "350000", "130579" ], + "230520" : [ "08:40", "350000", "130580" ], + "230521" : [ "08:41", "350000", "130581" ], + "230522" : [ "08:42", "350000", "130582" ], + "230523" : [ "08:43", "350000", "130583" ], + "230524" : [ "08:44", "350000", "130584" ], + "230525" : [ "08:45", "350000", "130585" ], + "230526" : [ "08:46", "350000", "130586" ], + "230527" : [ "08:47", "350000", "130587" ], + "230528" : [ "08:48", "350000", "130588" ], + "230529" : [ "08:49", "350000", "130589" ], + "230530" : [ "08:50", "350000", "130590" ], + "230531" : [ "08:51", "350000", "130591" ], + "230532" : [ "08:52", "350000", "130592" ], + "230533" : [ "08:53", "350000", "130593" ], + "230534" : [ "08:54", "350000", "130594" ], + "230535" : [ "08:55", "350000", "130595" ], + "230536" : [ "08:56", "350000", "130596" ], + "230537" : [ "08:57", "350000", "130597" ], + "230538" : [ "08:58", "350000", "130598" ], + "230539" : [ "08:59", "350000", "130599" ], + "230540" : [ "09:00", "350000", "130600" ], + "230541" : [ "09:01", "350000", "130601" ], + "230542" : [ "09:02", "350000", "130602" ], + "230543" : [ "09:03", "350000", "130603" ], + "230544" : [ "09:04", "350000", "130604" ], + "230545" : [ "09:05", "350000", "130605" ], + "230546" : [ "09:06", "350000", "130606" ], + "230547" : [ "09:07", "350000", "130607" ], + "230548" : [ "09:08", "350000", "130608" ], + "230549" : [ "09:09", "350000", "130609" ], + "230550" : [ "09:10", "350000", "130610" ], + "230551" : [ "09:11", "350000", "130611" ], + "230552" : [ "09:12", "350000", "130612" ], + "230553" : [ "09:13", "350000", "130613" ], + "230554" : [ "09:14", "350000", "130614" ], + "230555" : [ "09:15", "350000", "130615" ], + "230556" : [ "09:16", "350000", "130616" ], + "230557" : [ "09:17", "350000", "130617" ], + "230558" : [ "09:18", "350000", "130618" ], + "230559" : [ "09:19", "350000", "130619" ], + "230560" : [ "09:20", "350000", "130620" ], + "230561" : [ "09:21", "350000", "130621" ], + "230562" : [ "09:22", "350000", "130622" ], + "230563" : [ "09:23", "350000", "130623" ], + "230564" : [ "09:24", "350000", "130624" ], + "230565" : [ "09:25", "350000", "130625" ], + "230566" : [ "09:26", "350000", "130626" ], + "230567" : [ "09:27", "350000", "130627" ], + "230568" : [ "09:28", "350000", "130628" ], + "230569" : [ "09:29", "350000", "130629" ], + "230570" : [ "09:30", "350000", "130630" ], + "230571" : [ "09:31", "350000", "130631" ], + "230572" : [ "09:32", "350000", "130632" ], + "230573" : [ "09:33", "350000", "130633" ], + "230574" : [ "09:34", "350000", "130634" ], + "230575" : [ "09:35", "350000", "130635" ], + "230576" : [ "09:36", "350000", "130636" ], + "230577" : [ "09:37", "350000", "130637" ], + "230578" : [ "09:38", "350000", "130638" ], + "230579" : [ "09:39", "350000", "130639" ], + "230580" : [ "09:40", "350000", "130640" ], + "230581" : [ "09:41", "350000", "130641" ], + "230582" : [ "09:42", "350000", "130642" ], + "230583" : [ "09:43", "350000", "130643" ], + "230584" : [ "09:44", "350000", "130644" ], + "230585" : [ "09:45", "350000", "130645" ], + "230586" : [ "09:46", "350000", "130646" ], + "230587" : [ "09:47", "350000", "130647" ], + "230588" : [ "09:48", "350000", "130648" ], + "230589" : [ "09:49", "350000", "130649" ], + "230590" : [ "09:50", "350000", "130650" ], + "230591" : [ "09:51", "350000", "130651" ], + "230592" : [ "09:52", "350000", "130652" ], + "230593" : [ "09:53", "350000", "130653" ], + "230594" : [ "09:54", "350000", "130654" ], + "230595" : [ "09:55", "350000", "130655" ], + "230596" : [ "09:56", "350000", "130656" ], + "230597" : [ "09:57", "350000", "130657" ], + "230598" : [ "09:58", "350000", "130658" ], + "230599" : [ "09:59", "350000", "130659" ], + "230600" : [ "10:00", "350000", "130660" ], + "230601" : [ "10:01", "350000", "130661" ], + "230602" : [ "10:02", "350000", "130662" ], + "230603" : [ "10:03", "350000", "130663" ], + "230604" : [ "10:04", "350000", "130664" ], + "230605" : [ "10:05", "350000", "130665" ], + "230606" : [ "10:06", "350000", "130666" ], + "230607" : [ "10:07", "350000", "130667" ], + "230608" : [ "10:08", "350000", "130668" ], + "230609" : [ "10:09", "350000", "130669" ], + "230610" : [ "10:10", "350000", "130670" ], + "230611" : [ "10:11", "350000", "130671" ], + "230612" : [ "10:12", "350000", "130672" ], + "230613" : [ "10:13", "350000", "130673" ], + "230614" : [ "10:14", "350000", "130674" ], + "230615" : [ "10:15", "350000", "130675" ], + "230616" : [ "10:16", "350000", "130676" ], + "230617" : [ "10:17", "350000", "130677" ], + "230618" : [ "10:18", "350000", "130678" ], + "230619" : [ "10:19", "350000", "130679" ], + "230620" : [ "10:20", "350000", "130680" ], + "230621" : [ "10:21", "350000", "130681" ], + "230622" : [ "10:22", "350000", "130682" ], + "230623" : [ "10:23", "350000", "130683" ], + "230624" : [ "10:24", "350000", "130684" ], + "230625" : [ "10:25", "350000", "130685" ], + "230626" : [ "10:26", "350000", "130686" ], + "230627" : [ "10:27", "350000", "130687" ], + "230628" : [ "10:28", "350000", "130688" ], + "230629" : [ "10:29", "350000", "130689" ], + "230630" : [ "10:30", "350000", "130690" ], + "230631" : [ "10:31", "350000", "130691" ], + "230632" : [ "10:32", "350000", "130692" ], + "230633" : [ "10:33", "350000", "130693" ], + "230634" : [ "10:34", "350000", "130694" ], + "230635" : [ "10:35", "350000", "130695" ], + "230636" : [ "10:36", "350000", "130696" ], + "230637" : [ "10:37", "350000", "130697" ], + "230638" : [ "10:38", "350000", "130698" ], + "230639" : [ "10:39", "350000", "130699" ], + "230640" : [ "10:40", "350000", "130700" ], + "230641" : [ "10:41", "350000", "130701" ], + "230642" : [ "10:42", "350000", "130702" ], + "230643" : [ "10:43", "350000", "130703" ], + "230644" : [ "10:44", "350000", "130704" ], + "230645" : [ "10:45", "350000", "130705" ], + "230646" : [ "10:46", "350000", "130706" ], + "230647" : [ "10:47", "350000", "130707" ], + "230648" : [ "10:48", "350000", "130708" ], + "230649" : [ "10:49", "350000", "130709" ], + "230650" : [ "10:50", "350000", "130710" ], + "230651" : [ "10:51", "350000", "130711" ], + "230652" : [ "10:52", "350000", "130712" ], + "230653" : [ "10:53", "350000", "130713" ], + "230654" : [ "10:54", "350000", "130714" ], + "230655" : [ "10:55", "350000", "130715" ], + "230656" : [ "10:56", "350000", "130716" ], + "230657" : [ "10:57", "350000", "130717" ], + "230658" : [ "10:58", "350000", "130718" ], + "230659" : [ "10:59", "350000", "130719" ], + "230660" : [ "11:00", "350000", "130720" ], + "230661" : [ "11:01", "350000", "130721" ], + "230662" : [ "11:02", "350000", "130722" ], + "230663" : [ "11:03", "350000", "130723" ], + "230664" : [ "11:04", "350000", "130724" ], + "230665" : [ "11:05", "350000", "130725" ], + "230666" : [ "11:06", "350000", "130726" ], + "230667" : [ "11:07", "350000", "130727" ], + "230668" : [ "11:08", "350000", "130728" ], + "230669" : [ "11:09", "350000", "130729" ], + "230670" : [ "11:10", "350000", "130730" ], + "230671" : [ "11:11", "350000", "130731" ], + "230672" : [ "11:12", "350000", "130732" ], + "230673" : [ "11:13", "350000", "130733" ], + "230674" : [ "11:14", "350000", "130734" ], + "230675" : [ "11:15", "350000", "130735" ], + "230676" : [ "11:16", "350000", "130736" ], + "230677" : [ "11:17", "350000", "130737" ], + "230678" : [ "11:18", "350000", "130738" ], + "230679" : [ "11:19", "350000", "130739" ], + "230680" : [ "11:20", "350000", "130740" ], + "230681" : [ "11:21", "350000", "130741" ], + "230682" : [ "11:22", "350000", "130742" ], + "230683" : [ "11:23", "350000", "130743" ], + "230684" : [ "11:24", "350000", "130744" ], + "230685" : [ "11:25", "350000", "130745" ], + "230686" : [ "11:26", "350000", "130746" ], + "230687" : [ "11:27", "350000", "130747" ], + "230688" : [ "11:28", "350000", "130748" ], + "230689" : [ "11:29", "350000", "130749" ], + "230690" : [ "11:30", "350000", "130750" ], + "230691" : [ "11:31", "350000", "130751" ], + "230692" : [ "11:32", "350000", "130752" ], + "230693" : [ "11:33", "350000", "130753" ], + "230694" : [ "11:34", "350000", "130754" ], + "230695" : [ "11:35", "350000", "130755" ], + "230696" : [ "11:36", "350000", "130756" ], + "230697" : [ "11:37", "350000", "130757" ], + "230698" : [ "11:38", "350000", "130758" ], + "230699" : [ "11:39", "350000", "130759" ], + "230700" : [ "11:40", "350000", "130760" ], + "230701" : [ "11:41", "350000", "130761" ], + "230702" : [ "11:42", "350000", "130762" ], + "230703" : [ "11:43", "350000", "130763" ], + "230704" : [ "11:44", "350000", "130764" ], + "230705" : [ "11:45", "350000", "130765" ], + "230706" : [ "11:46", "350000", "130766" ], + "230707" : [ "11:47", "350000", "130767" ], + "230708" : [ "11:48", "350000", "130768" ], + "230709" : [ "11:49", "350000", "130769" ], + "230710" : [ "11:50", "350000", "130770" ], + "230711" : [ "11:51", "350000", "130771" ], + "230712" : [ "11:52", "350000", "130772" ], + "230713" : [ "11:53", "350000", "130773" ], + "230714" : [ "11:54", "350000", "130774" ], + "230715" : [ "11:55", "350000", "130775" ], + "230716" : [ "11:56", "350000", "130776" ], + "230717" : [ "11:57", "350000", "130777" ], + "230718" : [ "11:58", "350000", "130778" ], + "230719" : [ "11:59", "350000", "130779" ], + "230720" : [ "12:00", "350000", "130780" ], + "230721" : [ "12:01", "350000", "130781" ], + "230722" : [ "12:02", "350000", "130782" ], + "230723" : [ "12:03", "350000", "130783" ], + "230724" : [ "12:04", "350000", "130784" ], + "230725" : [ "12:05", "350000", "130785" ], + "230726" : [ "12:06", "350000", "130786" ], + "230727" : [ "12:07", "350000", "130787" ], + "230728" : [ "12:08", "350000", "130788" ], + "230729" : [ "12:09", "350000", "130789" ], + "230730" : [ "12:10", "350000", "130790" ], + "230731" : [ "12:11", "350000", "130791" ], + "230732" : [ "12:12", "350000", "130792" ], + "230733" : [ "12:13", "350000", "130793" ], + "230734" : [ "12:14", "350000", "130794" ], + "230735" : [ "12:15", "350000", "130795" ], + "230736" : [ "12:16", "350000", "130796" ], + "230737" : [ "12:17", "350000", "130797" ], + "230738" : [ "12:18", "350000", "130798" ], + "230739" : [ "12:19", "350000", "130799" ], + "230740" : [ "12:20", "350000", "130800" ], + "230741" : [ "12:21", "350000", "130801" ], + "230742" : [ "12:22", "350000", "130802" ], + "230743" : [ "12:23", "350000", "130803" ], + "230744" : [ "12:24", "350000", "130804" ], + "230745" : [ "12:25", "350000", "130805" ], + "230746" : [ "12:26", "350000", "130806" ], + "230747" : [ "12:27", "350000", "130807" ], + "230748" : [ "12:28", "350000", "130808" ], + "230749" : [ "12:29", "350000", "130809" ], + "230750" : [ "12:30", "350000", "130810" ], + "230751" : [ "12:31", "350000", "130811" ], + "230752" : [ "12:32", "350000", "130812" ], + "230753" : [ "12:33", "350000", "130813" ], + "230754" : [ "12:34", "350000", "130814" ], + "230755" : [ "12:35", "350000", "130815" ], + "230756" : [ "12:36", "350000", "130816" ], + "230757" : [ "12:37", "350000", "130817" ], + "230758" : [ "12:38", "350000", "130818" ], + "230759" : [ "12:39", "350000", "130819" ], + "230760" : [ "12:40", "350000", "130820" ], + "230761" : [ "12:41", "350000", "130821" ], + "230762" : [ "12:42", "350000", "130822" ], + "230763" : [ "12:43", "350000", "130823" ], + "230764" : [ "12:44", "350000", "130824" ], + "230765" : [ "12:45", "350000", "130825" ], + "230766" : [ "12:46", "350000", "130826" ], + "230767" : [ "12:47", "350000", "130827" ], + "230768" : [ "12:48", "350000", "130828" ], + "230769" : [ "12:49", "350000", "130829" ], + "230770" : [ "12:50", "350000", "130830" ], + "230771" : [ "12:51", "350000", "130831" ], + "230772" : [ "12:52", "350000", "130832" ], + "230773" : [ "12:53", "350000", "130833" ], + "230774" : [ "12:54", "350000", "130834" ], + "230775" : [ "12:55", "350000", "130835" ], + "230776" : [ "12:56", "350000", "130836" ], + "230777" : [ "12:57", "350000", "130837" ], + "230778" : [ "12:58", "350000", "130838" ], + "230779" : [ "12:59", "350000", "130839" ], + "230780" : [ "13:00", "350000", "130840" ], + "230781" : [ "13:01", "350000", "130841" ], + "230782" : [ "13:02", "350000", "130842" ], + "230783" : [ "13:03", "350000", "130843" ], + "230784" : [ "13:04", "350000", "130844" ], + "230785" : [ "13:05", "350000", "130845" ], + "230786" : [ "13:06", "350000", "130846" ], + "230787" : [ "13:07", "350000", "130847" ], + "230788" : [ "13:08", "350000", "130848" ], + "230789" : [ "13:09", "350000", "130849" ], + "230790" : [ "13:10", "350000", "130850" ], + "230791" : [ "13:11", "350000", "130851" ], + "230792" : [ "13:12", "350000", "130852" ], + "230793" : [ "13:13", "350000", "130853" ], + "230794" : [ "13:14", "350000", "130854" ], + "230795" : [ "13:15", "350000", "130855" ], + "230796" : [ "13:16", "350000", "130856" ], + "230797" : [ "13:17", "350000", "130857" ], + "230798" : [ "13:18", "350000", "130858" ], + "230799" : [ "13:19", "350000", "130859" ], + "230800" : [ "13:20", "350000", "130860" ], + "230801" : [ "13:21", "350000", "130861" ], + "230802" : [ "13:22", "350000", "130862" ], + "230803" : [ "13:23", "350000", "130863" ], + "230804" : [ "13:24", "350000", "130864" ], + "230805" : [ "13:25", "350000", "130865" ], + "230806" : [ "13:26", "350000", "130866" ], + "230807" : [ "13:27", "350000", "130867" ], + "230808" : [ "13:28", "350000", "130868" ], + "230809" : [ "13:29", "350000", "130869" ], + "230810" : [ "13:30", "350000", "130870" ], + "230811" : [ "13:31", "350000", "130871" ], + "230812" : [ "13:32", "350000", "130872" ], + "230813" : [ "13:33", "350000", "130873" ], + "230814" : [ "13:34", "350000", "130874" ], + "230815" : [ "13:35", "350000", "130875" ], + "230816" : [ "13:36", "350000", "130876" ], + "230817" : [ "13:37", "350000", "130877" ], + "230818" : [ "13:38", "350000", "130878" ], + "230819" : [ "13:39", "350000", "130879" ], + "230820" : [ "13:40", "350000", "130880" ], + "230821" : [ "13:41", "350000", "130881" ], + "230822" : [ "13:42", "350000", "130882" ], + "230823" : [ "13:43", "350000", "130883" ], + "230824" : [ "13:44", "350000", "130884" ], + "230825" : [ "13:45", "350000", "130885" ], + "230826" : [ "13:46", "350000", "130886" ], + "230827" : [ "13:47", "350000", "130887" ], + "230828" : [ "13:48", "350000", "130888" ], + "230829" : [ "13:49", "350000", "130889" ], + "230830" : [ "13:50", "350000", "130890" ], + "230831" : [ "13:51", "350000", "130891" ], + "230832" : [ "13:52", "350000", "130892" ], + "230833" : [ "13:53", "350000", "130893" ], + "230834" : [ "13:54", "350000", "130894" ], + "230835" : [ "13:55", "350000", "130895" ], + "230836" : [ "13:56", "350000", "130896" ], + "230837" : [ "13:57", "350000", "130897" ], + "230838" : [ "13:58", "350000", "130898" ], + "230839" : [ "13:59", "350000", "130899" ], + "230840" : [ "14:00", "350000", "130900" ], + "230841" : [ "14:01", "350000", "130901" ], + "230842" : [ "14:02", "350000", "130902" ], + "230843" : [ "14:03", "350000", "130903" ], + "230844" : [ "14:04", "350000", "130904" ], + "230845" : [ "14:05", "350000", "130905" ], + "230846" : [ "14:06", "350000", "130906" ], + "230847" : [ "14:07", "350000", "130907" ], + "230848" : [ "14:08", "350000", "130908" ], + "230849" : [ "14:09", "350000", "130909" ], + "230850" : [ "14:10", "350000", "130910" ], + "230851" : [ "14:11", "350000", "130911" ], + "230852" : [ "14:12", "350000", "130912" ], + "230853" : [ "14:13", "350000", "130913" ], + "230854" : [ "14:14", "350000", "130914" ], + "230855" : [ "14:15", "350000", "130915" ], + "230856" : [ "14:16", "350000", "130916" ], + "230857" : [ "14:17", "350000", "130917" ], + "230858" : [ "14:18", "350000", "130918" ], + "230859" : [ "14:19", "350000", "130919" ], + "230860" : [ "14:20", "350000", "130920" ], + "230861" : [ "14:21", "350000", "130921" ], + "230862" : [ "14:22", "350000", "130922" ], + "230863" : [ "14:23", "350000", "130923" ], + "230864" : [ "14:24", "350000", "130924" ], + "230865" : [ "14:25", "350000", "130925" ], + "230866" : [ "14:26", "350000", "130926" ], + "230867" : [ "14:27", "350000", "130927" ], + "230868" : [ "14:28", "350000", "130928" ], + "230869" : [ "14:29", "350000", "130929" ], + "230870" : [ "14:30", "350000", "130930" ], + "230871" : [ "14:31", "350000", "130931" ], + "230872" : [ "14:32", "350000", "130932" ], + "230873" : [ "14:33", "350000", "130933" ], + "230874" : [ "14:34", "350000", "130934" ], + "230875" : [ "14:35", "350000", "130935" ], + "230876" : [ "14:36", "350000", "130936" ], + "230877" : [ "14:37", "350000", "130937" ], + "230878" : [ "14:38", "350000", "130938" ], + "230879" : [ "14:39", "350000", "130939" ], + "230880" : [ "14:40", "350000", "130940" ], + "230881" : [ "14:41", "350000", "130941" ], + "230882" : [ "14:42", "350000", "130942" ], + "230883" : [ "14:43", "350000", "130943" ], + "230884" : [ "14:44", "350000", "130944" ], + "230885" : [ "14:45", "350000", "130945" ], + "230886" : [ "14:46", "350000", "130946" ], + "230887" : [ "14:47", "350000", "130947" ], + "230888" : [ "14:48", "350000", "130948" ], + "230889" : [ "14:49", "350000", "130949" ], + "230890" : [ "14:50", "350000", "130950" ], + "230891" : [ "14:51", "350000", "130951" ], + "230892" : [ "14:52", "350000", "130952" ], + "230893" : [ "14:53", "350000", "130953" ], + "230894" : [ "14:54", "350000", "130954" ], + "230895" : [ "14:55", "350000", "130955" ], + "230896" : [ "14:56", "350000", "130956" ], + "230897" : [ "14:57", "350000", "130957" ], + "230898" : [ "14:58", "350000", "130958" ], + "230899" : [ "14:59", "350000", "130959" ], + "230900" : [ "15:00", "350000", "130960" ], + "230901" : [ "15:01", "350000", "130961" ], + "230902" : [ "15:02", "350000", "130962" ], + "230903" : [ "15:03", "350000", "130963" ], + "230904" : [ "15:04", "350000", "130964" ], + "230905" : [ "15:05", "350000", "130965" ], + "230906" : [ "15:06", "350000", "130966" ], + "230907" : [ "15:07", "350000", "130967" ], + "230908" : [ "15:08", "350000", "130968" ], + "230909" : [ "15:09", "350000", "130969" ], + "230910" : [ "15:10", "350000", "130970" ], + "230911" : [ "15:11", "350000", "130971" ], + "230912" : [ "15:12", "350000", "130972" ], + "230913" : [ "15:13", "350000", "130973" ], + "230914" : [ "15:14", "350000", "130974" ], + "230915" : [ "15:15", "350000", "130975" ], + "230916" : [ "15:16", "350000", "130976" ], + "230917" : [ "15:17", "350000", "130977" ], + "230918" : [ "15:18", "350000", "130978" ], + "230919" : [ "15:19", "350000", "130979" ], + "230920" : [ "15:20", "350000", "130980" ], + "230921" : [ "15:21", "350000", "130981" ], + "230922" : [ "15:22", "350000", "130982" ], + "230923" : [ "15:23", "350000", "130983" ], + "230924" : [ "15:24", "350000", "130984" ], + "230925" : [ "15:25", "350000", "130985" ], + "230926" : [ "15:26", "350000", "130986" ], + "230927" : [ "15:27", "350000", "130987" ], + "230928" : [ "15:28", "350000", "130988" ], + "230929" : [ "15:29", "350000", "130989" ], + "230930" : [ "15:30", "350000", "130990" ], + "230931" : [ "15:31", "350000", "130991" ], + "230932" : [ "15:32", "350000", "130992" ], + "230933" : [ "15:33", "350000", "130993" ], + "230934" : [ "15:34", "350000", "130994" ], + "230935" : [ "15:35", "350000", "130995" ], + "230936" : [ "15:36", "350000", "130996" ], + "230937" : [ "15:37", "350000", "130997" ], + "230938" : [ "15:38", "350000", "130998" ], + "230939" : [ "15:39", "350000", "130999" ], + "230940" : [ "15:40", "350000", "131000" ], + "230941" : [ "15:41", "350000", "131001" ], + "230942" : [ "15:42", "350000", "131002" ], + "230943" : [ "15:43", "350000", "131003" ], + "230944" : [ "15:44", "350000", "131004" ], + "230945" : [ "15:45", "350000", "131005" ], + "230946" : [ "15:46", "350000", "131006" ], + "230947" : [ "15:47", "350000", "131007" ], + "230948" : [ "15:48", "350000", "131008" ], + "230949" : [ "15:49", "350000", "131009" ], + "230950" : [ "15:50", "350000", "131010" ], + "230951" : [ "15:51", "350000", "131011" ], + "230952" : [ "15:52", "350000", "131012" ], + "230953" : [ "15:53", "350000", "131013" ], + "230954" : [ "15:54", "350000", "131014" ], + "230955" : [ "15:55", "350000", "131015" ], + "230956" : [ "15:56", "350000", "131016" ], + "230957" : [ "15:57", "350000", "131017" ], + "230958" : [ "15:58", "350000", "131018" ], + "230959" : [ "15:59", "350000", "131019" ], + "230960" : [ "16:00", "350000", "131020" ], + "230961" : [ "16:01", "350000", "131021" ], + "230962" : [ "16:02", "350000", "131022" ], + "230963" : [ "16:03", "350000", "131023" ], + "230964" : [ "16:04", "350000", "131024" ], + "230965" : [ "16:05", "350000", "131025" ], + "230966" : [ "16:06", "350000", "131026" ], + "230967" : [ "16:07", "350000", "131027" ], + "230968" : [ "16:08", "350000", "131028" ], + "230969" : [ "16:09", "350000", "131029" ], + "230970" : [ "16:10", "350000", "131030" ], + "230971" : [ "16:11", "350000", "131031" ], + "230972" : [ "16:12", "350000", "131032" ], + "230973" : [ "16:13", "350000", "131033" ], + "230974" : [ "16:14", "350000", "131034" ], + "230975" : [ "16:15", "350000", "131035" ], + "230976" : [ "16:16", "350000", "131036" ], + "230977" : [ "16:17", "350000", "131037" ], + "230978" : [ "16:18", "350000", "131038" ], + "230979" : [ "16:19", "350000", "131039" ], + "230980" : [ "16:20", "350000", "131040" ], + "230981" : [ "16:21", "350000", "131041" ], + "230982" : [ "16:22", "350000", "131042" ], + "230983" : [ "16:23", "350000", "131043" ], + "230984" : [ "16:24", "350000", "131044" ], + "230985" : [ "16:25", "350000", "131045" ], + "230986" : [ "16:26", "350000", "131046" ], + "230987" : [ "16:27", "350000", "131047" ], + "230988" : [ "16:28", "350000", "131048" ], + "230989" : [ "16:29", "350000", "131049" ], + "230990" : [ "16:30", "350000", "131050" ], + "230991" : [ "16:31", "350000", "131051" ], + "230992" : [ "16:32", "350000", "131052" ], + "230993" : [ "16:33", "350000", "131053" ], + "230994" : [ "16:34", "350000", "131054" ], + "230995" : [ "16:35", "350000", "131055" ], + "230996" : [ "16:36", "350000", "131056" ], + "230997" : [ "16:37", "350000", "131057" ], + "230998" : [ "16:38", "350000", "131058" ], + "230999" : [ "16:39", "350000", "131059" ], + "231000" : [ "16:40", "350000", "131060" ], + "231001" : [ "16:41", "350000", "131061" ], + "231002" : [ "16:42", "350000", "131062" ], + "231003" : [ "16:43", "350000", "131063" ], + "231004" : [ "16:44", "350000", "131064" ], + "231005" : [ "16:45", "350000", "131065" ], + "231006" : [ "16:46", "350000", "131066" ], + "231007" : [ "16:47", "350000", "131067" ], + "231008" : [ "16:48", "350000", "131068" ], + "231009" : [ "16:49", "350000", "131069" ], + "231010" : [ "16:50", "350000", "131070" ], + "231011" : [ "16:51", "350000", "131071" ], + "231012" : [ "16:52", "350000", "131072" ], + "231013" : [ "16:53", "350000", "131073" ], + "231014" : [ "16:54", "350000", "131074" ], + "231015" : [ "16:55", "350000", "131075" ], + "231016" : [ "16:56", "350000", "131076" ], + "231017" : [ "16:57", "350000", "131077" ], + "231018" : [ "16:58", "350000", "131078" ], + "231019" : [ "16:59", "350000", "131079" ], + "231020" : [ "17:00", "350000", "131080" ], + "231021" : [ "17:01", "350000", "131081" ], + "231022" : [ "17:02", "350000", "131082" ], + "231023" : [ "17:03", "350000", "131083" ], + "231024" : [ "17:04", "350000", "131084" ], + "231025" : [ "17:05", "350000", "131085" ], + "231026" : [ "17:06", "350000", "131086" ], + "231027" : [ "17:07", "350000", "131087" ], + "231028" : [ "17:08", "350000", "131088" ], + "231029" : [ "17:09", "350000", "131089" ], + "231030" : [ "17:10", "350000", "131090" ], + "231031" : [ "17:11", "350000", "131091" ], + "231032" : [ "17:12", "350000", "131092" ], + "231033" : [ "17:13", "350000", "131093" ], + "231034" : [ "17:14", "350000", "131094" ], + "231035" : [ "17:15", "350000", "131095" ], + "231036" : [ "17:16", "350000", "131096" ], + "231037" : [ "17:17", "350000", "131097" ], + "231038" : [ "17:18", "350000", "131098" ], + "231039" : [ "17:19", "350000", "131099" ], + "231040" : [ "17:20", "350000", "131100" ], + "231041" : [ "17:21", "350000", "131101" ], + "231042" : [ "17:22", "350000", "131102" ], + "231043" : [ "17:23", "350000", "131103" ], + "231044" : [ "17:24", "350000", "131104" ], + "231045" : [ "17:25", "350000", "131105" ], + "231046" : [ "17:26", "350000", "131106" ], + "231047" : [ "17:27", "350000", "131107" ], + "231048" : [ "17:28", "350000", "131108" ], + "231049" : [ "17:29", "350000", "131109" ], + "231050" : [ "17:30", "350000", "131110" ], + "231051" : [ "17:31", "350000", "131111" ], + "231052" : [ "17:32", "350000", "131112" ], + "231053" : [ "17:33", "350000", "131113" ], + "231054" : [ "17:34", "350000", "131114" ], + "231055" : [ "17:35", "350000", "131115" ], + "231056" : [ "17:36", "350000", "131116" ], + "231057" : [ "17:37", "350000", "131117" ], + "231058" : [ "17:38", "350000", "131118" ], + "231059" : [ "17:39", "350000", "131119" ], + "231060" : [ "17:40", "350000", "131120" ], + "231061" : [ "17:41", "350000", "131121" ], + "231062" : [ "17:42", "350000", "131122" ], + "231063" : [ "17:43", "350000", "131123" ], + "231064" : [ "17:44", "350000", "131124" ], + "231065" : [ "17:45", "350000", "131125" ], + "231066" : [ "17:46", "350000", "131126" ], + "231067" : [ "17:47", "350000", "131127" ], + "231068" : [ "17:48", "350000", "131128" ], + "231069" : [ "17:49", "350000", "131129" ], + "231070" : [ "17:50", "350000", "131130" ], + "231071" : [ "17:51", "350000", "131131" ], + "231072" : [ "17:52", "350000", "131132" ], + "231073" : [ "17:53", "350000", "131133" ], + "231074" : [ "17:54", "350000", "131134" ], + "231075" : [ "17:55", "350000", "131135" ], + "231076" : [ "17:56", "350000", "131136" ], + "231077" : [ "17:57", "350000", "131137" ], + "231078" : [ "17:58", "350000", "131138" ], + "231079" : [ "17:59", "350000", "131139" ], + "231080" : [ "18:00", "350000", "131140" ], + "231081" : [ "18:01", "350000", "131141" ], + "231082" : [ "18:02", "350000", "131142" ], + "231083" : [ "18:03", "350000", "131143" ], + "231084" : [ "18:04", "350000", "131144" ], + "231085" : [ "18:05", "350000", "131145" ], + "231086" : [ "18:06", "350000", "131146" ], + "231087" : [ "18:07", "350000", "131147" ], + "231088" : [ "18:08", "350000", "131148" ], + "231089" : [ "18:09", "350000", "131149" ], + "231090" : [ "18:10", "350000", "131150" ], + "231091" : [ "18:11", "350000", "131151" ], + "231092" : [ "18:12", "350000", "131152" ], + "231093" : [ "18:13", "350000", "131153" ], + "231094" : [ "18:14", "350000", "131154" ], + "231095" : [ "18:15", "350000", "131155" ], + "231096" : [ "18:16", "350000", "131156" ], + "231097" : [ "18:17", "350000", "131157" ], + "231098" : [ "18:18", "350000", "131158" ], + "231099" : [ "18:19", "350000", "131159" ], + "231100" : [ "18:20", "350000", "131160" ], + "231101" : [ "18:21", "350000", "131161" ], + "231102" : [ "18:22", "350000", "131162" ], + "231103" : [ "18:23", "350000", "131163" ], + "231104" : [ "18:24", "350000", "131164" ], + "231105" : [ "18:25", "350000", "131165" ], + "231106" : [ "18:26", "350000", "131166" ], + "231107" : [ "18:27", "350000", "131167" ], + "231108" : [ "18:28", "350000", "131168" ], + "231109" : [ "18:29", "350000", "131169" ], + "231110" : [ "18:30", "350000", "131170" ], + "231111" : [ "18:31", "350000", "131171" ], + "231112" : [ "18:32", "350000", "131172" ], + "231113" : [ "18:33", "350000", "131173" ], + "231114" : [ "18:34", "350000", "131174" ], + "231115" : [ "18:35", "350000", "131175" ], + "231116" : [ "18:36", "350000", "131176" ], + "231117" : [ "18:37", "350000", "131177" ], + "231118" : [ "18:38", "350000", "131178" ], + "231119" : [ "18:39", "350000", "131179" ], + "231120" : [ "18:40", "350000", "131180" ], + "231121" : [ "18:41", "350000", "131181" ], + "231122" : [ "18:42", "350000", "131182" ], + "231123" : [ "18:43", "350000", "131183" ], + "231124" : [ "18:44", "350000", "131184" ], + "231125" : [ "18:45", "350000", "131185" ], + "231126" : [ "18:46", "350000", "131186" ], + "231127" : [ "18:47", "350000", "131187" ], + "231128" : [ "18:48", "350000", "131188" ], + "231129" : [ "18:49", "350000", "131189" ], + "231130" : [ "18:50", "350000", "131190" ], + "231131" : [ "18:51", "350000", "131191" ], + "231132" : [ "18:52", "350000", "131192" ], + "231133" : [ "18:53", "350000", "131193" ], + "231134" : [ "18:54", "350000", "131194" ], + "231135" : [ "18:55", "350000", "131195" ], + "231136" : [ "18:56", "350000", "131196" ], + "231137" : [ "18:57", "350000", "131197" ], + "231138" : [ "18:58", "350000", "131198" ], + "231139" : [ "18:59", "350000", "131199" ], + "231140" : [ "19:00", "350000", "131200" ], + "231141" : [ "19:01", "350000", "131200" ], + "231142" : [ "19:02", "350000", "131200" ], + "231143" : [ "19:03", "350000", "131200" ], + "231144" : [ "19:04", "350000", "131200" ], + "231145" : [ "19:05", "350000", "131200" ], + "231146" : [ "19:06", "350000", "131200" ], + "231147" : [ "19:07", "350000", "131200" ], + "231148" : [ "19:08", "350000", "131200" ], + "231149" : [ "19:09", "350000", "131200" ], + "231150" : [ "19:10", "350000", "131200" ], + "231151" : [ "19:11", "350000", "131200" ], + "231152" : [ "19:12", "350000", "131200" ], + "231153" : [ "19:13", "350000", "131200" ], + "231154" : [ "19:14", "350000", "131200" ], + "231155" : [ "19:15", "350000", "131200" ], + "231156" : [ "19:16", "350000", "131200" ], + "231157" : [ "19:17", "350000", "131200" ], + "231158" : [ "19:18", "350000", "131200" ], + "231159" : [ "19:19", "350000", "131200" ], + "231160" : [ "19:20", "350000", "131200" ], + "231161" : [ "19:21", "350000", "131200" ], + "231162" : [ "19:22", "350000", "131200" ], + "231163" : [ "19:23", "350000", "131200" ], + "231164" : [ "19:24", "350000", "131200" ], + "231165" : [ "19:25", "350000", "131200" ], + "231166" : [ "19:26", "350000", "131200" ], + "231167" : [ "19:27", "350000", "131200" ], + "231168" : [ "19:28", "350000", "131200" ], + "231169" : [ "19:29", "350000", "131200" ], + "231170" : [ "19:30", "350000", "131200" ], + "231171" : [ "19:31", "350000", "131200" ], + "231172" : [ "19:32", "350000", "131200" ], + "231173" : [ "19:33", "350000", "131200" ], + "231174" : [ "19:34", "350000", "131200" ], + "231175" : [ "19:35", "350000", "131200" ], + "231176" : [ "19:36", "350000", "131200" ], + "231177" : [ "19:37", "350000", "131200" ], + "231178" : [ "19:38", "350000", "131200" ], + "231179" : [ "19:39", "350000", "131200" ], + "231180" : [ "19:40", "350000", "131200" ], + "231181" : [ "19:41", "350000", "131200" ], + "231182" : [ "19:42", "350000", "131200" ], + "231183" : [ "19:43", "350000", "131200" ], + "231184" : [ "19:44", "350000", "131200" ], + "231185" : [ "19:45", "350000", "131200" ], + "231186" : [ "19:46", "350000", "131200" ], + "231187" : [ "19:47", "350000", "131200" ], + "231188" : [ "19:48", "350000", "131200" ], + "231189" : [ "19:49", "350000", "131200" ], + "231190" : [ "19:50", "350000", "131200" ], + "231191" : [ "19:51", "350000", "131200" ], + "231192" : [ "19:52", "350000", "131200" ], + "231193" : [ "19:53", "350000", "131200" ], + "231194" : [ "19:54", "350000", "131200" ], + "231195" : [ "19:55", "350000", "131200" ], + "231196" : [ "19:56", "350000", "131200" ], + "231197" : [ "19:57", "350000", "131200" ], + "231198" : [ "19:58", "350000", "131200" ], + "231199" : [ "19:59", "350000", "131200" ], + "231200" : [ "20:00", "800000", "140420" ], + "231201" : [ "20:01", "800000", "140420" ], + "231202" : [ "20:02", "800000", "140420" ], + "231203" : [ "20:03", "800000", "140420" ], + "231204" : [ "20:04", "800000", "140420" ], + "231205" : [ "20:05", "800000", "140420" ], + "231206" : [ "20:06", "800000", "140420" ], + "231207" : [ "20:07", "800000", "140420" ], + "231208" : [ "20:08", "800000", "140420" ], + "231209" : [ "20:09", "800000", "140420" ], + "231210" : [ "20:10", "800000", "140420" ], + "231211" : [ "20:11", "800000", "140420" ], + "231212" : [ "20:12", "800000", "140420" ], + "231213" : [ "20:13", "800000", "140420" ], + "231214" : [ "20:14", "800000", "140420" ], + "231215" : [ "20:15", "800000", "140420" ], + "231216" : [ "20:16", "800000", "140420" ], + "231217" : [ "20:17", "800000", "140420" ], + "231218" : [ "20:18", "800000", "140420" ], + "231219" : [ "20:19", "800000", "140420" ], + "231220" : [ "20:20", "800000", "140420" ], + "231221" : [ "20:21", "800000", "140420" ], + "231222" : [ "20:22", "800000", "140420" ], + "231223" : [ "20:23", "800000", "140420" ], + "231224" : [ "20:24", "800000", "140420" ], + "231225" : [ "20:25", "800000", "140420" ], + "231226" : [ "20:26", "800000", "140420" ], + "231227" : [ "20:27", "800000", "140420" ], + "231228" : [ "20:28", "800000", "140420" ], + "231229" : [ "20:29", "800000", "140420" ], + "231230" : [ "20:30", "800000", "140420" ], + "231231" : [ "20:31", "800000", "140420" ], + "231232" : [ "20:32", "800000", "140420" ], + "231233" : [ "20:33", "800000", "140420" ], + "231234" : [ "20:34", "800000", "140420" ], + "231235" : [ "20:35", "800000", "140420" ], + "231236" : [ "20:36", "800000", "140420" ], + "231237" : [ "20:37", "800000", "140420" ], + "231238" : [ "20:38", "800000", "140420" ], + "231239" : [ "20:39", "800000", "140420" ], + "231240" : [ "20:40", "800000", "140420" ], + "231241" : [ "20:41", "800000", "140420" ], + "231242" : [ "20:42", "800000", "140420" ], + "231243" : [ "20:43", "800000", "140420" ], + "231244" : [ "20:44", "800000", "140420" ], + "231245" : [ "20:45", "800000", "140420" ], + "231246" : [ "20:46", "800000", "140420" ], + "231247" : [ "20:47", "800000", "140420" ], + "231248" : [ "20:48", "800000", "140420" ], + "231249" : [ "20:49", "800000", "140420" ], + "231250" : [ "20:50", "800000", "140420" ], + "231251" : [ "20:51", "800000", "140420" ], + "231252" : [ "20:52", "800000", "140420" ], + "231253" : [ "20:53", "800000", "140420" ], + "231254" : [ "20:54", "800000", "140420" ], + "231255" : [ "20:55", "800000", "140420" ], + "231256" : [ "20:56", "800000", "140420" ], + "231257" : [ "20:57", "800000", "140420" ], + "231258" : [ "20:58", "800000", "140420" ], + "231259" : [ "20:59", "800000", "140420" ], + "231260" : [ "21:00", "800000", "140420" ], + "231261" : [ "21:01", "800000", "140420" ], + "231262" : [ "21:02", "800000", "140420" ], + "231263" : [ "21:03", "800000", "140420" ], + "231264" : [ "21:04", "800000", "140420" ], + "231265" : [ "21:05", "800000", "140420" ], + "231266" : [ "21:06", "800000", "140420" ], + "231267" : [ "21:07", "800000", "140420" ], + "231268" : [ "21:08", "800000", "140420" ], + "231269" : [ "21:09", "800000", "140420" ], + "231270" : [ "21:10", "800000", "140420" ], + "231271" : [ "21:11", "800000", "140420" ], + "231272" : [ "21:12", "800000", "140420" ], + "231273" : [ "21:13", "800000", "140420" ], + "231274" : [ "21:14", "800000", "140420" ], + "231275" : [ "21:15", "800000", "140420" ], + "231276" : [ "21:16", "800000", "140420" ], + "231277" : [ "21:17", "800000", "140420" ], + "231278" : [ "21:18", "800000", "140420" ], + "231279" : [ "21:19", "800000", "140420" ], + "231280" : [ "21:20", "800000", "140420" ], + "231281" : [ "21:21", "800000", "140420" ], + "231282" : [ "21:22", "800000", "140420" ], + "231283" : [ "21:23", "800000", "140420" ], + "231284" : [ "21:24", "800000", "140420" ], + "231285" : [ "21:25", "800000", "140420" ], + "231286" : [ "21:26", "800000", "140420" ], + "231287" : [ "21:27", "800000", "140420" ], + "231288" : [ "21:28", "800000", "140420" ], + "231289" : [ "21:29", "800000", "140420" ], + "231290" : [ "21:30", "800000", "140420" ], + "231291" : [ "21:31", "800000", "140420" ], + "231292" : [ "21:32", "800000", "140420" ], + "231293" : [ "21:33", "800000", "140420" ], + "231294" : [ "21:34", "800000", "140420" ], + "231295" : [ "21:35", "800000", "140420" ], + "231296" : [ "21:36", "800000", "140420" ], + "231297" : [ "21:37", "800000", "140420" ], + "231298" : [ "21:38", "800000", "140420" ], + "231299" : [ "21:39", "800000", "140420" ], + "231300" : [ "21:40", "800000", "140420" ], + "231301" : [ "21:41", "800000", "140420" ], + "231302" : [ "21:42", "800000", "140420" ], + "231303" : [ "21:43", "800000", "140420" ], + "231304" : [ "21:44", "800000", "140420" ], + "231305" : [ "21:45", "800000", "140420" ], + "231306" : [ "21:46", "800000", "140420" ], + "231307" : [ "21:47", "800000", "140420" ], + "231308" : [ "21:48", "800000", "140420" ], + "231309" : [ "21:49", "800000", "140420" ], + "231310" : [ "21:50", "800000", "140420" ], + "231311" : [ "21:51", "800000", "140420" ], + "231312" : [ "21:52", "800000", "140420" ], + "231313" : [ "21:53", "800000", "140420" ], + "231314" : [ "21:54", "800000", "140420" ], + "231315" : [ "21:55", "800000", "140420" ], + "231316" : [ "21:56", "800000", "140420" ], + "231317" : [ "21:57", "800000", "140420" ], + "231318" : [ "21:58", "800000", "140420" ], + "231319" : [ "21:59", "800000", "140420" ], + "231320" : [ "22:00", "800000", "140420" ], + "231321" : [ "22:01", "800000", "140420" ], + "231322" : [ "22:02", "800000", "140420" ], + "231323" : [ "22:03", "800000", "140420" ], + "231324" : [ "22:04", "800000", "140420" ], + "231325" : [ "22:05", "800000", "140420" ], + "231326" : [ "22:06", "800000", "140420" ], + "231327" : [ "22:07", "800000", "140420" ], + "231328" : [ "22:08", "800000", "140420" ], + "231329" : [ "22:09", "800000", "140420" ], + "231330" : [ "22:10", "800000", "140420" ], + "231331" : [ "22:11", "800000", "140420" ], + "231332" : [ "22:12", "800000", "140420" ], + "231333" : [ "22:13", "800000", "140420" ], + "231334" : [ "22:14", "800000", "140420" ], + "231335" : [ "22:15", "800000", "140420" ], + "231336" : [ "22:16", "800000", "140420" ], + "231337" : [ "22:17", "800000", "140420" ], + "231338" : [ "22:18", "800000", "140420" ], + "231339" : [ "22:19", "800000", "140420" ], + "231340" : [ "22:20", "800000", "140420" ], + "231341" : [ "22:21", "800000", "140420" ], + "231342" : [ "22:22", "800000", "140420" ], + "231343" : [ "22:23", "800000", "140420" ], + "231344" : [ "22:24", "800000", "140420" ], + "231345" : [ "22:25", "800000", "140420" ], + "231346" : [ "22:26", "800000", "140420" ], + "231347" : [ "22:27", "800000", "140420" ], + "231348" : [ "22:28", "800000", "140420" ], + "231349" : [ "22:29", "800000", "140420" ], + "231350" : [ "22:30", "800000", "140420" ], + "231351" : [ "22:31", "800000", "140420" ], + "231352" : [ "22:32", "800000", "140420" ], + "231353" : [ "22:33", "800000", "140420" ], + "231354" : [ "22:34", "800000", "140420" ], + "231355" : [ "22:35", "800000", "140420" ], + "231356" : [ "22:36", "800000", "140420" ], + "231357" : [ "22:37", "800000", "140420" ], + "231358" : [ "22:38", "800000", "140420" ], + "231359" : [ "22:39", "800000", "140420" ], + "231360" : [ "22:40", "800000", "140420" ], + "231361" : [ "22:41", "800000", "140420" ], + "231362" : [ "22:42", "800000", "140420" ], + "231363" : [ "22:43", "800000", "140420" ], + "231364" : [ "22:44", "800000", "140420" ], + "231365" : [ "22:45", "800000", "140420" ], + "231366" : [ "22:46", "800000", "140420" ], + "231367" : [ "22:47", "800000", "140420" ], + "231368" : [ "22:48", "800000", "140420" ], + "231369" : [ "22:49", "800000", "140420" ], + "231370" : [ "22:50", "800000", "140420" ], + "231371" : [ "22:51", "800000", "140420" ], + "231372" : [ "22:52", "800000", "140420" ], + "231373" : [ "22:53", "800000", "140420" ], + "231374" : [ "22:54", "800000", "140420" ], + "231375" : [ "22:55", "800000", "140420" ], + "231376" : [ "22:56", "800000", "140420" ], + "231377" : [ "22:57", "800000", "140420" ], + "231378" : [ "22:58", "800000", "140420" ], + "231379" : [ "22:59", "800000", "140420" ], + "231380" : [ "23:00", "800000", "140420" ], + "231381" : [ "23:01", "800000", "140420" ], + "231382" : [ "23:02", "800000", "140420" ], + "231383" : [ "23:03", "800000", "140420" ], + "231384" : [ "23:04", "800000", "140420" ], + "231385" : [ "23:05", "800000", "140420" ], + "231386" : [ "23:06", "800000", "140420" ], + "231387" : [ "23:07", "800000", "140420" ], + "231388" : [ "23:08", "800000", "140420" ], + "231389" : [ "23:09", "800000", "140420" ], + "231390" : [ "23:10", "800000", "140420" ], + "231391" : [ "23:11", "800000", "140420" ], + "231392" : [ "23:12", "800000", "140420" ], + "231393" : [ "23:13", "800000", "140420" ], + "231394" : [ "23:14", "800000", "140420" ], + "231395" : [ "23:15", "800000", "140420" ], + "231396" : [ "23:16", "800000", "140420" ], + "231397" : [ "23:17", "800000", "140420" ], + "231398" : [ "23:18", "800000", "140420" ], + "231399" : [ "23:19", "800000", "140420" ], + "231400" : [ "23:20", "800000", "140420" ], + "231401" : [ "23:21", "800000", "140420" ], + "231402" : [ "23:22", "800000", "140420" ], + "231403" : [ "23:23", "800000", "140420" ], + "231404" : [ "23:24", "800000", "140420" ], + "231405" : [ "23:25", "800000", "140420" ], + "231406" : [ "23:26", "800000", "140420" ], + "231407" : [ "23:27", "800000", "140420" ], + "231408" : [ "23:28", "800000", "140420" ], + "231409" : [ "23:29", "800000", "140420" ], + "231410" : [ "23:30", "800000", "140420" ], + "231411" : [ "23:31", "800000", "140420" ], + "231412" : [ "23:32", "800000", "140420" ], + "231413" : [ "23:33", "800000", "140420" ], + "231414" : [ "23:34", "800000", "140420" ], + "231415" : [ "23:35", "800000", "140420" ], + "231416" : [ "23:36", "800000", "140420" ], + "231417" : [ "23:37", "800000", "140420" ], + "231418" : [ "23:38", "800000", "140420" ], + "231419" : [ "23:39", "800000", "140420" ], + "231420" : [ "23:40", "800000", "140420" ], + "231421" : [ "23:41", "800000", "140420" ], + "231422" : [ "23:42", "800000", "140420" ], + "231423" : [ "23:43", "800000", "140420" ], + "231424" : [ "23:44", "800000", "140420" ], + "231425" : [ "23:45", "800000", "140420" ], + "231426" : [ "23:46", "800000", "140420" ], + "231427" : [ "23:47", "800000", "140420" ], + "231428" : [ "23:48", "800000", "140420" ], + "231429" : [ "23:49", "800000", "140420" ], + "231430" : [ "23:50", "800000", "140420" ], + "231431" : [ "23:51", "800000", "140420" ], + "231432" : [ "23:52", "800000", "140420" ], + "231433" : [ "23:53", "800000", "140420" ], + "231434" : [ "23:54", "800000", "140420" ], + "231435" : [ "23:55", "800000", "140420" ], + "231436" : [ "23:56", "800000", "140420" ], + "231437" : [ "23:57", "800000", "140420" ], + "231438" : [ "23:58", "800000", "140420" ], + "231439" : [ "23:59", "800000", "140420" ] + }, + "Friday": { + "240000" : [ "00:00", "800000", "140420" ], + "240001" : [ "00:01", "800000", "140420" ], + "240002" : [ "00:02", "800000", "140420" ], + "240003" : [ "00:03", "800000", "140420" ], + "240004" : [ "00:04", "800000", "140420" ], + "240005" : [ "00:05", "800000", "140420" ], + "240006" : [ "00:06", "800000", "140420" ], + "240007" : [ "00:07", "800000", "140420" ], + "240008" : [ "00:08", "800000", "140420" ], + "240009" : [ "00:09", "800000", "140420" ], + "240010" : [ "00:10", "800000", "140420" ], + "240011" : [ "00:11", "800000", "140420" ], + "240012" : [ "00:12", "800000", "140420" ], + "240013" : [ "00:13", "800000", "140420" ], + "240014" : [ "00:14", "800000", "140420" ], + "240015" : [ "00:15", "800000", "140420" ], + "240016" : [ "00:16", "800000", "140420" ], + "240017" : [ "00:17", "800000", "140420" ], + "240018" : [ "00:18", "800000", "140420" ], + "240019" : [ "00:19", "800000", "140420" ], + "240020" : [ "00:20", "800000", "140420" ], + "240021" : [ "00:21", "800000", "140420" ], + "240022" : [ "00:22", "800000", "140420" ], + "240023" : [ "00:23", "800000", "140420" ], + "240024" : [ "00:24", "800000", "140420" ], + "240025" : [ "00:25", "800000", "140420" ], + "240026" : [ "00:26", "800000", "140420" ], + "240027" : [ "00:27", "800000", "140420" ], + "240028" : [ "00:28", "800000", "140420" ], + "240029" : [ "00:29", "800000", "140420" ], + "240030" : [ "00:30", "800000", "140420" ], + "240031" : [ "00:31", "800000", "140420" ], + "240032" : [ "00:32", "800000", "140420" ], + "240033" : [ "00:33", "800000", "140420" ], + "240034" : [ "00:34", "800000", "140420" ], + "240035" : [ "00:35", "800000", "140420" ], + "240036" : [ "00:36", "800000", "140420" ], + "240037" : [ "00:37", "800000", "140420" ], + "240038" : [ "00:38", "800000", "140420" ], + "240039" : [ "00:39", "800000", "140420" ], + "240040" : [ "00:40", "800000", "140420" ], + "240041" : [ "00:41", "800000", "140420" ], + "240042" : [ "00:42", "800000", "140420" ], + "240043" : [ "00:43", "800000", "140420" ], + "240044" : [ "00:44", "800000", "140420" ], + "240045" : [ "00:45", "800000", "140420" ], + "240046" : [ "00:46", "800000", "140420" ], + "240047" : [ "00:47", "800000", "140420" ], + "240048" : [ "00:48", "800000", "140420" ], + "240049" : [ "00:49", "800000", "140420" ], + "240050" : [ "00:50", "800000", "140420" ], + "240051" : [ "00:51", "800000", "140420" ], + "240052" : [ "00:52", "800000", "140420" ], + "240053" : [ "00:53", "800000", "140420" ], + "240054" : [ "00:54", "800000", "140420" ], + "240055" : [ "00:55", "800000", "140420" ], + "240056" : [ "00:56", "800000", "140420" ], + "240057" : [ "00:57", "800000", "140420" ], + "240058" : [ "00:58", "800000", "140420" ], + "240059" : [ "00:59", "800000", "140420" ], + "240060" : [ "01:00", "800000", "140420" ], + "240061" : [ "01:01", "800000", "140420" ], + "240062" : [ "01:02", "800000", "140420" ], + "240063" : [ "01:03", "800000", "140420" ], + "240064" : [ "01:04", "800000", "140420" ], + "240065" : [ "01:05", "800000", "140420" ], + "240066" : [ "01:06", "800000", "140420" ], + "240067" : [ "01:07", "800000", "140420" ], + "240068" : [ "01:08", "800000", "140420" ], + "240069" : [ "01:09", "800000", "140420" ], + "240070" : [ "01:10", "800000", "140420" ], + "240071" : [ "01:11", "800000", "140420" ], + "240072" : [ "01:12", "800000", "140420" ], + "240073" : [ "01:13", "800000", "140420" ], + "240074" : [ "01:14", "800000", "140420" ], + "240075" : [ "01:15", "800000", "140420" ], + "240076" : [ "01:16", "800000", "140420" ], + "240077" : [ "01:17", "800000", "140420" ], + "240078" : [ "01:18", "800000", "140420" ], + "240079" : [ "01:19", "800000", "140420" ], + "240080" : [ "01:20", "800000", "140420" ], + "240081" : [ "01:21", "800000", "140420" ], + "240082" : [ "01:22", "800000", "140420" ], + "240083" : [ "01:23", "800000", "140420" ], + "240084" : [ "01:24", "800000", "140420" ], + "240085" : [ "01:25", "800000", "140420" ], + "240086" : [ "01:26", "800000", "140420" ], + "240087" : [ "01:27", "800000", "140420" ], + "240088" : [ "01:28", "800000", "140420" ], + "240089" : [ "01:29", "800000", "140420" ], + "240090" : [ "01:30", "800000", "140420" ], + "240091" : [ "01:31", "800000", "140420" ], + "240092" : [ "01:32", "800000", "140420" ], + "240093" : [ "01:33", "800000", "140420" ], + "240094" : [ "01:34", "800000", "140420" ], + "240095" : [ "01:35", "800000", "140420" ], + "240096" : [ "01:36", "800000", "140420" ], + "240097" : [ "01:37", "800000", "140420" ], + "240098" : [ "01:38", "800000", "140420" ], + "240099" : [ "01:39", "800000", "140420" ], + "240100" : [ "01:40", "800000", "140420" ], + "240101" : [ "01:41", "800000", "140420" ], + "240102" : [ "01:42", "800000", "140420" ], + "240103" : [ "01:43", "800000", "140420" ], + "240104" : [ "01:44", "800000", "140420" ], + "240105" : [ "01:45", "800000", "140420" ], + "240106" : [ "01:46", "800000", "140420" ], + "240107" : [ "01:47", "800000", "140420" ], + "240108" : [ "01:48", "800000", "140420" ], + "240109" : [ "01:49", "800000", "140420" ], + "240110" : [ "01:50", "800000", "140420" ], + "240111" : [ "01:51", "800000", "140420" ], + "240112" : [ "01:52", "800000", "140420" ], + "240113" : [ "01:53", "800000", "140420" ], + "240114" : [ "01:54", "800000", "140420" ], + "240115" : [ "01:55", "800000", "140420" ], + "240116" : [ "01:56", "800000", "140420" ], + "240117" : [ "01:57", "800000", "140420" ], + "240118" : [ "01:58", "800000", "140420" ], + "240119" : [ "01:59", "800000", "140420" ], + "240120" : [ "02:00", "800000", "140420" ], + "240121" : [ "02:01", "800000", "140420" ], + "240122" : [ "02:02", "800000", "140420" ], + "240123" : [ "02:03", "800000", "140420" ], + "240124" : [ "02:04", "800000", "140420" ], + "240125" : [ "02:05", "800000", "140420" ], + "240126" : [ "02:06", "800000", "140420" ], + "240127" : [ "02:07", "800000", "140420" ], + "240128" : [ "02:08", "800000", "140420" ], + "240129" : [ "02:09", "800000", "140420" ], + "240130" : [ "02:10", "800000", "140420" ], + "240131" : [ "02:11", "800000", "140420" ], + "240132" : [ "02:12", "800000", "140420" ], + "240133" : [ "02:13", "800000", "140420" ], + "240134" : [ "02:14", "800000", "140420" ], + "240135" : [ "02:15", "800000", "140420" ], + "240136" : [ "02:16", "800000", "140420" ], + "240137" : [ "02:17", "800000", "140420" ], + "240138" : [ "02:18", "800000", "140420" ], + "240139" : [ "02:19", "800000", "140420" ], + "240140" : [ "02:20", "800000", "140420" ], + "240141" : [ "02:21", "800000", "140420" ], + "240142" : [ "02:22", "800000", "140420" ], + "240143" : [ "02:23", "800000", "140420" ], + "240144" : [ "02:24", "800000", "140420" ], + "240145" : [ "02:25", "800000", "140420" ], + "240146" : [ "02:26", "800000", "140420" ], + "240147" : [ "02:27", "800000", "140420" ], + "240148" : [ "02:28", "800000", "140420" ], + "240149" : [ "02:29", "800000", "140420" ], + "240150" : [ "02:30", "800000", "140420" ], + "240151" : [ "02:31", "800000", "140420" ], + "240152" : [ "02:32", "800000", "140420" ], + "240153" : [ "02:33", "800000", "140420" ], + "240154" : [ "02:34", "800000", "140420" ], + "240155" : [ "02:35", "800000", "140420" ], + "240156" : [ "02:36", "800000", "140420" ], + "240157" : [ "02:37", "800000", "140420" ], + "240158" : [ "02:38", "800000", "140420" ], + "240159" : [ "02:39", "800000", "140420" ], + "240160" : [ "02:40", "800000", "140420" ], + "240161" : [ "02:41", "800000", "140420" ], + "240162" : [ "02:42", "800000", "140420" ], + "240163" : [ "02:43", "800000", "140420" ], + "240164" : [ "02:44", "800000", "140420" ], + "240165" : [ "02:45", "800000", "140420" ], + "240166" : [ "02:46", "800000", "140420" ], + "240167" : [ "02:47", "800000", "140420" ], + "240168" : [ "02:48", "800000", "140420" ], + "240169" : [ "02:49", "800000", "140420" ], + "240170" : [ "02:50", "800000", "140420" ], + "240171" : [ "02:51", "800000", "140420" ], + "240172" : [ "02:52", "800000", "140420" ], + "240173" : [ "02:53", "800000", "140420" ], + "240174" : [ "02:54", "800000", "140420" ], + "240175" : [ "02:55", "800000", "140420" ], + "240176" : [ "02:56", "800000", "140420" ], + "240177" : [ "02:57", "800000", "140420" ], + "240178" : [ "02:58", "800000", "140420" ], + "240179" : [ "02:59", "800000", "140420" ], + "240180" : [ "03:00", "800000", "140420" ], + "240181" : [ "03:01", "800000", "140420" ], + "240182" : [ "03:02", "800000", "140420" ], + "240183" : [ "03:03", "800000", "140420" ], + "240184" : [ "03:04", "800000", "140420" ], + "240185" : [ "03:05", "800000", "140420" ], + "240186" : [ "03:06", "800000", "140420" ], + "240187" : [ "03:07", "800000", "140420" ], + "240188" : [ "03:08", "800000", "140420" ], + "240189" : [ "03:09", "800000", "140420" ], + "240190" : [ "03:10", "800000", "140420" ], + "240191" : [ "03:11", "800000", "140420" ], + "240192" : [ "03:12", "800000", "140420" ], + "240193" : [ "03:13", "800000", "140420" ], + "240194" : [ "03:14", "800000", "140420" ], + "240195" : [ "03:15", "800000", "140420" ], + "240196" : [ "03:16", "800000", "140420" ], + "240197" : [ "03:17", "800000", "140420" ], + "240198" : [ "03:18", "800000", "140420" ], + "240199" : [ "03:19", "800000", "140420" ], + "240200" : [ "03:20", "800000", "140420" ], + "240201" : [ "03:21", "800000", "140420" ], + "240202" : [ "03:22", "800000", "140420" ], + "240203" : [ "03:23", "800000", "140420" ], + "240204" : [ "03:24", "800000", "140420" ], + "240205" : [ "03:25", "800000", "140420" ], + "240206" : [ "03:26", "800000", "140420" ], + "240207" : [ "03:27", "800000", "140420" ], + "240208" : [ "03:28", "800000", "140420" ], + "240209" : [ "03:29", "800000", "140420" ], + "240210" : [ "03:30", "800000", "140420" ], + "240211" : [ "03:31", "800000", "140420" ], + "240212" : [ "03:32", "800000", "140420" ], + "240213" : [ "03:33", "800000", "140420" ], + "240214" : [ "03:34", "800000", "140420" ], + "240215" : [ "03:35", "800000", "140420" ], + "240216" : [ "03:36", "800000", "140420" ], + "240217" : [ "03:37", "800000", "140420" ], + "240218" : [ "03:38", "800000", "140420" ], + "240219" : [ "03:39", "800000", "140420" ], + "240220" : [ "03:40", "800000", "140420" ], + "240221" : [ "03:41", "800000", "140420" ], + "240222" : [ "03:42", "800000", "140420" ], + "240223" : [ "03:43", "800000", "140420" ], + "240224" : [ "03:44", "800000", "140420" ], + "240225" : [ "03:45", "800000", "140420" ], + "240226" : [ "03:46", "800000", "140420" ], + "240227" : [ "03:47", "800000", "140420" ], + "240228" : [ "03:48", "800000", "140420" ], + "240229" : [ "03:49", "800000", "140420" ], + "240230" : [ "03:50", "800000", "140420" ], + "240231" : [ "03:51", "800000", "140420" ], + "240232" : [ "03:52", "800000", "140420" ], + "240233" : [ "03:53", "800000", "140420" ], + "240234" : [ "03:54", "800000", "140420" ], + "240235" : [ "03:55", "800000", "140420" ], + "240236" : [ "03:56", "800000", "140420" ], + "240237" : [ "03:57", "800000", "140420" ], + "240238" : [ "03:58", "800000", "140420" ], + "240239" : [ "03:59", "800000", "140420" ], + "240240" : [ "04:00", "800000", "140420" ], + "240241" : [ "04:01", "800000", "140420" ], + "240242" : [ "04:02", "800000", "140420" ], + "240243" : [ "04:03", "800000", "140420" ], + "240244" : [ "04:04", "800000", "140420" ], + "240245" : [ "04:05", "800000", "140420" ], + "240246" : [ "04:06", "800000", "140420" ], + "240247" : [ "04:07", "800000", "140420" ], + "240248" : [ "04:08", "800000", "140420" ], + "240249" : [ "04:09", "800000", "140420" ], + "240250" : [ "04:10", "800000", "140420" ], + "240251" : [ "04:11", "800000", "140420" ], + "240252" : [ "04:12", "800000", "140420" ], + "240253" : [ "04:13", "800000", "140420" ], + "240254" : [ "04:14", "800000", "140420" ], + "240255" : [ "04:15", "800000", "140420" ], + "240256" : [ "04:16", "800000", "140420" ], + "240257" : [ "04:17", "800000", "140420" ], + "240258" : [ "04:18", "800000", "140420" ], + "240259" : [ "04:19", "800000", "140420" ], + "240260" : [ "04:20", "800000", "140420" ], + "240261" : [ "04:21", "800000", "140420" ], + "240262" : [ "04:22", "800000", "140420" ], + "240263" : [ "04:23", "800000", "140420" ], + "240264" : [ "04:24", "800000", "140420" ], + "240265" : [ "04:25", "800000", "140420" ], + "240266" : [ "04:26", "800000", "140420" ], + "240267" : [ "04:27", "800000", "140420" ], + "240268" : [ "04:28", "800000", "140420" ], + "240269" : [ "04:29", "800000", "140420" ], + "240270" : [ "04:30", "800000", "140420" ], + "240271" : [ "04:31", "800000", "140420" ], + "240272" : [ "04:32", "800000", "140420" ], + "240273" : [ "04:33", "800000", "140420" ], + "240274" : [ "04:34", "800000", "140420" ], + "240275" : [ "04:35", "800000", "140420" ], + "240276" : [ "04:36", "800000", "140420" ], + "240277" : [ "04:37", "800000", "140420" ], + "240278" : [ "04:38", "800000", "140420" ], + "240279" : [ "04:39", "800000", "140420" ], + "240280" : [ "04:40", "800000", "140420" ], + "240281" : [ "04:41", "800000", "140420" ], + "240282" : [ "04:42", "800000", "140420" ], + "240283" : [ "04:43", "800000", "140420" ], + "240284" : [ "04:44", "800000", "140420" ], + "240285" : [ "04:45", "800000", "140420" ], + "240286" : [ "04:46", "800000", "140420" ], + "240287" : [ "04:47", "800000", "140420" ], + "240288" : [ "04:48", "800000", "140420" ], + "240289" : [ "04:49", "800000", "140420" ], + "240290" : [ "04:50", "800000", "140420" ], + "240291" : [ "04:51", "800000", "140420" ], + "240292" : [ "04:52", "800000", "140420" ], + "240293" : [ "04:53", "800000", "140420" ], + "240294" : [ "04:54", "800000", "140420" ], + "240295" : [ "04:55", "800000", "140420" ], + "240296" : [ "04:56", "800000", "140420" ], + "240297" : [ "04:57", "800000", "140420" ], + "240298" : [ "04:58", "800000", "140420" ], + "240299" : [ "04:59", "800000", "140420" ], + "240300" : [ "05:00", "800000", "140420" ], + "240301" : [ "05:01", "800000", "140420" ], + "240302" : [ "05:02", "800000", "140420" ], + "240303" : [ "05:03", "800000", "140420" ], + "240304" : [ "05:04", "800000", "140420" ], + "240305" : [ "05:05", "800000", "140420" ], + "240306" : [ "05:06", "800000", "140420" ], + "240307" : [ "05:07", "800000", "140420" ], + "240308" : [ "05:08", "800000", "140420" ], + "240309" : [ "05:09", "800000", "140420" ], + "240310" : [ "05:10", "800000", "140420" ], + "240311" : [ "05:11", "800000", "140420" ], + "240312" : [ "05:12", "800000", "140420" ], + "240313" : [ "05:13", "800000", "140420" ], + "240314" : [ "05:14", "800000", "140420" ], + "240315" : [ "05:15", "800000", "140420" ], + "240316" : [ "05:16", "800000", "140420" ], + "240317" : [ "05:17", "800000", "140420" ], + "240318" : [ "05:18", "800000", "140420" ], + "240319" : [ "05:19", "800000", "140420" ], + "240320" : [ "05:20", "800000", "140420" ], + "240321" : [ "05:21", "800000", "140420" ], + "240322" : [ "05:22", "800000", "140420" ], + "240323" : [ "05:23", "800000", "140420" ], + "240324" : [ "05:24", "800000", "140420" ], + "240325" : [ "05:25", "800000", "140420" ], + "240326" : [ "05:26", "800000", "140420" ], + "240327" : [ "05:27", "800000", "140420" ], + "240328" : [ "05:28", "800000", "140420" ], + "240329" : [ "05:29", "800000", "140420" ], + "240330" : [ "05:30", "800000", "140420" ], + "240331" : [ "05:31", "800000", "140420" ], + "240332" : [ "05:32", "800000", "140420" ], + "240333" : [ "05:33", "800000", "140420" ], + "240334" : [ "05:34", "800000", "140420" ], + "240335" : [ "05:35", "800000", "140420" ], + "240336" : [ "05:36", "800000", "140420" ], + "240337" : [ "05:37", "800000", "140420" ], + "240338" : [ "05:38", "800000", "140420" ], + "240339" : [ "05:39", "800000", "140420" ], + "240340" : [ "05:40", "800000", "140420" ], + "240341" : [ "05:41", "800000", "140420" ], + "240342" : [ "05:42", "800000", "140420" ], + "240343" : [ "05:43", "800000", "140420" ], + "240344" : [ "05:44", "800000", "140420" ], + "240345" : [ "05:45", "800000", "140420" ], + "240346" : [ "05:46", "800000", "140420" ], + "240347" : [ "05:47", "800000", "140420" ], + "240348" : [ "05:48", "800000", "140420" ], + "240349" : [ "05:49", "800000", "140420" ], + "240350" : [ "05:50", "800000", "140420" ], + "240351" : [ "05:51", "800000", "140420" ], + "240352" : [ "05:52", "800000", "140420" ], + "240353" : [ "05:53", "800000", "140420" ], + "240354" : [ "05:54", "800000", "140420" ], + "240355" : [ "05:55", "800000", "140420" ], + "240356" : [ "05:56", "800000", "140420" ], + "240357" : [ "05:57", "800000", "140420" ], + "240358" : [ "05:58", "800000", "140420" ], + "240359" : [ "05:59", "800000", "140420" ], + "240360" : [ "06:00", "800000", "140420" ], + "240361" : [ "06:01", "800000", "140420" ], + "240362" : [ "06:02", "800000", "140420" ], + "240363" : [ "06:03", "800000", "140420" ], + "240364" : [ "06:04", "800000", "140420" ], + "240365" : [ "06:05", "800000", "140420" ], + "240366" : [ "06:06", "800000", "140420" ], + "240367" : [ "06:07", "800000", "140420" ], + "240368" : [ "06:08", "800000", "140420" ], + "240369" : [ "06:09", "800000", "140420" ], + "240370" : [ "06:10", "800000", "140420" ], + "240371" : [ "06:11", "800000", "140420" ], + "240372" : [ "06:12", "800000", "140420" ], + "240373" : [ "06:13", "800000", "140420" ], + "240374" : [ "06:14", "800000", "140420" ], + "240375" : [ "06:15", "800000", "140420" ], + "240376" : [ "06:16", "800000", "140420" ], + "240377" : [ "06:17", "800000", "140420" ], + "240378" : [ "06:18", "800000", "140420" ], + "240379" : [ "06:19", "800000", "140420" ], + "240380" : [ "06:20", "800000", "140420" ], + "240381" : [ "06:21", "800000", "140420" ], + "240382" : [ "06:22", "800000", "140420" ], + "240383" : [ "06:23", "800000", "140420" ], + "240384" : [ "06:24", "800000", "140420" ], + "240385" : [ "06:25", "800000", "140420" ], + "240386" : [ "06:26", "800000", "140420" ], + "240387" : [ "06:27", "800000", "140420" ], + "240388" : [ "06:28", "800000", "140420" ], + "240389" : [ "06:29", "800000", "140420" ], + "240390" : [ "06:30", "800000", "140420" ], + "240391" : [ "06:31", "800000", "140420" ], + "240392" : [ "06:32", "800000", "140420" ], + "240393" : [ "06:33", "800000", "140420" ], + "240394" : [ "06:34", "800000", "140420" ], + "240395" : [ "06:35", "800000", "140420" ], + "240396" : [ "06:36", "800000", "140420" ], + "240397" : [ "06:37", "800000", "140420" ], + "240398" : [ "06:38", "800000", "140420" ], + "240399" : [ "06:39", "800000", "140420" ], + "240400" : [ "06:40", "800000", "140420" ], + "240401" : [ "06:41", "800000", "140420" ], + "240402" : [ "06:42", "800000", "140420" ], + "240403" : [ "06:43", "800000", "140420" ], + "240404" : [ "06:44", "800000", "140420" ], + "240405" : [ "06:45", "800000", "140420" ], + "240406" : [ "06:46", "800000", "140420" ], + "240407" : [ "06:47", "800000", "140420" ], + "240408" : [ "06:48", "800000", "140420" ], + "240409" : [ "06:49", "800000", "140420" ], + "240410" : [ "06:50", "800000", "140420" ], + "240411" : [ "06:51", "800000", "140420" ], + "240412" : [ "06:52", "800000", "140420" ], + "240413" : [ "06:53", "800000", "140420" ], + "240414" : [ "06:54", "800000", "140420" ], + "240415" : [ "06:55", "800000", "140420" ], + "240416" : [ "06:56", "800000", "140420" ], + "240417" : [ "06:57", "800000", "140420" ], + "240418" : [ "06:58", "800000", "140420" ], + "240419" : [ "06:59", "800000", "140420" ], + "240420" : [ "07:00", "350000", "140480" ], + "240421" : [ "07:01", "350000", "140481" ], + "240422" : [ "07:02", "350000", "140482" ], + "240423" : [ "07:03", "350000", "140483" ], + "240424" : [ "07:04", "350000", "140484" ], + "240425" : [ "07:05", "350000", "140485" ], + "240426" : [ "07:06", "350000", "140486" ], + "240427" : [ "07:07", "350000", "140487" ], + "240428" : [ "07:08", "350000", "140488" ], + "240429" : [ "07:09", "350000", "140489" ], + "240430" : [ "07:10", "350000", "140490" ], + "240431" : [ "07:11", "350000", "140491" ], + "240432" : [ "07:12", "350000", "140492" ], + "240433" : [ "07:13", "350000", "140493" ], + "240434" : [ "07:14", "350000", "140494" ], + "240435" : [ "07:15", "350000", "140495" ], + "240436" : [ "07:16", "350000", "140496" ], + "240437" : [ "07:17", "350000", "140497" ], + "240438" : [ "07:18", "350000", "140498" ], + "240439" : [ "07:19", "350000", "140499" ], + "240440" : [ "07:20", "350000", "140500" ], + "240441" : [ "07:21", "350000", "140501" ], + "240442" : [ "07:22", "350000", "140502" ], + "240443" : [ "07:23", "350000", "140503" ], + "240444" : [ "07:24", "350000", "140504" ], + "240445" : [ "07:25", "350000", "140505" ], + "240446" : [ "07:26", "350000", "140506" ], + "240447" : [ "07:27", "350000", "140507" ], + "240448" : [ "07:28", "350000", "140508" ], + "240449" : [ "07:29", "350000", "140509" ], + "240450" : [ "07:30", "350000", "140510" ], + "240451" : [ "07:31", "350000", "140511" ], + "240452" : [ "07:32", "350000", "140512" ], + "240453" : [ "07:33", "350000", "140513" ], + "240454" : [ "07:34", "350000", "140514" ], + "240455" : [ "07:35", "350000", "140515" ], + "240456" : [ "07:36", "350000", "140516" ], + "240457" : [ "07:37", "350000", "140517" ], + "240458" : [ "07:38", "350000", "140518" ], + "240459" : [ "07:39", "350000", "140519" ], + "240460" : [ "07:40", "350000", "140520" ], + "240461" : [ "07:41", "350000", "140521" ], + "240462" : [ "07:42", "350000", "140522" ], + "240463" : [ "07:43", "350000", "140523" ], + "240464" : [ "07:44", "350000", "140524" ], + "240465" : [ "07:45", "350000", "140525" ], + "240466" : [ "07:46", "350000", "140526" ], + "240467" : [ "07:47", "350000", "140527" ], + "240468" : [ "07:48", "350000", "140528" ], + "240469" : [ "07:49", "350000", "140529" ], + "240470" : [ "07:50", "350000", "140530" ], + "240471" : [ "07:51", "350000", "140531" ], + "240472" : [ "07:52", "350000", "140532" ], + "240473" : [ "07:53", "350000", "140533" ], + "240474" : [ "07:54", "350000", "140534" ], + "240475" : [ "07:55", "350000", "140535" ], + "240476" : [ "07:56", "350000", "140536" ], + "240477" : [ "07:57", "350000", "140537" ], + "240478" : [ "07:58", "350000", "140538" ], + "240479" : [ "07:59", "350000", "140539" ], + "240480" : [ "08:00", "350000", "140540" ], + "240481" : [ "08:01", "350000", "140541" ], + "240482" : [ "08:02", "350000", "140542" ], + "240483" : [ "08:03", "350000", "140543" ], + "240484" : [ "08:04", "350000", "140544" ], + "240485" : [ "08:05", "350000", "140545" ], + "240486" : [ "08:06", "350000", "140546" ], + "240487" : [ "08:07", "350000", "140547" ], + "240488" : [ "08:08", "350000", "140548" ], + "240489" : [ "08:09", "350000", "140549" ], + "240490" : [ "08:10", "350000", "140550" ], + "240491" : [ "08:11", "350000", "140551" ], + "240492" : [ "08:12", "350000", "140552" ], + "240493" : [ "08:13", "350000", "140553" ], + "240494" : [ "08:14", "350000", "140554" ], + "240495" : [ "08:15", "350000", "140555" ], + "240496" : [ "08:16", "350000", "140556" ], + "240497" : [ "08:17", "350000", "140557" ], + "240498" : [ "08:18", "350000", "140558" ], + "240499" : [ "08:19", "350000", "140559" ], + "240500" : [ "08:20", "350000", "140560" ], + "240501" : [ "08:21", "350000", "140561" ], + "240502" : [ "08:22", "350000", "140562" ], + "240503" : [ "08:23", "350000", "140563" ], + "240504" : [ "08:24", "350000", "140564" ], + "240505" : [ "08:25", "350000", "140565" ], + "240506" : [ "08:26", "350000", "140566" ], + "240507" : [ "08:27", "350000", "140567" ], + "240508" : [ "08:28", "350000", "140568" ], + "240509" : [ "08:29", "350000", "140569" ], + "240510" : [ "08:30", "350000", "140570" ], + "240511" : [ "08:31", "350000", "140571" ], + "240512" : [ "08:32", "350000", "140572" ], + "240513" : [ "08:33", "350000", "140573" ], + "240514" : [ "08:34", "350000", "140574" ], + "240515" : [ "08:35", "350000", "140575" ], + "240516" : [ "08:36", "350000", "140576" ], + "240517" : [ "08:37", "350000", "140577" ], + "240518" : [ "08:38", "350000", "140578" ], + "240519" : [ "08:39", "350000", "140579" ], + "240520" : [ "08:40", "350000", "140580" ], + "240521" : [ "08:41", "350000", "140581" ], + "240522" : [ "08:42", "350000", "140582" ], + "240523" : [ "08:43", "350000", "140583" ], + "240524" : [ "08:44", "350000", "140584" ], + "240525" : [ "08:45", "350000", "140585" ], + "240526" : [ "08:46", "350000", "140586" ], + "240527" : [ "08:47", "350000", "140587" ], + "240528" : [ "08:48", "350000", "140588" ], + "240529" : [ "08:49", "350000", "140589" ], + "240530" : [ "08:50", "350000", "140590" ], + "240531" : [ "08:51", "350000", "140591" ], + "240532" : [ "08:52", "350000", "140592" ], + "240533" : [ "08:53", "350000", "140593" ], + "240534" : [ "08:54", "350000", "140594" ], + "240535" : [ "08:55", "350000", "140595" ], + "240536" : [ "08:56", "350000", "140596" ], + "240537" : [ "08:57", "350000", "140597" ], + "240538" : [ "08:58", "350000", "140598" ], + "240539" : [ "08:59", "350000", "140599" ], + "240540" : [ "09:00", "350000", "140600" ], + "240541" : [ "09:01", "350000", "140601" ], + "240542" : [ "09:02", "350000", "140602" ], + "240543" : [ "09:03", "350000", "140603" ], + "240544" : [ "09:04", "350000", "140604" ], + "240545" : [ "09:05", "350000", "140605" ], + "240546" : [ "09:06", "350000", "140606" ], + "240547" : [ "09:07", "350000", "140607" ], + "240548" : [ "09:08", "350000", "140608" ], + "240549" : [ "09:09", "350000", "140609" ], + "240550" : [ "09:10", "350000", "140610" ], + "240551" : [ "09:11", "350000", "140611" ], + "240552" : [ "09:12", "350000", "140612" ], + "240553" : [ "09:13", "350000", "140613" ], + "240554" : [ "09:14", "350000", "140614" ], + "240555" : [ "09:15", "350000", "140615" ], + "240556" : [ "09:16", "350000", "140616" ], + "240557" : [ "09:17", "350000", "140617" ], + "240558" : [ "09:18", "350000", "140618" ], + "240559" : [ "09:19", "350000", "140619" ], + "240560" : [ "09:20", "350000", "140620" ], + "240561" : [ "09:21", "350000", "140621" ], + "240562" : [ "09:22", "350000", "140622" ], + "240563" : [ "09:23", "350000", "140623" ], + "240564" : [ "09:24", "350000", "140624" ], + "240565" : [ "09:25", "350000", "140625" ], + "240566" : [ "09:26", "350000", "140626" ], + "240567" : [ "09:27", "350000", "140627" ], + "240568" : [ "09:28", "350000", "140628" ], + "240569" : [ "09:29", "350000", "140629" ], + "240570" : [ "09:30", "350000", "140630" ], + "240571" : [ "09:31", "350000", "140631" ], + "240572" : [ "09:32", "350000", "140632" ], + "240573" : [ "09:33", "350000", "140633" ], + "240574" : [ "09:34", "350000", "140634" ], + "240575" : [ "09:35", "350000", "140635" ], + "240576" : [ "09:36", "350000", "140636" ], + "240577" : [ "09:37", "350000", "140637" ], + "240578" : [ "09:38", "350000", "140638" ], + "240579" : [ "09:39", "350000", "140639" ], + "240580" : [ "09:40", "350000", "140640" ], + "240581" : [ "09:41", "350000", "140641" ], + "240582" : [ "09:42", "350000", "140642" ], + "240583" : [ "09:43", "350000", "140643" ], + "240584" : [ "09:44", "350000", "140644" ], + "240585" : [ "09:45", "350000", "140645" ], + "240586" : [ "09:46", "350000", "140646" ], + "240587" : [ "09:47", "350000", "140647" ], + "240588" : [ "09:48", "350000", "140648" ], + "240589" : [ "09:49", "350000", "140649" ], + "240590" : [ "09:50", "350000", "140650" ], + "240591" : [ "09:51", "350000", "140651" ], + "240592" : [ "09:52", "350000", "140652" ], + "240593" : [ "09:53", "350000", "140653" ], + "240594" : [ "09:54", "350000", "140654" ], + "240595" : [ "09:55", "350000", "140655" ], + "240596" : [ "09:56", "350000", "140656" ], + "240597" : [ "09:57", "350000", "140657" ], + "240598" : [ "09:58", "350000", "140658" ], + "240599" : [ "09:59", "350000", "140659" ], + "240600" : [ "10:00", "350000", "140660" ], + "240601" : [ "10:01", "350000", "140661" ], + "240602" : [ "10:02", "350000", "140662" ], + "240603" : [ "10:03", "350000", "140663" ], + "240604" : [ "10:04", "350000", "140664" ], + "240605" : [ "10:05", "350000", "140665" ], + "240606" : [ "10:06", "350000", "140666" ], + "240607" : [ "10:07", "350000", "140667" ], + "240608" : [ "10:08", "350000", "140668" ], + "240609" : [ "10:09", "350000", "140669" ], + "240610" : [ "10:10", "350000", "140670" ], + "240611" : [ "10:11", "350000", "140671" ], + "240612" : [ "10:12", "350000", "140672" ], + "240613" : [ "10:13", "350000", "140673" ], + "240614" : [ "10:14", "350000", "140674" ], + "240615" : [ "10:15", "350000", "140675" ], + "240616" : [ "10:16", "350000", "140676" ], + "240617" : [ "10:17", "350000", "140677" ], + "240618" : [ "10:18", "350000", "140678" ], + "240619" : [ "10:19", "350000", "140679" ], + "240620" : [ "10:20", "350000", "140680" ], + "240621" : [ "10:21", "350000", "140681" ], + "240622" : [ "10:22", "350000", "140682" ], + "240623" : [ "10:23", "350000", "140683" ], + "240624" : [ "10:24", "350000", "140684" ], + "240625" : [ "10:25", "350000", "140685" ], + "240626" : [ "10:26", "350000", "140686" ], + "240627" : [ "10:27", "350000", "140687" ], + "240628" : [ "10:28", "350000", "140688" ], + "240629" : [ "10:29", "350000", "140689" ], + "240630" : [ "10:30", "350000", "140690" ], + "240631" : [ "10:31", "350000", "140691" ], + "240632" : [ "10:32", "350000", "140692" ], + "240633" : [ "10:33", "350000", "140693" ], + "240634" : [ "10:34", "350000", "140694" ], + "240635" : [ "10:35", "350000", "140695" ], + "240636" : [ "10:36", "350000", "140696" ], + "240637" : [ "10:37", "350000", "140697" ], + "240638" : [ "10:38", "350000", "140698" ], + "240639" : [ "10:39", "350000", "140699" ], + "240640" : [ "10:40", "350000", "140700" ], + "240641" : [ "10:41", "350000", "140701" ], + "240642" : [ "10:42", "350000", "140702" ], + "240643" : [ "10:43", "350000", "140703" ], + "240644" : [ "10:44", "350000", "140704" ], + "240645" : [ "10:45", "350000", "140705" ], + "240646" : [ "10:46", "350000", "140706" ], + "240647" : [ "10:47", "350000", "140707" ], + "240648" : [ "10:48", "350000", "140708" ], + "240649" : [ "10:49", "350000", "140709" ], + "240650" : [ "10:50", "350000", "140710" ], + "240651" : [ "10:51", "350000", "140711" ], + "240652" : [ "10:52", "350000", "140712" ], + "240653" : [ "10:53", "350000", "140713" ], + "240654" : [ "10:54", "350000", "140714" ], + "240655" : [ "10:55", "350000", "140715" ], + "240656" : [ "10:56", "350000", "140716" ], + "240657" : [ "10:57", "350000", "140717" ], + "240658" : [ "10:58", "350000", "140718" ], + "240659" : [ "10:59", "350000", "140719" ], + "240660" : [ "11:00", "350000", "140720" ], + "240661" : [ "11:01", "350000", "140721" ], + "240662" : [ "11:02", "350000", "140722" ], + "240663" : [ "11:03", "350000", "140723" ], + "240664" : [ "11:04", "350000", "140724" ], + "240665" : [ "11:05", "350000", "140725" ], + "240666" : [ "11:06", "350000", "140726" ], + "240667" : [ "11:07", "350000", "140727" ], + "240668" : [ "11:08", "350000", "140728" ], + "240669" : [ "11:09", "350000", "140729" ], + "240670" : [ "11:10", "350000", "140730" ], + "240671" : [ "11:11", "350000", "140731" ], + "240672" : [ "11:12", "350000", "140732" ], + "240673" : [ "11:13", "350000", "140733" ], + "240674" : [ "11:14", "350000", "140734" ], + "240675" : [ "11:15", "350000", "140735" ], + "240676" : [ "11:16", "350000", "140736" ], + "240677" : [ "11:17", "350000", "140737" ], + "240678" : [ "11:18", "350000", "140738" ], + "240679" : [ "11:19", "350000", "140739" ], + "240680" : [ "11:20", "350000", "140740" ], + "240681" : [ "11:21", "350000", "140741" ], + "240682" : [ "11:22", "350000", "140742" ], + "240683" : [ "11:23", "350000", "140743" ], + "240684" : [ "11:24", "350000", "140744" ], + "240685" : [ "11:25", "350000", "140745" ], + "240686" : [ "11:26", "350000", "140746" ], + "240687" : [ "11:27", "350000", "140747" ], + "240688" : [ "11:28", "350000", "140748" ], + "240689" : [ "11:29", "350000", "140749" ], + "240690" : [ "11:30", "350000", "140750" ], + "240691" : [ "11:31", "350000", "140751" ], + "240692" : [ "11:32", "350000", "140752" ], + "240693" : [ "11:33", "350000", "140753" ], + "240694" : [ "11:34", "350000", "140754" ], + "240695" : [ "11:35", "350000", "140755" ], + "240696" : [ "11:36", "350000", "140756" ], + "240697" : [ "11:37", "350000", "140757" ], + "240698" : [ "11:38", "350000", "140758" ], + "240699" : [ "11:39", "350000", "140759" ], + "240700" : [ "11:40", "350000", "140760" ], + "240701" : [ "11:41", "350000", "140761" ], + "240702" : [ "11:42", "350000", "140762" ], + "240703" : [ "11:43", "350000", "140763" ], + "240704" : [ "11:44", "350000", "140764" ], + "240705" : [ "11:45", "350000", "140765" ], + "240706" : [ "11:46", "350000", "140766" ], + "240707" : [ "11:47", "350000", "140767" ], + "240708" : [ "11:48", "350000", "140768" ], + "240709" : [ "11:49", "350000", "140769" ], + "240710" : [ "11:50", "350000", "140770" ], + "240711" : [ "11:51", "350000", "140771" ], + "240712" : [ "11:52", "350000", "140772" ], + "240713" : [ "11:53", "350000", "140773" ], + "240714" : [ "11:54", "350000", "140774" ], + "240715" : [ "11:55", "350000", "140775" ], + "240716" : [ "11:56", "350000", "140776" ], + "240717" : [ "11:57", "350000", "140777" ], + "240718" : [ "11:58", "350000", "140778" ], + "240719" : [ "11:59", "350000", "140779" ], + "240720" : [ "12:00", "350000", "140780" ], + "240721" : [ "12:01", "350000", "140781" ], + "240722" : [ "12:02", "350000", "140782" ], + "240723" : [ "12:03", "350000", "140783" ], + "240724" : [ "12:04", "350000", "140784" ], + "240725" : [ "12:05", "350000", "140785" ], + "240726" : [ "12:06", "350000", "140786" ], + "240727" : [ "12:07", "350000", "140787" ], + "240728" : [ "12:08", "350000", "140788" ], + "240729" : [ "12:09", "350000", "140789" ], + "240730" : [ "12:10", "350000", "140790" ], + "240731" : [ "12:11", "350000", "140791" ], + "240732" : [ "12:12", "350000", "140792" ], + "240733" : [ "12:13", "350000", "140793" ], + "240734" : [ "12:14", "350000", "140794" ], + "240735" : [ "12:15", "350000", "140795" ], + "240736" : [ "12:16", "350000", "140796" ], + "240737" : [ "12:17", "350000", "140797" ], + "240738" : [ "12:18", "350000", "140798" ], + "240739" : [ "12:19", "350000", "140799" ], + "240740" : [ "12:20", "350000", "140800" ], + "240741" : [ "12:21", "350000", "140801" ], + "240742" : [ "12:22", "350000", "140802" ], + "240743" : [ "12:23", "350000", "140803" ], + "240744" : [ "12:24", "350000", "140804" ], + "240745" : [ "12:25", "350000", "140805" ], + "240746" : [ "12:26", "350000", "140806" ], + "240747" : [ "12:27", "350000", "140807" ], + "240748" : [ "12:28", "350000", "140808" ], + "240749" : [ "12:29", "350000", "140809" ], + "240750" : [ "12:30", "350000", "140810" ], + "240751" : [ "12:31", "350000", "140811" ], + "240752" : [ "12:32", "350000", "140812" ], + "240753" : [ "12:33", "350000", "140813" ], + "240754" : [ "12:34", "350000", "140814" ], + "240755" : [ "12:35", "350000", "140815" ], + "240756" : [ "12:36", "350000", "140816" ], + "240757" : [ "12:37", "350000", "140817" ], + "240758" : [ "12:38", "350000", "140818" ], + "240759" : [ "12:39", "350000", "140819" ], + "240760" : [ "12:40", "350000", "140820" ], + "240761" : [ "12:41", "350000", "140821" ], + "240762" : [ "12:42", "350000", "140822" ], + "240763" : [ "12:43", "350000", "140823" ], + "240764" : [ "12:44", "350000", "140824" ], + "240765" : [ "12:45", "350000", "140825" ], + "240766" : [ "12:46", "350000", "140826" ], + "240767" : [ "12:47", "350000", "140827" ], + "240768" : [ "12:48", "350000", "140828" ], + "240769" : [ "12:49", "350000", "140829" ], + "240770" : [ "12:50", "350000", "140830" ], + "240771" : [ "12:51", "350000", "140831" ], + "240772" : [ "12:52", "350000", "140832" ], + "240773" : [ "12:53", "350000", "140833" ], + "240774" : [ "12:54", "350000", "140834" ], + "240775" : [ "12:55", "350000", "140835" ], + "240776" : [ "12:56", "350000", "140836" ], + "240777" : [ "12:57", "350000", "140837" ], + "240778" : [ "12:58", "350000", "140838" ], + "240779" : [ "12:59", "350000", "140839" ], + "240780" : [ "13:00", "350000", "140840" ], + "240781" : [ "13:01", "350000", "140841" ], + "240782" : [ "13:02", "350000", "140842" ], + "240783" : [ "13:03", "350000", "140843" ], + "240784" : [ "13:04", "350000", "140844" ], + "240785" : [ "13:05", "350000", "140845" ], + "240786" : [ "13:06", "350000", "140846" ], + "240787" : [ "13:07", "350000", "140847" ], + "240788" : [ "13:08", "350000", "140848" ], + "240789" : [ "13:09", "350000", "140849" ], + "240790" : [ "13:10", "350000", "140850" ], + "240791" : [ "13:11", "350000", "140851" ], + "240792" : [ "13:12", "350000", "140852" ], + "240793" : [ "13:13", "350000", "140853" ], + "240794" : [ "13:14", "350000", "140854" ], + "240795" : [ "13:15", "350000", "140855" ], + "240796" : [ "13:16", "350000", "140856" ], + "240797" : [ "13:17", "350000", "140857" ], + "240798" : [ "13:18", "350000", "140858" ], + "240799" : [ "13:19", "350000", "140859" ], + "240800" : [ "13:20", "350000", "140860" ], + "240801" : [ "13:21", "350000", "140861" ], + "240802" : [ "13:22", "350000", "140862" ], + "240803" : [ "13:23", "350000", "140863" ], + "240804" : [ "13:24", "350000", "140864" ], + "240805" : [ "13:25", "350000", "140865" ], + "240806" : [ "13:26", "350000", "140866" ], + "240807" : [ "13:27", "350000", "140867" ], + "240808" : [ "13:28", "350000", "140868" ], + "240809" : [ "13:29", "350000", "140869" ], + "240810" : [ "13:30", "350000", "140870" ], + "240811" : [ "13:31", "350000", "140871" ], + "240812" : [ "13:32", "350000", "140872" ], + "240813" : [ "13:33", "350000", "140873" ], + "240814" : [ "13:34", "350000", "140874" ], + "240815" : [ "13:35", "350000", "140875" ], + "240816" : [ "13:36", "350000", "140876" ], + "240817" : [ "13:37", "350000", "140877" ], + "240818" : [ "13:38", "350000", "140878" ], + "240819" : [ "13:39", "350000", "140879" ], + "240820" : [ "13:40", "350000", "140880" ], + "240821" : [ "13:41", "350000", "140881" ], + "240822" : [ "13:42", "350000", "140882" ], + "240823" : [ "13:43", "350000", "140883" ], + "240824" : [ "13:44", "350000", "140884" ], + "240825" : [ "13:45", "350000", "140885" ], + "240826" : [ "13:46", "350000", "140886" ], + "240827" : [ "13:47", "350000", "140887" ], + "240828" : [ "13:48", "350000", "140888" ], + "240829" : [ "13:49", "350000", "140889" ], + "240830" : [ "13:50", "350000", "140890" ], + "240831" : [ "13:51", "350000", "140891" ], + "240832" : [ "13:52", "350000", "140892" ], + "240833" : [ "13:53", "350000", "140893" ], + "240834" : [ "13:54", "350000", "140894" ], + "240835" : [ "13:55", "350000", "140895" ], + "240836" : [ "13:56", "350000", "140896" ], + "240837" : [ "13:57", "350000", "140897" ], + "240838" : [ "13:58", "350000", "140898" ], + "240839" : [ "13:59", "350000", "140899" ], + "240840" : [ "14:00", "350000", "140900" ], + "240841" : [ "14:01", "350000", "140901" ], + "240842" : [ "14:02", "350000", "140902" ], + "240843" : [ "14:03", "350000", "140903" ], + "240844" : [ "14:04", "350000", "140904" ], + "240845" : [ "14:05", "350000", "140905" ], + "240846" : [ "14:06", "350000", "140906" ], + "240847" : [ "14:07", "350000", "140907" ], + "240848" : [ "14:08", "350000", "140908" ], + "240849" : [ "14:09", "350000", "140909" ], + "240850" : [ "14:10", "350000", "140910" ], + "240851" : [ "14:11", "350000", "140911" ], + "240852" : [ "14:12", "350000", "140912" ], + "240853" : [ "14:13", "350000", "140913" ], + "240854" : [ "14:14", "350000", "140914" ], + "240855" : [ "14:15", "350000", "140915" ], + "240856" : [ "14:16", "350000", "140916" ], + "240857" : [ "14:17", "350000", "140917" ], + "240858" : [ "14:18", "350000", "140918" ], + "240859" : [ "14:19", "350000", "140919" ], + "240860" : [ "14:20", "350000", "140920" ], + "240861" : [ "14:21", "350000", "140921" ], + "240862" : [ "14:22", "350000", "140922" ], + "240863" : [ "14:23", "350000", "140923" ], + "240864" : [ "14:24", "350000", "140924" ], + "240865" : [ "14:25", "350000", "140925" ], + "240866" : [ "14:26", "350000", "140926" ], + "240867" : [ "14:27", "350000", "140927" ], + "240868" : [ "14:28", "350000", "140928" ], + "240869" : [ "14:29", "350000", "140929" ], + "240870" : [ "14:30", "350000", "140930" ], + "240871" : [ "14:31", "350000", "140931" ], + "240872" : [ "14:32", "350000", "140932" ], + "240873" : [ "14:33", "350000", "140933" ], + "240874" : [ "14:34", "350000", "140934" ], + "240875" : [ "14:35", "350000", "140935" ], + "240876" : [ "14:36", "350000", "140936" ], + "240877" : [ "14:37", "350000", "140937" ], + "240878" : [ "14:38", "350000", "140938" ], + "240879" : [ "14:39", "350000", "140939" ], + "240880" : [ "14:40", "350000", "140940" ], + "240881" : [ "14:41", "350000", "140941" ], + "240882" : [ "14:42", "350000", "140942" ], + "240883" : [ "14:43", "350000", "140943" ], + "240884" : [ "14:44", "350000", "140944" ], + "240885" : [ "14:45", "350000", "140945" ], + "240886" : [ "14:46", "350000", "140946" ], + "240887" : [ "14:47", "350000", "140947" ], + "240888" : [ "14:48", "350000", "140948" ], + "240889" : [ "14:49", "350000", "140949" ], + "240890" : [ "14:50", "350000", "140950" ], + "240891" : [ "14:51", "350000", "140951" ], + "240892" : [ "14:52", "350000", "140952" ], + "240893" : [ "14:53", "350000", "140953" ], + "240894" : [ "14:54", "350000", "140954" ], + "240895" : [ "14:55", "350000", "140955" ], + "240896" : [ "14:56", "350000", "140956" ], + "240897" : [ "14:57", "350000", "140957" ], + "240898" : [ "14:58", "350000", "140958" ], + "240899" : [ "14:59", "350000", "140959" ], + "240900" : [ "15:00", "350000", "140960" ], + "240901" : [ "15:01", "350000", "140961" ], + "240902" : [ "15:02", "350000", "140962" ], + "240903" : [ "15:03", "350000", "140963" ], + "240904" : [ "15:04", "350000", "140964" ], + "240905" : [ "15:05", "350000", "140965" ], + "240906" : [ "15:06", "350000", "140966" ], + "240907" : [ "15:07", "350000", "140967" ], + "240908" : [ "15:08", "350000", "140968" ], + "240909" : [ "15:09", "350000", "140969" ], + "240910" : [ "15:10", "350000", "140970" ], + "240911" : [ "15:11", "350000", "140971" ], + "240912" : [ "15:12", "350000", "140972" ], + "240913" : [ "15:13", "350000", "140973" ], + "240914" : [ "15:14", "350000", "140974" ], + "240915" : [ "15:15", "350000", "140975" ], + "240916" : [ "15:16", "350000", "140976" ], + "240917" : [ "15:17", "350000", "140977" ], + "240918" : [ "15:18", "350000", "140978" ], + "240919" : [ "15:19", "350000", "140979" ], + "240920" : [ "15:20", "350000", "140980" ], + "240921" : [ "15:21", "350000", "140981" ], + "240922" : [ "15:22", "350000", "140982" ], + "240923" : [ "15:23", "350000", "140983" ], + "240924" : [ "15:24", "350000", "140984" ], + "240925" : [ "15:25", "350000", "140985" ], + "240926" : [ "15:26", "350000", "140986" ], + "240927" : [ "15:27", "350000", "140987" ], + "240928" : [ "15:28", "350000", "140988" ], + "240929" : [ "15:29", "350000", "140989" ], + "240930" : [ "15:30", "350000", "140990" ], + "240931" : [ "15:31", "350000", "140991" ], + "240932" : [ "15:32", "350000", "140992" ], + "240933" : [ "15:33", "350000", "140993" ], + "240934" : [ "15:34", "350000", "140994" ], + "240935" : [ "15:35", "350000", "140995" ], + "240936" : [ "15:36", "350000", "140996" ], + "240937" : [ "15:37", "350000", "140997" ], + "240938" : [ "15:38", "350000", "140998" ], + "240939" : [ "15:39", "350000", "140999" ], + "240940" : [ "15:40", "350000", "141000" ], + "240941" : [ "15:41", "350000", "141001" ], + "240942" : [ "15:42", "350000", "141002" ], + "240943" : [ "15:43", "350000", "141003" ], + "240944" : [ "15:44", "350000", "141004" ], + "240945" : [ "15:45", "350000", "141005" ], + "240946" : [ "15:46", "350000", "141006" ], + "240947" : [ "15:47", "350000", "141007" ], + "240948" : [ "15:48", "350000", "141008" ], + "240949" : [ "15:49", "350000", "141009" ], + "240950" : [ "15:50", "350000", "141010" ], + "240951" : [ "15:51", "350000", "141011" ], + "240952" : [ "15:52", "350000", "141012" ], + "240953" : [ "15:53", "350000", "141013" ], + "240954" : [ "15:54", "350000", "141014" ], + "240955" : [ "15:55", "350000", "141015" ], + "240956" : [ "15:56", "350000", "141016" ], + "240957" : [ "15:57", "350000", "141017" ], + "240958" : [ "15:58", "350000", "141018" ], + "240959" : [ "15:59", "350000", "141019" ], + "240960" : [ "16:00", "350000", "141020" ], + "240961" : [ "16:01", "350000", "141021" ], + "240962" : [ "16:02", "350000", "141022" ], + "240963" : [ "16:03", "350000", "141023" ], + "240964" : [ "16:04", "350000", "141024" ], + "240965" : [ "16:05", "350000", "141025" ], + "240966" : [ "16:06", "350000", "141026" ], + "240967" : [ "16:07", "350000", "141027" ], + "240968" : [ "16:08", "350000", "141028" ], + "240969" : [ "16:09", "350000", "141029" ], + "240970" : [ "16:10", "350000", "141030" ], + "240971" : [ "16:11", "350000", "141031" ], + "240972" : [ "16:12", "350000", "141032" ], + "240973" : [ "16:13", "350000", "141033" ], + "240974" : [ "16:14", "350000", "141034" ], + "240975" : [ "16:15", "350000", "141035" ], + "240976" : [ "16:16", "350000", "141036" ], + "240977" : [ "16:17", "350000", "141037" ], + "240978" : [ "16:18", "350000", "141038" ], + "240979" : [ "16:19", "350000", "141039" ], + "240980" : [ "16:20", "350000", "141040" ], + "240981" : [ "16:21", "350000", "141041" ], + "240982" : [ "16:22", "350000", "141042" ], + "240983" : [ "16:23", "350000", "141043" ], + "240984" : [ "16:24", "350000", "141044" ], + "240985" : [ "16:25", "350000", "141045" ], + "240986" : [ "16:26", "350000", "141046" ], + "240987" : [ "16:27", "350000", "141047" ], + "240988" : [ "16:28", "350000", "141048" ], + "240989" : [ "16:29", "350000", "141049" ], + "240990" : [ "16:30", "350000", "141050" ], + "240991" : [ "16:31", "350000", "141051" ], + "240992" : [ "16:32", "350000", "141052" ], + "240993" : [ "16:33", "350000", "141053" ], + "240994" : [ "16:34", "350000", "141054" ], + "240995" : [ "16:35", "350000", "141055" ], + "240996" : [ "16:36", "350000", "141056" ], + "240997" : [ "16:37", "350000", "141057" ], + "240998" : [ "16:38", "350000", "141058" ], + "240999" : [ "16:39", "350000", "141059" ], + "241000" : [ "16:40", "350000", "141060" ], + "241001" : [ "16:41", "350000", "141061" ], + "241002" : [ "16:42", "350000", "141062" ], + "241003" : [ "16:43", "350000", "141063" ], + "241004" : [ "16:44", "350000", "141064" ], + "241005" : [ "16:45", "350000", "141065" ], + "241006" : [ "16:46", "350000", "141066" ], + "241007" : [ "16:47", "350000", "141067" ], + "241008" : [ "16:48", "350000", "141068" ], + "241009" : [ "16:49", "350000", "141069" ], + "241010" : [ "16:50", "350000", "141070" ], + "241011" : [ "16:51", "350000", "141071" ], + "241012" : [ "16:52", "350000", "141072" ], + "241013" : [ "16:53", "350000", "141073" ], + "241014" : [ "16:54", "350000", "141074" ], + "241015" : [ "16:55", "350000", "141075" ], + "241016" : [ "16:56", "350000", "141076" ], + "241017" : [ "16:57", "350000", "141077" ], + "241018" : [ "16:58", "350000", "141078" ], + "241019" : [ "16:59", "350000", "141079" ], + "241020" : [ "17:00", "350000", "141080" ], + "241021" : [ "17:01", "350000", "141081" ], + "241022" : [ "17:02", "350000", "141082" ], + "241023" : [ "17:03", "350000", "141083" ], + "241024" : [ "17:04", "350000", "141084" ], + "241025" : [ "17:05", "350000", "141085" ], + "241026" : [ "17:06", "350000", "141086" ], + "241027" : [ "17:07", "350000", "141087" ], + "241028" : [ "17:08", "350000", "141088" ], + "241029" : [ "17:09", "350000", "141089" ], + "241030" : [ "17:10", "350000", "141090" ], + "241031" : [ "17:11", "350000", "141091" ], + "241032" : [ "17:12", "350000", "141092" ], + "241033" : [ "17:13", "350000", "141093" ], + "241034" : [ "17:14", "350000", "141094" ], + "241035" : [ "17:15", "350000", "141095" ], + "241036" : [ "17:16", "350000", "141096" ], + "241037" : [ "17:17", "350000", "141097" ], + "241038" : [ "17:18", "350000", "141098" ], + "241039" : [ "17:19", "350000", "141099" ], + "241040" : [ "17:20", "350000", "141100" ], + "241041" : [ "17:21", "350000", "141101" ], + "241042" : [ "17:22", "350000", "141102" ], + "241043" : [ "17:23", "350000", "141103" ], + "241044" : [ "17:24", "350000", "141104" ], + "241045" : [ "17:25", "350000", "141105" ], + "241046" : [ "17:26", "350000", "141106" ], + "241047" : [ "17:27", "350000", "141107" ], + "241048" : [ "17:28", "350000", "141108" ], + "241049" : [ "17:29", "350000", "141109" ], + "241050" : [ "17:30", "350000", "141110" ], + "241051" : [ "17:31", "350000", "141111" ], + "241052" : [ "17:32", "350000", "141112" ], + "241053" : [ "17:33", "350000", "141113" ], + "241054" : [ "17:34", "350000", "141114" ], + "241055" : [ "17:35", "350000", "141115" ], + "241056" : [ "17:36", "350000", "141116" ], + "241057" : [ "17:37", "350000", "141117" ], + "241058" : [ "17:38", "350000", "141118" ], + "241059" : [ "17:39", "350000", "141119" ], + "241060" : [ "17:40", "350000", "141120" ], + "241061" : [ "17:41", "350000", "141121" ], + "241062" : [ "17:42", "350000", "141122" ], + "241063" : [ "17:43", "350000", "141123" ], + "241064" : [ "17:44", "350000", "141124" ], + "241065" : [ "17:45", "350000", "141125" ], + "241066" : [ "17:46", "350000", "141126" ], + "241067" : [ "17:47", "350000", "141127" ], + "241068" : [ "17:48", "350000", "141128" ], + "241069" : [ "17:49", "350000", "141129" ], + "241070" : [ "17:50", "350000", "141130" ], + "241071" : [ "17:51", "350000", "141131" ], + "241072" : [ "17:52", "350000", "141132" ], + "241073" : [ "17:53", "350000", "141133" ], + "241074" : [ "17:54", "350000", "141134" ], + "241075" : [ "17:55", "350000", "141135" ], + "241076" : [ "17:56", "350000", "141136" ], + "241077" : [ "17:57", "350000", "141137" ], + "241078" : [ "17:58", "350000", "141138" ], + "241079" : [ "17:59", "350000", "141139" ], + "241080" : [ "18:00", "350000", "141140" ], + "241081" : [ "18:01", "350000", "141141" ], + "241082" : [ "18:02", "350000", "141142" ], + "241083" : [ "18:03", "350000", "141143" ], + "241084" : [ "18:04", "350000", "141144" ], + "241085" : [ "18:05", "350000", "141145" ], + "241086" : [ "18:06", "350000", "141146" ], + "241087" : [ "18:07", "350000", "141147" ], + "241088" : [ "18:08", "350000", "141148" ], + "241089" : [ "18:09", "350000", "141149" ], + "241090" : [ "18:10", "350000", "141150" ], + "241091" : [ "18:11", "350000", "141151" ], + "241092" : [ "18:12", "350000", "141152" ], + "241093" : [ "18:13", "350000", "141153" ], + "241094" : [ "18:14", "350000", "141154" ], + "241095" : [ "18:15", "350000", "141155" ], + "241096" : [ "18:16", "350000", "141156" ], + "241097" : [ "18:17", "350000", "141157" ], + "241098" : [ "18:18", "350000", "141158" ], + "241099" : [ "18:19", "350000", "141159" ], + "241100" : [ "18:20", "350000", "141160" ], + "241101" : [ "18:21", "350000", "141161" ], + "241102" : [ "18:22", "350000", "141162" ], + "241103" : [ "18:23", "350000", "141163" ], + "241104" : [ "18:24", "350000", "141164" ], + "241105" : [ "18:25", "350000", "141165" ], + "241106" : [ "18:26", "350000", "141166" ], + "241107" : [ "18:27", "350000", "141167" ], + "241108" : [ "18:28", "350000", "141168" ], + "241109" : [ "18:29", "350000", "141169" ], + "241110" : [ "18:30", "350000", "141170" ], + "241111" : [ "18:31", "350000", "141171" ], + "241112" : [ "18:32", "350000", "141172" ], + "241113" : [ "18:33", "350000", "141173" ], + "241114" : [ "18:34", "350000", "141174" ], + "241115" : [ "18:35", "350000", "141175" ], + "241116" : [ "18:36", "350000", "141176" ], + "241117" : [ "18:37", "350000", "141177" ], + "241118" : [ "18:38", "350000", "141178" ], + "241119" : [ "18:39", "350000", "141179" ], + "241120" : [ "18:40", "350000", "141180" ], + "241121" : [ "18:41", "350000", "141181" ], + "241122" : [ "18:42", "350000", "141182" ], + "241123" : [ "18:43", "350000", "141183" ], + "241124" : [ "18:44", "350000", "141184" ], + "241125" : [ "18:45", "350000", "141185" ], + "241126" : [ "18:46", "350000", "141186" ], + "241127" : [ "18:47", "350000", "141187" ], + "241128" : [ "18:48", "350000", "141188" ], + "241129" : [ "18:49", "350000", "141189" ], + "241130" : [ "18:50", "350000", "141190" ], + "241131" : [ "18:51", "350000", "141191" ], + "241132" : [ "18:52", "350000", "141192" ], + "241133" : [ "18:53", "350000", "141193" ], + "241134" : [ "18:54", "350000", "141194" ], + "241135" : [ "18:55", "350000", "141195" ], + "241136" : [ "18:56", "350000", "141196" ], + "241137" : [ "18:57", "350000", "141197" ], + "241138" : [ "18:58", "350000", "141198" ], + "241139" : [ "18:59", "350000", "141199" ], + "241140" : [ "19:00", "350000", "141200" ], + "241141" : [ "19:01", "350000", "141200" ], + "241142" : [ "19:02", "350000", "141200" ], + "241143" : [ "19:03", "350000", "141200" ], + "241144" : [ "19:04", "350000", "141200" ], + "241145" : [ "19:05", "350000", "141200" ], + "241146" : [ "19:06", "350000", "141200" ], + "241147" : [ "19:07", "350000", "141200" ], + "241148" : [ "19:08", "350000", "141200" ], + "241149" : [ "19:09", "350000", "141200" ], + "241150" : [ "19:10", "350000", "141200" ], + "241151" : [ "19:11", "350000", "141200" ], + "241152" : [ "19:12", "350000", "141200" ], + "241153" : [ "19:13", "350000", "141200" ], + "241154" : [ "19:14", "350000", "141200" ], + "241155" : [ "19:15", "350000", "141200" ], + "241156" : [ "19:16", "350000", "141200" ], + "241157" : [ "19:17", "350000", "141200" ], + "241158" : [ "19:18", "350000", "141200" ], + "241159" : [ "19:19", "350000", "141200" ], + "241160" : [ "19:20", "350000", "141200" ], + "241161" : [ "19:21", "350000", "141200" ], + "241162" : [ "19:22", "350000", "141200" ], + "241163" : [ "19:23", "350000", "141200" ], + "241164" : [ "19:24", "350000", "141200" ], + "241165" : [ "19:25", "350000", "141200" ], + "241166" : [ "19:26", "350000", "141200" ], + "241167" : [ "19:27", "350000", "141200" ], + "241168" : [ "19:28", "350000", "141200" ], + "241169" : [ "19:29", "350000", "141200" ], + "241170" : [ "19:30", "350000", "141200" ], + "241171" : [ "19:31", "350000", "141200" ], + "241172" : [ "19:32", "350000", "141200" ], + "241173" : [ "19:33", "350000", "141200" ], + "241174" : [ "19:34", "350000", "141200" ], + "241175" : [ "19:35", "350000", "141200" ], + "241176" : [ "19:36", "350000", "141200" ], + "241177" : [ "19:37", "350000", "141200" ], + "241178" : [ "19:38", "350000", "141200" ], + "241179" : [ "19:39", "350000", "141200" ], + "241180" : [ "19:40", "350000", "141200" ], + "241181" : [ "19:41", "350000", "141200" ], + "241182" : [ "19:42", "350000", "141200" ], + "241183" : [ "19:43", "350000", "141200" ], + "241184" : [ "19:44", "350000", "141200" ], + "241185" : [ "19:45", "350000", "141200" ], + "241186" : [ "19:46", "350000", "141200" ], + "241187" : [ "19:47", "350000", "141200" ], + "241188" : [ "19:48", "350000", "141200" ], + "241189" : [ "19:49", "350000", "141200" ], + "241190" : [ "19:50", "350000", "141200" ], + "241191" : [ "19:51", "350000", "141200" ], + "241192" : [ "19:52", "350000", "141200" ], + "241193" : [ "19:53", "350000", "141200" ], + "241194" : [ "19:54", "350000", "141200" ], + "241195" : [ "19:55", "350000", "141200" ], + "241196" : [ "19:56", "350000", "141200" ], + "241197" : [ "19:57", "350000", "141200" ], + "241198" : [ "19:58", "350000", "141200" ], + "241199" : [ "19:59", "350000", "141200" ], + "241200" : [ "20:00", "800000", "150420" ], + "241201" : [ "20:01", "800000", "150420" ], + "241202" : [ "20:02", "800000", "150420" ], + "241203" : [ "20:03", "800000", "150420" ], + "241204" : [ "20:04", "800000", "150420" ], + "241205" : [ "20:05", "800000", "150420" ], + "241206" : [ "20:06", "800000", "150420" ], + "241207" : [ "20:07", "800000", "150420" ], + "241208" : [ "20:08", "800000", "150420" ], + "241209" : [ "20:09", "800000", "150420" ], + "241210" : [ "20:10", "800000", "150420" ], + "241211" : [ "20:11", "800000", "150420" ], + "241212" : [ "20:12", "800000", "150420" ], + "241213" : [ "20:13", "800000", "150420" ], + "241214" : [ "20:14", "800000", "150420" ], + "241215" : [ "20:15", "800000", "150420" ], + "241216" : [ "20:16", "800000", "150420" ], + "241217" : [ "20:17", "800000", "150420" ], + "241218" : [ "20:18", "800000", "150420" ], + "241219" : [ "20:19", "800000", "150420" ], + "241220" : [ "20:20", "800000", "150420" ], + "241221" : [ "20:21", "800000", "150420" ], + "241222" : [ "20:22", "800000", "150420" ], + "241223" : [ "20:23", "800000", "150420" ], + "241224" : [ "20:24", "800000", "150420" ], + "241225" : [ "20:25", "800000", "150420" ], + "241226" : [ "20:26", "800000", "150420" ], + "241227" : [ "20:27", "800000", "150420" ], + "241228" : [ "20:28", "800000", "150420" ], + "241229" : [ "20:29", "800000", "150420" ], + "241230" : [ "20:30", "800000", "150420" ], + "241231" : [ "20:31", "800000", "150420" ], + "241232" : [ "20:32", "800000", "150420" ], + "241233" : [ "20:33", "800000", "150420" ], + "241234" : [ "20:34", "800000", "150420" ], + "241235" : [ "20:35", "800000", "150420" ], + "241236" : [ "20:36", "800000", "150420" ], + "241237" : [ "20:37", "800000", "150420" ], + "241238" : [ "20:38", "800000", "150420" ], + "241239" : [ "20:39", "800000", "150420" ], + "241240" : [ "20:40", "800000", "150420" ], + "241241" : [ "20:41", "800000", "150420" ], + "241242" : [ "20:42", "800000", "150420" ], + "241243" : [ "20:43", "800000", "150420" ], + "241244" : [ "20:44", "800000", "150420" ], + "241245" : [ "20:45", "800000", "150420" ], + "241246" : [ "20:46", "800000", "150420" ], + "241247" : [ "20:47", "800000", "150420" ], + "241248" : [ "20:48", "800000", "150420" ], + "241249" : [ "20:49", "800000", "150420" ], + "241250" : [ "20:50", "800000", "150420" ], + "241251" : [ "20:51", "800000", "150420" ], + "241252" : [ "20:52", "800000", "150420" ], + "241253" : [ "20:53", "800000", "150420" ], + "241254" : [ "20:54", "800000", "150420" ], + "241255" : [ "20:55", "800000", "150420" ], + "241256" : [ "20:56", "800000", "150420" ], + "241257" : [ "20:57", "800000", "150420" ], + "241258" : [ "20:58", "800000", "150420" ], + "241259" : [ "20:59", "800000", "150420" ], + "241260" : [ "21:00", "800000", "150420" ], + "241261" : [ "21:01", "800000", "150420" ], + "241262" : [ "21:02", "800000", "150420" ], + "241263" : [ "21:03", "800000", "150420" ], + "241264" : [ "21:04", "800000", "150420" ], + "241265" : [ "21:05", "800000", "150420" ], + "241266" : [ "21:06", "800000", "150420" ], + "241267" : [ "21:07", "800000", "150420" ], + "241268" : [ "21:08", "800000", "150420" ], + "241269" : [ "21:09", "800000", "150420" ], + "241270" : [ "21:10", "800000", "150420" ], + "241271" : [ "21:11", "800000", "150420" ], + "241272" : [ "21:12", "800000", "150420" ], + "241273" : [ "21:13", "800000", "150420" ], + "241274" : [ "21:14", "800000", "150420" ], + "241275" : [ "21:15", "800000", "150420" ], + "241276" : [ "21:16", "800000", "150420" ], + "241277" : [ "21:17", "800000", "150420" ], + "241278" : [ "21:18", "800000", "150420" ], + "241279" : [ "21:19", "800000", "150420" ], + "241280" : [ "21:20", "800000", "150420" ], + "241281" : [ "21:21", "800000", "150420" ], + "241282" : [ "21:22", "800000", "150420" ], + "241283" : [ "21:23", "800000", "150420" ], + "241284" : [ "21:24", "800000", "150420" ], + "241285" : [ "21:25", "800000", "150420" ], + "241286" : [ "21:26", "800000", "150420" ], + "241287" : [ "21:27", "800000", "150420" ], + "241288" : [ "21:28", "800000", "150420" ], + "241289" : [ "21:29", "800000", "150420" ], + "241290" : [ "21:30", "800000", "150420" ], + "241291" : [ "21:31", "800000", "150420" ], + "241292" : [ "21:32", "800000", "150420" ], + "241293" : [ "21:33", "800000", "150420" ], + "241294" : [ "21:34", "800000", "150420" ], + "241295" : [ "21:35", "800000", "150420" ], + "241296" : [ "21:36", "800000", "150420" ], + "241297" : [ "21:37", "800000", "150420" ], + "241298" : [ "21:38", "800000", "150420" ], + "241299" : [ "21:39", "800000", "150420" ], + "241300" : [ "21:40", "800000", "150420" ], + "241301" : [ "21:41", "800000", "150420" ], + "241302" : [ "21:42", "800000", "150420" ], + "241303" : [ "21:43", "800000", "150420" ], + "241304" : [ "21:44", "800000", "150420" ], + "241305" : [ "21:45", "800000", "150420" ], + "241306" : [ "21:46", "800000", "150420" ], + "241307" : [ "21:47", "800000", "150420" ], + "241308" : [ "21:48", "800000", "150420" ], + "241309" : [ "21:49", "800000", "150420" ], + "241310" : [ "21:50", "800000", "150420" ], + "241311" : [ "21:51", "800000", "150420" ], + "241312" : [ "21:52", "800000", "150420" ], + "241313" : [ "21:53", "800000", "150420" ], + "241314" : [ "21:54", "800000", "150420" ], + "241315" : [ "21:55", "800000", "150420" ], + "241316" : [ "21:56", "800000", "150420" ], + "241317" : [ "21:57", "800000", "150420" ], + "241318" : [ "21:58", "800000", "150420" ], + "241319" : [ "21:59", "800000", "150420" ], + "241320" : [ "22:00", "800000", "150420" ], + "241321" : [ "22:01", "800000", "150420" ], + "241322" : [ "22:02", "800000", "150420" ], + "241323" : [ "22:03", "800000", "150420" ], + "241324" : [ "22:04", "800000", "150420" ], + "241325" : [ "22:05", "800000", "150420" ], + "241326" : [ "22:06", "800000", "150420" ], + "241327" : [ "22:07", "800000", "150420" ], + "241328" : [ "22:08", "800000", "150420" ], + "241329" : [ "22:09", "800000", "150420" ], + "241330" : [ "22:10", "800000", "150420" ], + "241331" : [ "22:11", "800000", "150420" ], + "241332" : [ "22:12", "800000", "150420" ], + "241333" : [ "22:13", "800000", "150420" ], + "241334" : [ "22:14", "800000", "150420" ], + "241335" : [ "22:15", "800000", "150420" ], + "241336" : [ "22:16", "800000", "150420" ], + "241337" : [ "22:17", "800000", "150420" ], + "241338" : [ "22:18", "800000", "150420" ], + "241339" : [ "22:19", "800000", "150420" ], + "241340" : [ "22:20", "800000", "150420" ], + "241341" : [ "22:21", "800000", "150420" ], + "241342" : [ "22:22", "800000", "150420" ], + "241343" : [ "22:23", "800000", "150420" ], + "241344" : [ "22:24", "800000", "150420" ], + "241345" : [ "22:25", "800000", "150420" ], + "241346" : [ "22:26", "800000", "150420" ], + "241347" : [ "22:27", "800000", "150420" ], + "241348" : [ "22:28", "800000", "150420" ], + "241349" : [ "22:29", "800000", "150420" ], + "241350" : [ "22:30", "800000", "150420" ], + "241351" : [ "22:31", "800000", "150420" ], + "241352" : [ "22:32", "800000", "150420" ], + "241353" : [ "22:33", "800000", "150420" ], + "241354" : [ "22:34", "800000", "150420" ], + "241355" : [ "22:35", "800000", "150420" ], + "241356" : [ "22:36", "800000", "150420" ], + "241357" : [ "22:37", "800000", "150420" ], + "241358" : [ "22:38", "800000", "150420" ], + "241359" : [ "22:39", "800000", "150420" ], + "241360" : [ "22:40", "800000", "150420" ], + "241361" : [ "22:41", "800000", "150420" ], + "241362" : [ "22:42", "800000", "150420" ], + "241363" : [ "22:43", "800000", "150420" ], + "241364" : [ "22:44", "800000", "150420" ], + "241365" : [ "22:45", "800000", "150420" ], + "241366" : [ "22:46", "800000", "150420" ], + "241367" : [ "22:47", "800000", "150420" ], + "241368" : [ "22:48", "800000", "150420" ], + "241369" : [ "22:49", "800000", "150420" ], + "241370" : [ "22:50", "800000", "150420" ], + "241371" : [ "22:51", "800000", "150420" ], + "241372" : [ "22:52", "800000", "150420" ], + "241373" : [ "22:53", "800000", "150420" ], + "241374" : [ "22:54", "800000", "150420" ], + "241375" : [ "22:55", "800000", "150420" ], + "241376" : [ "22:56", "800000", "150420" ], + "241377" : [ "22:57", "800000", "150420" ], + "241378" : [ "22:58", "800000", "150420" ], + "241379" : [ "22:59", "800000", "150420" ], + "241380" : [ "23:00", "800000", "150420" ], + "241381" : [ "23:01", "800000", "150420" ], + "241382" : [ "23:02", "800000", "150420" ], + "241383" : [ "23:03", "800000", "150420" ], + "241384" : [ "23:04", "800000", "150420" ], + "241385" : [ "23:05", "800000", "150420" ], + "241386" : [ "23:06", "800000", "150420" ], + "241387" : [ "23:07", "800000", "150420" ], + "241388" : [ "23:08", "800000", "150420" ], + "241389" : [ "23:09", "800000", "150420" ], + "241390" : [ "23:10", "800000", "150420" ], + "241391" : [ "23:11", "800000", "150420" ], + "241392" : [ "23:12", "800000", "150420" ], + "241393" : [ "23:13", "800000", "150420" ], + "241394" : [ "23:14", "800000", "150420" ], + "241395" : [ "23:15", "800000", "150420" ], + "241396" : [ "23:16", "800000", "150420" ], + "241397" : [ "23:17", "800000", "150420" ], + "241398" : [ "23:18", "800000", "150420" ], + "241399" : [ "23:19", "800000", "150420" ], + "241400" : [ "23:20", "800000", "150420" ], + "241401" : [ "23:21", "800000", "150420" ], + "241402" : [ "23:22", "800000", "150420" ], + "241403" : [ "23:23", "800000", "150420" ], + "241404" : [ "23:24", "800000", "150420" ], + "241405" : [ "23:25", "800000", "150420" ], + "241406" : [ "23:26", "800000", "150420" ], + "241407" : [ "23:27", "800000", "150420" ], + "241408" : [ "23:28", "800000", "150420" ], + "241409" : [ "23:29", "800000", "150420" ], + "241410" : [ "23:30", "800000", "150420" ], + "241411" : [ "23:31", "800000", "150420" ], + "241412" : [ "23:32", "800000", "150420" ], + "241413" : [ "23:33", "800000", "150420" ], + "241414" : [ "23:34", "800000", "150420" ], + "241415" : [ "23:35", "800000", "150420" ], + "241416" : [ "23:36", "800000", "150420" ], + "241417" : [ "23:37", "800000", "150420" ], + "241418" : [ "23:38", "800000", "150420" ], + "241419" : [ "23:39", "800000", "150420" ], + "241420" : [ "23:40", "800000", "150420" ], + "241421" : [ "23:41", "800000", "150420" ], + "241422" : [ "23:42", "800000", "150420" ], + "241423" : [ "23:43", "800000", "150420" ], + "241424" : [ "23:44", "800000", "150420" ], + "241425" : [ "23:45", "800000", "150420" ], + "241426" : [ "23:46", "800000", "150420" ], + "241427" : [ "23:47", "800000", "150420" ], + "241428" : [ "23:48", "800000", "150420" ], + "241429" : [ "23:49", "800000", "150420" ], + "241430" : [ "23:50", "800000", "150420" ], + "241431" : [ "23:51", "800000", "150420" ], + "241432" : [ "23:52", "800000", "150420" ], + "241433" : [ "23:53", "800000", "150420" ], + "241434" : [ "23:54", "800000", "150420" ], + "241435" : [ "23:55", "800000", "150420" ], + "241436" : [ "23:56", "800000", "150420" ], + "241437" : [ "23:57", "800000", "150420" ], + "241438" : [ "23:58", "800000", "150420" ], + "241439" : [ "23:59", "800000", "150420" ] + }, + "Saturday": { + "250000" : [ "00:00", "800000", "150420" ], + "250001" : [ "00:01", "800000", "150420" ], + "250002" : [ "00:02", "800000", "150420" ], + "250003" : [ "00:03", "800000", "150420" ], + "250004" : [ "00:04", "800000", "150420" ], + "250005" : [ "00:05", "800000", "150420" ], + "250006" : [ "00:06", "800000", "150420" ], + "250007" : [ "00:07", "800000", "150420" ], + "250008" : [ "00:08", "800000", "150420" ], + "250009" : [ "00:09", "800000", "150420" ], + "250010" : [ "00:10", "800000", "150420" ], + "250011" : [ "00:11", "800000", "150420" ], + "250012" : [ "00:12", "800000", "150420" ], + "250013" : [ "00:13", "800000", "150420" ], + "250014" : [ "00:14", "800000", "150420" ], + "250015" : [ "00:15", "800000", "150420" ], + "250016" : [ "00:16", "800000", "150420" ], + "250017" : [ "00:17", "800000", "150420" ], + "250018" : [ "00:18", "800000", "150420" ], + "250019" : [ "00:19", "800000", "150420" ], + "250020" : [ "00:20", "800000", "150420" ], + "250021" : [ "00:21", "800000", "150420" ], + "250022" : [ "00:22", "800000", "150420" ], + "250023" : [ "00:23", "800000", "150420" ], + "250024" : [ "00:24", "800000", "150420" ], + "250025" : [ "00:25", "800000", "150420" ], + "250026" : [ "00:26", "800000", "150420" ], + "250027" : [ "00:27", "800000", "150420" ], + "250028" : [ "00:28", "800000", "150420" ], + "250029" : [ "00:29", "800000", "150420" ], + "250030" : [ "00:30", "800000", "150420" ], + "250031" : [ "00:31", "800000", "150420" ], + "250032" : [ "00:32", "800000", "150420" ], + "250033" : [ "00:33", "800000", "150420" ], + "250034" : [ "00:34", "800000", "150420" ], + "250035" : [ "00:35", "800000", "150420" ], + "250036" : [ "00:36", "800000", "150420" ], + "250037" : [ "00:37", "800000", "150420" ], + "250038" : [ "00:38", "800000", "150420" ], + "250039" : [ "00:39", "800000", "150420" ], + "250040" : [ "00:40", "800000", "150420" ], + "250041" : [ "00:41", "800000", "150420" ], + "250042" : [ "00:42", "800000", "150420" ], + "250043" : [ "00:43", "800000", "150420" ], + "250044" : [ "00:44", "800000", "150420" ], + "250045" : [ "00:45", "800000", "150420" ], + "250046" : [ "00:46", "800000", "150420" ], + "250047" : [ "00:47", "800000", "150420" ], + "250048" : [ "00:48", "800000", "150420" ], + "250049" : [ "00:49", "800000", "150420" ], + "250050" : [ "00:50", "800000", "150420" ], + "250051" : [ "00:51", "800000", "150420" ], + "250052" : [ "00:52", "800000", "150420" ], + "250053" : [ "00:53", "800000", "150420" ], + "250054" : [ "00:54", "800000", "150420" ], + "250055" : [ "00:55", "800000", "150420" ], + "250056" : [ "00:56", "800000", "150420" ], + "250057" : [ "00:57", "800000", "150420" ], + "250058" : [ "00:58", "800000", "150420" ], + "250059" : [ "00:59", "800000", "150420" ], + "250060" : [ "01:00", "800000", "150420" ], + "250061" : [ "01:01", "800000", "150420" ], + "250062" : [ "01:02", "800000", "150420" ], + "250063" : [ "01:03", "800000", "150420" ], + "250064" : [ "01:04", "800000", "150420" ], + "250065" : [ "01:05", "800000", "150420" ], + "250066" : [ "01:06", "800000", "150420" ], + "250067" : [ "01:07", "800000", "150420" ], + "250068" : [ "01:08", "800000", "150420" ], + "250069" : [ "01:09", "800000", "150420" ], + "250070" : [ "01:10", "800000", "150420" ], + "250071" : [ "01:11", "800000", "150420" ], + "250072" : [ "01:12", "800000", "150420" ], + "250073" : [ "01:13", "800000", "150420" ], + "250074" : [ "01:14", "800000", "150420" ], + "250075" : [ "01:15", "800000", "150420" ], + "250076" : [ "01:16", "800000", "150420" ], + "250077" : [ "01:17", "800000", "150420" ], + "250078" : [ "01:18", "800000", "150420" ], + "250079" : [ "01:19", "800000", "150420" ], + "250080" : [ "01:20", "800000", "150420" ], + "250081" : [ "01:21", "800000", "150420" ], + "250082" : [ "01:22", "800000", "150420" ], + "250083" : [ "01:23", "800000", "150420" ], + "250084" : [ "01:24", "800000", "150420" ], + "250085" : [ "01:25", "800000", "150420" ], + "250086" : [ "01:26", "800000", "150420" ], + "250087" : [ "01:27", "800000", "150420" ], + "250088" : [ "01:28", "800000", "150420" ], + "250089" : [ "01:29", "800000", "150420" ], + "250090" : [ "01:30", "800000", "150420" ], + "250091" : [ "01:31", "800000", "150420" ], + "250092" : [ "01:32", "800000", "150420" ], + "250093" : [ "01:33", "800000", "150420" ], + "250094" : [ "01:34", "800000", "150420" ], + "250095" : [ "01:35", "800000", "150420" ], + "250096" : [ "01:36", "800000", "150420" ], + "250097" : [ "01:37", "800000", "150420" ], + "250098" : [ "01:38", "800000", "150420" ], + "250099" : [ "01:39", "800000", "150420" ], + "250100" : [ "01:40", "800000", "150420" ], + "250101" : [ "01:41", "800000", "150420" ], + "250102" : [ "01:42", "800000", "150420" ], + "250103" : [ "01:43", "800000", "150420" ], + "250104" : [ "01:44", "800000", "150420" ], + "250105" : [ "01:45", "800000", "150420" ], + "250106" : [ "01:46", "800000", "150420" ], + "250107" : [ "01:47", "800000", "150420" ], + "250108" : [ "01:48", "800000", "150420" ], + "250109" : [ "01:49", "800000", "150420" ], + "250110" : [ "01:50", "800000", "150420" ], + "250111" : [ "01:51", "800000", "150420" ], + "250112" : [ "01:52", "800000", "150420" ], + "250113" : [ "01:53", "800000", "150420" ], + "250114" : [ "01:54", "800000", "150420" ], + "250115" : [ "01:55", "800000", "150420" ], + "250116" : [ "01:56", "800000", "150420" ], + "250117" : [ "01:57", "800000", "150420" ], + "250118" : [ "01:58", "800000", "150420" ], + "250119" : [ "01:59", "800000", "150420" ], + "250120" : [ "02:00", "800000", "150420" ], + "250121" : [ "02:01", "800000", "150420" ], + "250122" : [ "02:02", "800000", "150420" ], + "250123" : [ "02:03", "800000", "150420" ], + "250124" : [ "02:04", "800000", "150420" ], + "250125" : [ "02:05", "800000", "150420" ], + "250126" : [ "02:06", "800000", "150420" ], + "250127" : [ "02:07", "800000", "150420" ], + "250128" : [ "02:08", "800000", "150420" ], + "250129" : [ "02:09", "800000", "150420" ], + "250130" : [ "02:10", "800000", "150420" ], + "250131" : [ "02:11", "800000", "150420" ], + "250132" : [ "02:12", "800000", "150420" ], + "250133" : [ "02:13", "800000", "150420" ], + "250134" : [ "02:14", "800000", "150420" ], + "250135" : [ "02:15", "800000", "150420" ], + "250136" : [ "02:16", "800000", "150420" ], + "250137" : [ "02:17", "800000", "150420" ], + "250138" : [ "02:18", "800000", "150420" ], + "250139" : [ "02:19", "800000", "150420" ], + "250140" : [ "02:20", "800000", "150420" ], + "250141" : [ "02:21", "800000", "150420" ], + "250142" : [ "02:22", "800000", "150420" ], + "250143" : [ "02:23", "800000", "150420" ], + "250144" : [ "02:24", "800000", "150420" ], + "250145" : [ "02:25", "800000", "150420" ], + "250146" : [ "02:26", "800000", "150420" ], + "250147" : [ "02:27", "800000", "150420" ], + "250148" : [ "02:28", "800000", "150420" ], + "250149" : [ "02:29", "800000", "150420" ], + "250150" : [ "02:30", "800000", "150420" ], + "250151" : [ "02:31", "800000", "150420" ], + "250152" : [ "02:32", "800000", "150420" ], + "250153" : [ "02:33", "800000", "150420" ], + "250154" : [ "02:34", "800000", "150420" ], + "250155" : [ "02:35", "800000", "150420" ], + "250156" : [ "02:36", "800000", "150420" ], + "250157" : [ "02:37", "800000", "150420" ], + "250158" : [ "02:38", "800000", "150420" ], + "250159" : [ "02:39", "800000", "150420" ], + "250160" : [ "02:40", "800000", "150420" ], + "250161" : [ "02:41", "800000", "150420" ], + "250162" : [ "02:42", "800000", "150420" ], + "250163" : [ "02:43", "800000", "150420" ], + "250164" : [ "02:44", "800000", "150420" ], + "250165" : [ "02:45", "800000", "150420" ], + "250166" : [ "02:46", "800000", "150420" ], + "250167" : [ "02:47", "800000", "150420" ], + "250168" : [ "02:48", "800000", "150420" ], + "250169" : [ "02:49", "800000", "150420" ], + "250170" : [ "02:50", "800000", "150420" ], + "250171" : [ "02:51", "800000", "150420" ], + "250172" : [ "02:52", "800000", "150420" ], + "250173" : [ "02:53", "800000", "150420" ], + "250174" : [ "02:54", "800000", "150420" ], + "250175" : [ "02:55", "800000", "150420" ], + "250176" : [ "02:56", "800000", "150420" ], + "250177" : [ "02:57", "800000", "150420" ], + "250178" : [ "02:58", "800000", "150420" ], + "250179" : [ "02:59", "800000", "150420" ], + "250180" : [ "03:00", "800000", "150420" ], + "250181" : [ "03:01", "800000", "150420" ], + "250182" : [ "03:02", "800000", "150420" ], + "250183" : [ "03:03", "800000", "150420" ], + "250184" : [ "03:04", "800000", "150420" ], + "250185" : [ "03:05", "800000", "150420" ], + "250186" : [ "03:06", "800000", "150420" ], + "250187" : [ "03:07", "800000", "150420" ], + "250188" : [ "03:08", "800000", "150420" ], + "250189" : [ "03:09", "800000", "150420" ], + "250190" : [ "03:10", "800000", "150420" ], + "250191" : [ "03:11", "800000", "150420" ], + "250192" : [ "03:12", "800000", "150420" ], + "250193" : [ "03:13", "800000", "150420" ], + "250194" : [ "03:14", "800000", "150420" ], + "250195" : [ "03:15", "800000", "150420" ], + "250196" : [ "03:16", "800000", "150420" ], + "250197" : [ "03:17", "800000", "150420" ], + "250198" : [ "03:18", "800000", "150420" ], + "250199" : [ "03:19", "800000", "150420" ], + "250200" : [ "03:20", "800000", "150420" ], + "250201" : [ "03:21", "800000", "150420" ], + "250202" : [ "03:22", "800000", "150420" ], + "250203" : [ "03:23", "800000", "150420" ], + "250204" : [ "03:24", "800000", "150420" ], + "250205" : [ "03:25", "800000", "150420" ], + "250206" : [ "03:26", "800000", "150420" ], + "250207" : [ "03:27", "800000", "150420" ], + "250208" : [ "03:28", "800000", "150420" ], + "250209" : [ "03:29", "800000", "150420" ], + "250210" : [ "03:30", "800000", "150420" ], + "250211" : [ "03:31", "800000", "150420" ], + "250212" : [ "03:32", "800000", "150420" ], + "250213" : [ "03:33", "800000", "150420" ], + "250214" : [ "03:34", "800000", "150420" ], + "250215" : [ "03:35", "800000", "150420" ], + "250216" : [ "03:36", "800000", "150420" ], + "250217" : [ "03:37", "800000", "150420" ], + "250218" : [ "03:38", "800000", "150420" ], + "250219" : [ "03:39", "800000", "150420" ], + "250220" : [ "03:40", "800000", "150420" ], + "250221" : [ "03:41", "800000", "150420" ], + "250222" : [ "03:42", "800000", "150420" ], + "250223" : [ "03:43", "800000", "150420" ], + "250224" : [ "03:44", "800000", "150420" ], + "250225" : [ "03:45", "800000", "150420" ], + "250226" : [ "03:46", "800000", "150420" ], + "250227" : [ "03:47", "800000", "150420" ], + "250228" : [ "03:48", "800000", "150420" ], + "250229" : [ "03:49", "800000", "150420" ], + "250230" : [ "03:50", "800000", "150420" ], + "250231" : [ "03:51", "800000", "150420" ], + "250232" : [ "03:52", "800000", "150420" ], + "250233" : [ "03:53", "800000", "150420" ], + "250234" : [ "03:54", "800000", "150420" ], + "250235" : [ "03:55", "800000", "150420" ], + "250236" : [ "03:56", "800000", "150420" ], + "250237" : [ "03:57", "800000", "150420" ], + "250238" : [ "03:58", "800000", "150420" ], + "250239" : [ "03:59", "800000", "150420" ], + "250240" : [ "04:00", "800000", "150420" ], + "250241" : [ "04:01", "800000", "150420" ], + "250242" : [ "04:02", "800000", "150420" ], + "250243" : [ "04:03", "800000", "150420" ], + "250244" : [ "04:04", "800000", "150420" ], + "250245" : [ "04:05", "800000", "150420" ], + "250246" : [ "04:06", "800000", "150420" ], + "250247" : [ "04:07", "800000", "150420" ], + "250248" : [ "04:08", "800000", "150420" ], + "250249" : [ "04:09", "800000", "150420" ], + "250250" : [ "04:10", "800000", "150420" ], + "250251" : [ "04:11", "800000", "150420" ], + "250252" : [ "04:12", "800000", "150420" ], + "250253" : [ "04:13", "800000", "150420" ], + "250254" : [ "04:14", "800000", "150420" ], + "250255" : [ "04:15", "800000", "150420" ], + "250256" : [ "04:16", "800000", "150420" ], + "250257" : [ "04:17", "800000", "150420" ], + "250258" : [ "04:18", "800000", "150420" ], + "250259" : [ "04:19", "800000", "150420" ], + "250260" : [ "04:20", "800000", "150420" ], + "250261" : [ "04:21", "800000", "150420" ], + "250262" : [ "04:22", "800000", "150420" ], + "250263" : [ "04:23", "800000", "150420" ], + "250264" : [ "04:24", "800000", "150420" ], + "250265" : [ "04:25", "800000", "150420" ], + "250266" : [ "04:26", "800000", "150420" ], + "250267" : [ "04:27", "800000", "150420" ], + "250268" : [ "04:28", "800000", "150420" ], + "250269" : [ "04:29", "800000", "150420" ], + "250270" : [ "04:30", "800000", "150420" ], + "250271" : [ "04:31", "800000", "150420" ], + "250272" : [ "04:32", "800000", "150420" ], + "250273" : [ "04:33", "800000", "150420" ], + "250274" : [ "04:34", "800000", "150420" ], + "250275" : [ "04:35", "800000", "150420" ], + "250276" : [ "04:36", "800000", "150420" ], + "250277" : [ "04:37", "800000", "150420" ], + "250278" : [ "04:38", "800000", "150420" ], + "250279" : [ "04:39", "800000", "150420" ], + "250280" : [ "04:40", "800000", "150420" ], + "250281" : [ "04:41", "800000", "150420" ], + "250282" : [ "04:42", "800000", "150420" ], + "250283" : [ "04:43", "800000", "150420" ], + "250284" : [ "04:44", "800000", "150420" ], + "250285" : [ "04:45", "800000", "150420" ], + "250286" : [ "04:46", "800000", "150420" ], + "250287" : [ "04:47", "800000", "150420" ], + "250288" : [ "04:48", "800000", "150420" ], + "250289" : [ "04:49", "800000", "150420" ], + "250290" : [ "04:50", "800000", "150420" ], + "250291" : [ "04:51", "800000", "150420" ], + "250292" : [ "04:52", "800000", "150420" ], + "250293" : [ "04:53", "800000", "150420" ], + "250294" : [ "04:54", "800000", "150420" ], + "250295" : [ "04:55", "800000", "150420" ], + "250296" : [ "04:56", "800000", "150420" ], + "250297" : [ "04:57", "800000", "150420" ], + "250298" : [ "04:58", "800000", "150420" ], + "250299" : [ "04:59", "800000", "150420" ], + "250300" : [ "05:00", "800000", "150420" ], + "250301" : [ "05:01", "800000", "150420" ], + "250302" : [ "05:02", "800000", "150420" ], + "250303" : [ "05:03", "800000", "150420" ], + "250304" : [ "05:04", "800000", "150420" ], + "250305" : [ "05:05", "800000", "150420" ], + "250306" : [ "05:06", "800000", "150420" ], + "250307" : [ "05:07", "800000", "150420" ], + "250308" : [ "05:08", "800000", "150420" ], + "250309" : [ "05:09", "800000", "150420" ], + "250310" : [ "05:10", "800000", "150420" ], + "250311" : [ "05:11", "800000", "150420" ], + "250312" : [ "05:12", "800000", "150420" ], + "250313" : [ "05:13", "800000", "150420" ], + "250314" : [ "05:14", "800000", "150420" ], + "250315" : [ "05:15", "800000", "150420" ], + "250316" : [ "05:16", "800000", "150420" ], + "250317" : [ "05:17", "800000", "150420" ], + "250318" : [ "05:18", "800000", "150420" ], + "250319" : [ "05:19", "800000", "150420" ], + "250320" : [ "05:20", "800000", "150420" ], + "250321" : [ "05:21", "800000", "150420" ], + "250322" : [ "05:22", "800000", "150420" ], + "250323" : [ "05:23", "800000", "150420" ], + "250324" : [ "05:24", "800000", "150420" ], + "250325" : [ "05:25", "800000", "150420" ], + "250326" : [ "05:26", "800000", "150420" ], + "250327" : [ "05:27", "800000", "150420" ], + "250328" : [ "05:28", "800000", "150420" ], + "250329" : [ "05:29", "800000", "150420" ], + "250330" : [ "05:30", "800000", "150420" ], + "250331" : [ "05:31", "800000", "150420" ], + "250332" : [ "05:32", "800000", "150420" ], + "250333" : [ "05:33", "800000", "150420" ], + "250334" : [ "05:34", "800000", "150420" ], + "250335" : [ "05:35", "800000", "150420" ], + "250336" : [ "05:36", "800000", "150420" ], + "250337" : [ "05:37", "800000", "150420" ], + "250338" : [ "05:38", "800000", "150420" ], + "250339" : [ "05:39", "800000", "150420" ], + "250340" : [ "05:40", "800000", "150420" ], + "250341" : [ "05:41", "800000", "150420" ], + "250342" : [ "05:42", "800000", "150420" ], + "250343" : [ "05:43", "800000", "150420" ], + "250344" : [ "05:44", "800000", "150420" ], + "250345" : [ "05:45", "800000", "150420" ], + "250346" : [ "05:46", "800000", "150420" ], + "250347" : [ "05:47", "800000", "150420" ], + "250348" : [ "05:48", "800000", "150420" ], + "250349" : [ "05:49", "800000", "150420" ], + "250350" : [ "05:50", "800000", "150420" ], + "250351" : [ "05:51", "800000", "150420" ], + "250352" : [ "05:52", "800000", "150420" ], + "250353" : [ "05:53", "800000", "150420" ], + "250354" : [ "05:54", "800000", "150420" ], + "250355" : [ "05:55", "800000", "150420" ], + "250356" : [ "05:56", "800000", "150420" ], + "250357" : [ "05:57", "800000", "150420" ], + "250358" : [ "05:58", "800000", "150420" ], + "250359" : [ "05:59", "800000", "150420" ], + "250360" : [ "06:00", "800000", "150420" ], + "250361" : [ "06:01", "800000", "150420" ], + "250362" : [ "06:02", "800000", "150420" ], + "250363" : [ "06:03", "800000", "150420" ], + "250364" : [ "06:04", "800000", "150420" ], + "250365" : [ "06:05", "800000", "150420" ], + "250366" : [ "06:06", "800000", "150420" ], + "250367" : [ "06:07", "800000", "150420" ], + "250368" : [ "06:08", "800000", "150420" ], + "250369" : [ "06:09", "800000", "150420" ], + "250370" : [ "06:10", "800000", "150420" ], + "250371" : [ "06:11", "800000", "150420" ], + "250372" : [ "06:12", "800000", "150420" ], + "250373" : [ "06:13", "800000", "150420" ], + "250374" : [ "06:14", "800000", "150420" ], + "250375" : [ "06:15", "800000", "150420" ], + "250376" : [ "06:16", "800000", "150420" ], + "250377" : [ "06:17", "800000", "150420" ], + "250378" : [ "06:18", "800000", "150420" ], + "250379" : [ "06:19", "800000", "150420" ], + "250380" : [ "06:20", "800000", "150420" ], + "250381" : [ "06:21", "800000", "150420" ], + "250382" : [ "06:22", "800000", "150420" ], + "250383" : [ "06:23", "800000", "150420" ], + "250384" : [ "06:24", "800000", "150420" ], + "250385" : [ "06:25", "800000", "150420" ], + "250386" : [ "06:26", "800000", "150420" ], + "250387" : [ "06:27", "800000", "150420" ], + "250388" : [ "06:28", "800000", "150420" ], + "250389" : [ "06:29", "800000", "150420" ], + "250390" : [ "06:30", "800000", "150420" ], + "250391" : [ "06:31", "800000", "150420" ], + "250392" : [ "06:32", "800000", "150420" ], + "250393" : [ "06:33", "800000", "150420" ], + "250394" : [ "06:34", "800000", "150420" ], + "250395" : [ "06:35", "800000", "150420" ], + "250396" : [ "06:36", "800000", "150420" ], + "250397" : [ "06:37", "800000", "150420" ], + "250398" : [ "06:38", "800000", "150420" ], + "250399" : [ "06:39", "800000", "150420" ], + "250400" : [ "06:40", "800000", "150420" ], + "250401" : [ "06:41", "800000", "150420" ], + "250402" : [ "06:42", "800000", "150420" ], + "250403" : [ "06:43", "800000", "150420" ], + "250404" : [ "06:44", "800000", "150420" ], + "250405" : [ "06:45", "800000", "150420" ], + "250406" : [ "06:46", "800000", "150420" ], + "250407" : [ "06:47", "800000", "150420" ], + "250408" : [ "06:48", "800000", "150420" ], + "250409" : [ "06:49", "800000", "150420" ], + "250410" : [ "06:50", "800000", "150420" ], + "250411" : [ "06:51", "800000", "150420" ], + "250412" : [ "06:52", "800000", "150420" ], + "250413" : [ "06:53", "800000", "150420" ], + "250414" : [ "06:54", "800000", "150420" ], + "250415" : [ "06:55", "800000", "150420" ], + "250416" : [ "06:56", "800000", "150420" ], + "250417" : [ "06:57", "800000", "150420" ], + "250418" : [ "06:58", "800000", "150420" ], + "250419" : [ "06:59", "800000", "150420" ], + "250420" : [ "07:00", "350000", "150480" ], + "250421" : [ "07:01", "350000", "150481" ], + "250422" : [ "07:02", "350000", "150482" ], + "250423" : [ "07:03", "350000", "150483" ], + "250424" : [ "07:04", "350000", "150484" ], + "250425" : [ "07:05", "350000", "150485" ], + "250426" : [ "07:06", "350000", "150486" ], + "250427" : [ "07:07", "350000", "150487" ], + "250428" : [ "07:08", "350000", "150488" ], + "250429" : [ "07:09", "350000", "150489" ], + "250430" : [ "07:10", "350000", "150490" ], + "250431" : [ "07:11", "350000", "150491" ], + "250432" : [ "07:12", "350000", "150492" ], + "250433" : [ "07:13", "350000", "150493" ], + "250434" : [ "07:14", "350000", "150494" ], + "250435" : [ "07:15", "350000", "150495" ], + "250436" : [ "07:16", "350000", "150496" ], + "250437" : [ "07:17", "350000", "150497" ], + "250438" : [ "07:18", "350000", "150498" ], + "250439" : [ "07:19", "350000", "150499" ], + "250440" : [ "07:20", "350000", "150500" ], + "250441" : [ "07:21", "350000", "150501" ], + "250442" : [ "07:22", "350000", "150502" ], + "250443" : [ "07:23", "350000", "150503" ], + "250444" : [ "07:24", "350000", "150504" ], + "250445" : [ "07:25", "350000", "150505" ], + "250446" : [ "07:26", "350000", "150506" ], + "250447" : [ "07:27", "350000", "150507" ], + "250448" : [ "07:28", "350000", "150508" ], + "250449" : [ "07:29", "350000", "150509" ], + "250450" : [ "07:30", "350000", "150510" ], + "250451" : [ "07:31", "350000", "150511" ], + "250452" : [ "07:32", "350000", "150512" ], + "250453" : [ "07:33", "350000", "150513" ], + "250454" : [ "07:34", "350000", "150514" ], + "250455" : [ "07:35", "350000", "150515" ], + "250456" : [ "07:36", "350000", "150516" ], + "250457" : [ "07:37", "350000", "150517" ], + "250458" : [ "07:38", "350000", "150518" ], + "250459" : [ "07:39", "350000", "150519" ], + "250460" : [ "07:40", "350000", "150520" ], + "250461" : [ "07:41", "350000", "150521" ], + "250462" : [ "07:42", "350000", "150522" ], + "250463" : [ "07:43", "350000", "150523" ], + "250464" : [ "07:44", "350000", "150524" ], + "250465" : [ "07:45", "350000", "150525" ], + "250466" : [ "07:46", "350000", "150526" ], + "250467" : [ "07:47", "350000", "150527" ], + "250468" : [ "07:48", "350000", "150528" ], + "250469" : [ "07:49", "350000", "150529" ], + "250470" : [ "07:50", "350000", "150530" ], + "250471" : [ "07:51", "350000", "150531" ], + "250472" : [ "07:52", "350000", "150532" ], + "250473" : [ "07:53", "350000", "150533" ], + "250474" : [ "07:54", "350000", "150534" ], + "250475" : [ "07:55", "350000", "150535" ], + "250476" : [ "07:56", "350000", "150536" ], + "250477" : [ "07:57", "350000", "150537" ], + "250478" : [ "07:58", "350000", "150538" ], + "250479" : [ "07:59", "350000", "150539" ], + "250480" : [ "08:00", "350000", "150540" ], + "250481" : [ "08:01", "350000", "150541" ], + "250482" : [ "08:02", "350000", "150542" ], + "250483" : [ "08:03", "350000", "150543" ], + "250484" : [ "08:04", "350000", "150544" ], + "250485" : [ "08:05", "350000", "150545" ], + "250486" : [ "08:06", "350000", "150546" ], + "250487" : [ "08:07", "350000", "150547" ], + "250488" : [ "08:08", "350000", "150548" ], + "250489" : [ "08:09", "350000", "150549" ], + "250490" : [ "08:10", "350000", "150550" ], + "250491" : [ "08:11", "350000", "150551" ], + "250492" : [ "08:12", "350000", "150552" ], + "250493" : [ "08:13", "350000", "150553" ], + "250494" : [ "08:14", "350000", "150554" ], + "250495" : [ "08:15", "350000", "150555" ], + "250496" : [ "08:16", "350000", "150556" ], + "250497" : [ "08:17", "350000", "150557" ], + "250498" : [ "08:18", "350000", "150558" ], + "250499" : [ "08:19", "350000", "150559" ], + "250500" : [ "08:20", "350000", "150560" ], + "250501" : [ "08:21", "350000", "150561" ], + "250502" : [ "08:22", "350000", "150562" ], + "250503" : [ "08:23", "350000", "150563" ], + "250504" : [ "08:24", "350000", "150564" ], + "250505" : [ "08:25", "350000", "150565" ], + "250506" : [ "08:26", "350000", "150566" ], + "250507" : [ "08:27", "350000", "150567" ], + "250508" : [ "08:28", "350000", "150568" ], + "250509" : [ "08:29", "350000", "150569" ], + "250510" : [ "08:30", "350000", "150570" ], + "250511" : [ "08:31", "350000", "150571" ], + "250512" : [ "08:32", "350000", "150572" ], + "250513" : [ "08:33", "350000", "150573" ], + "250514" : [ "08:34", "350000", "150574" ], + "250515" : [ "08:35", "350000", "150575" ], + "250516" : [ "08:36", "350000", "150576" ], + "250517" : [ "08:37", "350000", "150577" ], + "250518" : [ "08:38", "350000", "150578" ], + "250519" : [ "08:39", "350000", "150579" ], + "250520" : [ "08:40", "350000", "150580" ], + "250521" : [ "08:41", "350000", "150581" ], + "250522" : [ "08:42", "350000", "150582" ], + "250523" : [ "08:43", "350000", "150583" ], + "250524" : [ "08:44", "350000", "150584" ], + "250525" : [ "08:45", "350000", "150585" ], + "250526" : [ "08:46", "350000", "150586" ], + "250527" : [ "08:47", "350000", "150587" ], + "250528" : [ "08:48", "350000", "150588" ], + "250529" : [ "08:49", "350000", "150589" ], + "250530" : [ "08:50", "350000", "150590" ], + "250531" : [ "08:51", "350000", "150591" ], + "250532" : [ "08:52", "350000", "150592" ], + "250533" : [ "08:53", "350000", "150593" ], + "250534" : [ "08:54", "350000", "150594" ], + "250535" : [ "08:55", "350000", "150595" ], + "250536" : [ "08:56", "350000", "150596" ], + "250537" : [ "08:57", "350000", "150597" ], + "250538" : [ "08:58", "350000", "150598" ], + "250539" : [ "08:59", "350000", "150599" ], + "250540" : [ "09:00", "350000", "150600" ], + "250541" : [ "09:01", "350000", "150601" ], + "250542" : [ "09:02", "350000", "150602" ], + "250543" : [ "09:03", "350000", "150603" ], + "250544" : [ "09:04", "350000", "150604" ], + "250545" : [ "09:05", "350000", "150605" ], + "250546" : [ "09:06", "350000", "150606" ], + "250547" : [ "09:07", "350000", "150607" ], + "250548" : [ "09:08", "350000", "150608" ], + "250549" : [ "09:09", "350000", "150609" ], + "250550" : [ "09:10", "350000", "150610" ], + "250551" : [ "09:11", "350000", "150611" ], + "250552" : [ "09:12", "350000", "150612" ], + "250553" : [ "09:13", "350000", "150613" ], + "250554" : [ "09:14", "350000", "150614" ], + "250555" : [ "09:15", "350000", "150615" ], + "250556" : [ "09:16", "350000", "150616" ], + "250557" : [ "09:17", "350000", "150617" ], + "250558" : [ "09:18", "350000", "150618" ], + "250559" : [ "09:19", "350000", "150619" ], + "250560" : [ "09:20", "350000", "150620" ], + "250561" : [ "09:21", "350000", "150621" ], + "250562" : [ "09:22", "350000", "150622" ], + "250563" : [ "09:23", "350000", "150623" ], + "250564" : [ "09:24", "350000", "150624" ], + "250565" : [ "09:25", "350000", "150625" ], + "250566" : [ "09:26", "350000", "150626" ], + "250567" : [ "09:27", "350000", "150627" ], + "250568" : [ "09:28", "350000", "150628" ], + "250569" : [ "09:29", "350000", "150629" ], + "250570" : [ "09:30", "350000", "150630" ], + "250571" : [ "09:31", "350000", "150631" ], + "250572" : [ "09:32", "350000", "150632" ], + "250573" : [ "09:33", "350000", "150633" ], + "250574" : [ "09:34", "350000", "150634" ], + "250575" : [ "09:35", "350000", "150635" ], + "250576" : [ "09:36", "350000", "150636" ], + "250577" : [ "09:37", "350000", "150637" ], + "250578" : [ "09:38", "350000", "150638" ], + "250579" : [ "09:39", "350000", "150639" ], + "250580" : [ "09:40", "350000", "150640" ], + "250581" : [ "09:41", "350000", "150641" ], + "250582" : [ "09:42", "350000", "150642" ], + "250583" : [ "09:43", "350000", "150643" ], + "250584" : [ "09:44", "350000", "150644" ], + "250585" : [ "09:45", "350000", "150645" ], + "250586" : [ "09:46", "350000", "150646" ], + "250587" : [ "09:47", "350000", "150647" ], + "250588" : [ "09:48", "350000", "150648" ], + "250589" : [ "09:49", "350000", "150649" ], + "250590" : [ "09:50", "350000", "150650" ], + "250591" : [ "09:51", "350000", "150651" ], + "250592" : [ "09:52", "350000", "150652" ], + "250593" : [ "09:53", "350000", "150653" ], + "250594" : [ "09:54", "350000", "150654" ], + "250595" : [ "09:55", "350000", "150655" ], + "250596" : [ "09:56", "350000", "150656" ], + "250597" : [ "09:57", "350000", "150657" ], + "250598" : [ "09:58", "350000", "150658" ], + "250599" : [ "09:59", "350000", "150659" ], + "250600" : [ "10:00", "350000", "150660" ], + "250601" : [ "10:01", "350000", "150661" ], + "250602" : [ "10:02", "350000", "150662" ], + "250603" : [ "10:03", "350000", "150663" ], + "250604" : [ "10:04", "350000", "150664" ], + "250605" : [ "10:05", "350000", "150665" ], + "250606" : [ "10:06", "350000", "150666" ], + "250607" : [ "10:07", "350000", "150667" ], + "250608" : [ "10:08", "350000", "150668" ], + "250609" : [ "10:09", "350000", "150669" ], + "250610" : [ "10:10", "350000", "150670" ], + "250611" : [ "10:11", "350000", "150671" ], + "250612" : [ "10:12", "350000", "150672" ], + "250613" : [ "10:13", "350000", "150673" ], + "250614" : [ "10:14", "350000", "150674" ], + "250615" : [ "10:15", "350000", "150675" ], + "250616" : [ "10:16", "350000", "150676" ], + "250617" : [ "10:17", "350000", "150677" ], + "250618" : [ "10:18", "350000", "150678" ], + "250619" : [ "10:19", "350000", "150679" ], + "250620" : [ "10:20", "350000", "150680" ], + "250621" : [ "10:21", "350000", "150681" ], + "250622" : [ "10:22", "350000", "150682" ], + "250623" : [ "10:23", "350000", "150683" ], + "250624" : [ "10:24", "350000", "150684" ], + "250625" : [ "10:25", "350000", "150685" ], + "250626" : [ "10:26", "350000", "150686" ], + "250627" : [ "10:27", "350000", "150687" ], + "250628" : [ "10:28", "350000", "150688" ], + "250629" : [ "10:29", "350000", "150689" ], + "250630" : [ "10:30", "350000", "150690" ], + "250631" : [ "10:31", "350000", "150691" ], + "250632" : [ "10:32", "350000", "150692" ], + "250633" : [ "10:33", "350000", "150693" ], + "250634" : [ "10:34", "350000", "150694" ], + "250635" : [ "10:35", "350000", "150695" ], + "250636" : [ "10:36", "350000", "150696" ], + "250637" : [ "10:37", "350000", "150697" ], + "250638" : [ "10:38", "350000", "150698" ], + "250639" : [ "10:39", "350000", "150699" ], + "250640" : [ "10:40", "350000", "150700" ], + "250641" : [ "10:41", "350000", "150701" ], + "250642" : [ "10:42", "350000", "150702" ], + "250643" : [ "10:43", "350000", "150703" ], + "250644" : [ "10:44", "350000", "150704" ], + "250645" : [ "10:45", "350000", "150705" ], + "250646" : [ "10:46", "350000", "150706" ], + "250647" : [ "10:47", "350000", "150707" ], + "250648" : [ "10:48", "350000", "150708" ], + "250649" : [ "10:49", "350000", "150709" ], + "250650" : [ "10:50", "350000", "150710" ], + "250651" : [ "10:51", "350000", "150711" ], + "250652" : [ "10:52", "350000", "150712" ], + "250653" : [ "10:53", "350000", "150713" ], + "250654" : [ "10:54", "350000", "150714" ], + "250655" : [ "10:55", "350000", "150715" ], + "250656" : [ "10:56", "350000", "150716" ], + "250657" : [ "10:57", "350000", "150717" ], + "250658" : [ "10:58", "350000", "150718" ], + "250659" : [ "10:59", "350000", "150719" ], + "250660" : [ "11:00", "350000", "150720" ], + "250661" : [ "11:01", "350000", "150721" ], + "250662" : [ "11:02", "350000", "150722" ], + "250663" : [ "11:03", "350000", "150723" ], + "250664" : [ "11:04", "350000", "150724" ], + "250665" : [ "11:05", "350000", "150725" ], + "250666" : [ "11:06", "350000", "150726" ], + "250667" : [ "11:07", "350000", "150727" ], + "250668" : [ "11:08", "350000", "150728" ], + "250669" : [ "11:09", "350000", "150729" ], + "250670" : [ "11:10", "350000", "150730" ], + "250671" : [ "11:11", "350000", "150731" ], + "250672" : [ "11:12", "350000", "150732" ], + "250673" : [ "11:13", "350000", "150733" ], + "250674" : [ "11:14", "350000", "150734" ], + "250675" : [ "11:15", "350000", "150735" ], + "250676" : [ "11:16", "350000", "150736" ], + "250677" : [ "11:17", "350000", "150737" ], + "250678" : [ "11:18", "350000", "150738" ], + "250679" : [ "11:19", "350000", "150739" ], + "250680" : [ "11:20", "350000", "150740" ], + "250681" : [ "11:21", "350000", "150741" ], + "250682" : [ "11:22", "350000", "150742" ], + "250683" : [ "11:23", "350000", "150743" ], + "250684" : [ "11:24", "350000", "150744" ], + "250685" : [ "11:25", "350000", "150745" ], + "250686" : [ "11:26", "350000", "150746" ], + "250687" : [ "11:27", "350000", "150747" ], + "250688" : [ "11:28", "350000", "150748" ], + "250689" : [ "11:29", "350000", "150749" ], + "250690" : [ "11:30", "350000", "150750" ], + "250691" : [ "11:31", "350000", "150751" ], + "250692" : [ "11:32", "350000", "150752" ], + "250693" : [ "11:33", "350000", "150753" ], + "250694" : [ "11:34", "350000", "150754" ], + "250695" : [ "11:35", "350000", "150755" ], + "250696" : [ "11:36", "350000", "150756" ], + "250697" : [ "11:37", "350000", "150757" ], + "250698" : [ "11:38", "350000", "150758" ], + "250699" : [ "11:39", "350000", "150759" ], + "250700" : [ "11:40", "350000", "150760" ], + "250701" : [ "11:41", "350000", "150761" ], + "250702" : [ "11:42", "350000", "150762" ], + "250703" : [ "11:43", "350000", "150763" ], + "250704" : [ "11:44", "350000", "150764" ], + "250705" : [ "11:45", "350000", "150765" ], + "250706" : [ "11:46", "350000", "150766" ], + "250707" : [ "11:47", "350000", "150767" ], + "250708" : [ "11:48", "350000", "150768" ], + "250709" : [ "11:49", "350000", "150769" ], + "250710" : [ "11:50", "350000", "150770" ], + "250711" : [ "11:51", "350000", "150771" ], + "250712" : [ "11:52", "350000", "150772" ], + "250713" : [ "11:53", "350000", "150773" ], + "250714" : [ "11:54", "350000", "150774" ], + "250715" : [ "11:55", "350000", "150775" ], + "250716" : [ "11:56", "350000", "150776" ], + "250717" : [ "11:57", "350000", "150777" ], + "250718" : [ "11:58", "350000", "150778" ], + "250719" : [ "11:59", "350000", "150779" ], + "250720" : [ "12:00", "350000", "150780" ], + "250721" : [ "12:01", "350000", "150781" ], + "250722" : [ "12:02", "350000", "150782" ], + "250723" : [ "12:03", "350000", "150783" ], + "250724" : [ "12:04", "350000", "150784" ], + "250725" : [ "12:05", "350000", "150785" ], + "250726" : [ "12:06", "350000", "150786" ], + "250727" : [ "12:07", "350000", "150787" ], + "250728" : [ "12:08", "350000", "150788" ], + "250729" : [ "12:09", "350000", "150789" ], + "250730" : [ "12:10", "350000", "150790" ], + "250731" : [ "12:11", "350000", "150791" ], + "250732" : [ "12:12", "350000", "150792" ], + "250733" : [ "12:13", "350000", "150793" ], + "250734" : [ "12:14", "350000", "150794" ], + "250735" : [ "12:15", "350000", "150795" ], + "250736" : [ "12:16", "350000", "150796" ], + "250737" : [ "12:17", "350000", "150797" ], + "250738" : [ "12:18", "350000", "150798" ], + "250739" : [ "12:19", "350000", "150799" ], + "250740" : [ "12:20", "350000", "150800" ], + "250741" : [ "12:21", "350000", "150801" ], + "250742" : [ "12:22", "350000", "150802" ], + "250743" : [ "12:23", "350000", "150803" ], + "250744" : [ "12:24", "350000", "150804" ], + "250745" : [ "12:25", "350000", "150805" ], + "250746" : [ "12:26", "350000", "150806" ], + "250747" : [ "12:27", "350000", "150807" ], + "250748" : [ "12:28", "350000", "150808" ], + "250749" : [ "12:29", "350000", "150809" ], + "250750" : [ "12:30", "350000", "150810" ], + "250751" : [ "12:31", "350000", "150811" ], + "250752" : [ "12:32", "350000", "150812" ], + "250753" : [ "12:33", "350000", "150813" ], + "250754" : [ "12:34", "350000", "150814" ], + "250755" : [ "12:35", "350000", "150815" ], + "250756" : [ "12:36", "350000", "150816" ], + "250757" : [ "12:37", "350000", "150817" ], + "250758" : [ "12:38", "350000", "150818" ], + "250759" : [ "12:39", "350000", "150819" ], + "250760" : [ "12:40", "350000", "150820" ], + "250761" : [ "12:41", "350000", "150821" ], + "250762" : [ "12:42", "350000", "150822" ], + "250763" : [ "12:43", "350000", "150823" ], + "250764" : [ "12:44", "350000", "150824" ], + "250765" : [ "12:45", "350000", "150825" ], + "250766" : [ "12:46", "350000", "150826" ], + "250767" : [ "12:47", "350000", "150827" ], + "250768" : [ "12:48", "350000", "150828" ], + "250769" : [ "12:49", "350000", "150829" ], + "250770" : [ "12:50", "350000", "150830" ], + "250771" : [ "12:51", "350000", "150831" ], + "250772" : [ "12:52", "350000", "150832" ], + "250773" : [ "12:53", "350000", "150833" ], + "250774" : [ "12:54", "350000", "150834" ], + "250775" : [ "12:55", "350000", "150835" ], + "250776" : [ "12:56", "350000", "150836" ], + "250777" : [ "12:57", "350000", "150837" ], + "250778" : [ "12:58", "350000", "150838" ], + "250779" : [ "12:59", "350000", "150839" ], + "250780" : [ "13:00", "350000", "150840" ], + "250781" : [ "13:01", "350000", "150841" ], + "250782" : [ "13:02", "350000", "150842" ], + "250783" : [ "13:03", "350000", "150843" ], + "250784" : [ "13:04", "350000", "150844" ], + "250785" : [ "13:05", "350000", "150845" ], + "250786" : [ "13:06", "350000", "150846" ], + "250787" : [ "13:07", "350000", "150847" ], + "250788" : [ "13:08", "350000", "150848" ], + "250789" : [ "13:09", "350000", "150849" ], + "250790" : [ "13:10", "350000", "150850" ], + "250791" : [ "13:11", "350000", "150851" ], + "250792" : [ "13:12", "350000", "150852" ], + "250793" : [ "13:13", "350000", "150853" ], + "250794" : [ "13:14", "350000", "150854" ], + "250795" : [ "13:15", "350000", "150855" ], + "250796" : [ "13:16", "350000", "150856" ], + "250797" : [ "13:17", "350000", "150857" ], + "250798" : [ "13:18", "350000", "150858" ], + "250799" : [ "13:19", "350000", "150859" ], + "250800" : [ "13:20", "350000", "150860" ], + "250801" : [ "13:21", "350000", "150861" ], + "250802" : [ "13:22", "350000", "150862" ], + "250803" : [ "13:23", "350000", "150863" ], + "250804" : [ "13:24", "350000", "150864" ], + "250805" : [ "13:25", "350000", "150865" ], + "250806" : [ "13:26", "350000", "150866" ], + "250807" : [ "13:27", "350000", "150867" ], + "250808" : [ "13:28", "350000", "150868" ], + "250809" : [ "13:29", "350000", "150869" ], + "250810" : [ "13:30", "350000", "150870" ], + "250811" : [ "13:31", "350000", "150871" ], + "250812" : [ "13:32", "350000", "150872" ], + "250813" : [ "13:33", "350000", "150873" ], + "250814" : [ "13:34", "350000", "150874" ], + "250815" : [ "13:35", "350000", "150875" ], + "250816" : [ "13:36", "350000", "150876" ], + "250817" : [ "13:37", "350000", "150877" ], + "250818" : [ "13:38", "350000", "150878" ], + "250819" : [ "13:39", "350000", "150879" ], + "250820" : [ "13:40", "350000", "150880" ], + "250821" : [ "13:41", "350000", "150881" ], + "250822" : [ "13:42", "350000", "150882" ], + "250823" : [ "13:43", "350000", "150883" ], + "250824" : [ "13:44", "350000", "150884" ], + "250825" : [ "13:45", "350000", "150885" ], + "250826" : [ "13:46", "350000", "150886" ], + "250827" : [ "13:47", "350000", "150887" ], + "250828" : [ "13:48", "350000", "150888" ], + "250829" : [ "13:49", "350000", "150889" ], + "250830" : [ "13:50", "350000", "150890" ], + "250831" : [ "13:51", "350000", "150891" ], + "250832" : [ "13:52", "350000", "150892" ], + "250833" : [ "13:53", "350000", "150893" ], + "250834" : [ "13:54", "350000", "150894" ], + "250835" : [ "13:55", "350000", "150895" ], + "250836" : [ "13:56", "350000", "150896" ], + "250837" : [ "13:57", "350000", "150897" ], + "250838" : [ "13:58", "350000", "150898" ], + "250839" : [ "13:59", "350000", "150899" ], + "250840" : [ "14:00", "350000", "150900" ], + "250841" : [ "14:01", "350000", "150901" ], + "250842" : [ "14:02", "350000", "150902" ], + "250843" : [ "14:03", "350000", "150903" ], + "250844" : [ "14:04", "350000", "150904" ], + "250845" : [ "14:05", "350000", "150905" ], + "250846" : [ "14:06", "350000", "150906" ], + "250847" : [ "14:07", "350000", "150907" ], + "250848" : [ "14:08", "350000", "150908" ], + "250849" : [ "14:09", "350000", "150909" ], + "250850" : [ "14:10", "350000", "150910" ], + "250851" : [ "14:11", "350000", "150911" ], + "250852" : [ "14:12", "350000", "150912" ], + "250853" : [ "14:13", "350000", "150913" ], + "250854" : [ "14:14", "350000", "150914" ], + "250855" : [ "14:15", "350000", "150915" ], + "250856" : [ "14:16", "350000", "150916" ], + "250857" : [ "14:17", "350000", "150917" ], + "250858" : [ "14:18", "350000", "150918" ], + "250859" : [ "14:19", "350000", "150919" ], + "250860" : [ "14:20", "350000", "150920" ], + "250861" : [ "14:21", "350000", "150921" ], + "250862" : [ "14:22", "350000", "150922" ], + "250863" : [ "14:23", "350000", "150923" ], + "250864" : [ "14:24", "350000", "150924" ], + "250865" : [ "14:25", "350000", "150925" ], + "250866" : [ "14:26", "350000", "150926" ], + "250867" : [ "14:27", "350000", "150927" ], + "250868" : [ "14:28", "350000", "150928" ], + "250869" : [ "14:29", "350000", "150929" ], + "250870" : [ "14:30", "350000", "150930" ], + "250871" : [ "14:31", "350000", "150931" ], + "250872" : [ "14:32", "350000", "150932" ], + "250873" : [ "14:33", "350000", "150933" ], + "250874" : [ "14:34", "350000", "150934" ], + "250875" : [ "14:35", "350000", "150935" ], + "250876" : [ "14:36", "350000", "150936" ], + "250877" : [ "14:37", "350000", "150937" ], + "250878" : [ "14:38", "350000", "150938" ], + "250879" : [ "14:39", "350000", "150939" ], + "250880" : [ "14:40", "350000", "150940" ], + "250881" : [ "14:41", "350000", "150941" ], + "250882" : [ "14:42", "350000", "150942" ], + "250883" : [ "14:43", "350000", "150943" ], + "250884" : [ "14:44", "350000", "150944" ], + "250885" : [ "14:45", "350000", "150945" ], + "250886" : [ "14:46", "350000", "150946" ], + "250887" : [ "14:47", "350000", "150947" ], + "250888" : [ "14:48", "350000", "150948" ], + "250889" : [ "14:49", "350000", "150949" ], + "250890" : [ "14:50", "350000", "150950" ], + "250891" : [ "14:51", "350000", "150951" ], + "250892" : [ "14:52", "350000", "150952" ], + "250893" : [ "14:53", "350000", "150953" ], + "250894" : [ "14:54", "350000", "150954" ], + "250895" : [ "14:55", "350000", "150955" ], + "250896" : [ "14:56", "350000", "150956" ], + "250897" : [ "14:57", "350000", "150957" ], + "250898" : [ "14:58", "350000", "150958" ], + "250899" : [ "14:59", "350000", "150959" ], + "250900" : [ "15:00", "350000", "150960" ], + "250901" : [ "15:01", "350000", "150961" ], + "250902" : [ "15:02", "350000", "150962" ], + "250903" : [ "15:03", "350000", "150963" ], + "250904" : [ "15:04", "350000", "150964" ], + "250905" : [ "15:05", "350000", "150965" ], + "250906" : [ "15:06", "350000", "150966" ], + "250907" : [ "15:07", "350000", "150967" ], + "250908" : [ "15:08", "350000", "150968" ], + "250909" : [ "15:09", "350000", "150969" ], + "250910" : [ "15:10", "350000", "150970" ], + "250911" : [ "15:11", "350000", "150971" ], + "250912" : [ "15:12", "350000", "150972" ], + "250913" : [ "15:13", "350000", "150973" ], + "250914" : [ "15:14", "350000", "150974" ], + "250915" : [ "15:15", "350000", "150975" ], + "250916" : [ "15:16", "350000", "150976" ], + "250917" : [ "15:17", "350000", "150977" ], + "250918" : [ "15:18", "350000", "150978" ], + "250919" : [ "15:19", "350000", "150979" ], + "250920" : [ "15:20", "350000", "150980" ], + "250921" : [ "15:21", "350000", "150981" ], + "250922" : [ "15:22", "350000", "150982" ], + "250923" : [ "15:23", "350000", "150983" ], + "250924" : [ "15:24", "350000", "150984" ], + "250925" : [ "15:25", "350000", "150985" ], + "250926" : [ "15:26", "350000", "150986" ], + "250927" : [ "15:27", "350000", "150987" ], + "250928" : [ "15:28", "350000", "150988" ], + "250929" : [ "15:29", "350000", "150989" ], + "250930" : [ "15:30", "350000", "150990" ], + "250931" : [ "15:31", "350000", "150991" ], + "250932" : [ "15:32", "350000", "150992" ], + "250933" : [ "15:33", "350000", "150993" ], + "250934" : [ "15:34", "350000", "150994" ], + "250935" : [ "15:35", "350000", "150995" ], + "250936" : [ "15:36", "350000", "150996" ], + "250937" : [ "15:37", "350000", "150997" ], + "250938" : [ "15:38", "350000", "150998" ], + "250939" : [ "15:39", "350000", "150999" ], + "250940" : [ "15:40", "350000", "151000" ], + "250941" : [ "15:41", "350000", "151001" ], + "250942" : [ "15:42", "350000", "151002" ], + "250943" : [ "15:43", "350000", "151003" ], + "250944" : [ "15:44", "350000", "151004" ], + "250945" : [ "15:45", "350000", "151005" ], + "250946" : [ "15:46", "350000", "151006" ], + "250947" : [ "15:47", "350000", "151007" ], + "250948" : [ "15:48", "350000", "151008" ], + "250949" : [ "15:49", "350000", "151009" ], + "250950" : [ "15:50", "350000", "151010" ], + "250951" : [ "15:51", "350000", "151011" ], + "250952" : [ "15:52", "350000", "151012" ], + "250953" : [ "15:53", "350000", "151013" ], + "250954" : [ "15:54", "350000", "151014" ], + "250955" : [ "15:55", "350000", "151015" ], + "250956" : [ "15:56", "350000", "151016" ], + "250957" : [ "15:57", "350000", "151017" ], + "250958" : [ "15:58", "350000", "151018" ], + "250959" : [ "15:59", "350000", "151019" ], + "250960" : [ "16:00", "350000", "151020" ], + "250961" : [ "16:01", "350000", "151021" ], + "250962" : [ "16:02", "350000", "151022" ], + "250963" : [ "16:03", "350000", "151023" ], + "250964" : [ "16:04", "350000", "151024" ], + "250965" : [ "16:05", "350000", "151025" ], + "250966" : [ "16:06", "350000", "151026" ], + "250967" : [ "16:07", "350000", "151027" ], + "250968" : [ "16:08", "350000", "151028" ], + "250969" : [ "16:09", "350000", "151029" ], + "250970" : [ "16:10", "350000", "151030" ], + "250971" : [ "16:11", "350000", "151031" ], + "250972" : [ "16:12", "350000", "151032" ], + "250973" : [ "16:13", "350000", "151033" ], + "250974" : [ "16:14", "350000", "151034" ], + "250975" : [ "16:15", "350000", "151035" ], + "250976" : [ "16:16", "350000", "151036" ], + "250977" : [ "16:17", "350000", "151037" ], + "250978" : [ "16:18", "350000", "151038" ], + "250979" : [ "16:19", "350000", "151039" ], + "250980" : [ "16:20", "350000", "151040" ], + "250981" : [ "16:21", "350000", "151041" ], + "250982" : [ "16:22", "350000", "151042" ], + "250983" : [ "16:23", "350000", "151043" ], + "250984" : [ "16:24", "350000", "151044" ], + "250985" : [ "16:25", "350000", "151045" ], + "250986" : [ "16:26", "350000", "151046" ], + "250987" : [ "16:27", "350000", "151047" ], + "250988" : [ "16:28", "350000", "151048" ], + "250989" : [ "16:29", "350000", "151049" ], + "250990" : [ "16:30", "350000", "151050" ], + "250991" : [ "16:31", "350000", "151051" ], + "250992" : [ "16:32", "350000", "151052" ], + "250993" : [ "16:33", "350000", "151053" ], + "250994" : [ "16:34", "350000", "151054" ], + "250995" : [ "16:35", "350000", "151055" ], + "250996" : [ "16:36", "350000", "151056" ], + "250997" : [ "16:37", "350000", "151057" ], + "250998" : [ "16:38", "350000", "151058" ], + "250999" : [ "16:39", "350000", "151059" ], + "251000" : [ "16:40", "350000", "151060" ], + "251001" : [ "16:41", "350000", "151061" ], + "251002" : [ "16:42", "350000", "151062" ], + "251003" : [ "16:43", "350000", "151063" ], + "251004" : [ "16:44", "350000", "151064" ], + "251005" : [ "16:45", "350000", "151065" ], + "251006" : [ "16:46", "350000", "151066" ], + "251007" : [ "16:47", "350000", "151067" ], + "251008" : [ "16:48", "350000", "151068" ], + "251009" : [ "16:49", "350000", "151069" ], + "251010" : [ "16:50", "350000", "151070" ], + "251011" : [ "16:51", "350000", "151071" ], + "251012" : [ "16:52", "350000", "151072" ], + "251013" : [ "16:53", "350000", "151073" ], + "251014" : [ "16:54", "350000", "151074" ], + "251015" : [ "16:55", "350000", "151075" ], + "251016" : [ "16:56", "350000", "151076" ], + "251017" : [ "16:57", "350000", "151077" ], + "251018" : [ "16:58", "350000", "151078" ], + "251019" : [ "16:59", "350000", "151079" ], + "251020" : [ "17:00", "350000", "151080" ], + "251021" : [ "17:01", "350000", "151081" ], + "251022" : [ "17:02", "350000", "151082" ], + "251023" : [ "17:03", "350000", "151083" ], + "251024" : [ "17:04", "350000", "151084" ], + "251025" : [ "17:05", "350000", "151085" ], + "251026" : [ "17:06", "350000", "151086" ], + "251027" : [ "17:07", "350000", "151087" ], + "251028" : [ "17:08", "350000", "151088" ], + "251029" : [ "17:09", "350000", "151089" ], + "251030" : [ "17:10", "350000", "151090" ], + "251031" : [ "17:11", "350000", "151091" ], + "251032" : [ "17:12", "350000", "151092" ], + "251033" : [ "17:13", "350000", "151093" ], + "251034" : [ "17:14", "350000", "151094" ], + "251035" : [ "17:15", "350000", "151095" ], + "251036" : [ "17:16", "350000", "151096" ], + "251037" : [ "17:17", "350000", "151097" ], + "251038" : [ "17:18", "350000", "151098" ], + "251039" : [ "17:19", "350000", "151099" ], + "251040" : [ "17:20", "350000", "151100" ], + "251041" : [ "17:21", "350000", "151101" ], + "251042" : [ "17:22", "350000", "151102" ], + "251043" : [ "17:23", "350000", "151103" ], + "251044" : [ "17:24", "350000", "151104" ], + "251045" : [ "17:25", "350000", "151105" ], + "251046" : [ "17:26", "350000", "151106" ], + "251047" : [ "17:27", "350000", "151107" ], + "251048" : [ "17:28", "350000", "151108" ], + "251049" : [ "17:29", "350000", "151109" ], + "251050" : [ "17:30", "350000", "151110" ], + "251051" : [ "17:31", "350000", "151111" ], + "251052" : [ "17:32", "350000", "151112" ], + "251053" : [ "17:33", "350000", "151113" ], + "251054" : [ "17:34", "350000", "151114" ], + "251055" : [ "17:35", "350000", "151115" ], + "251056" : [ "17:36", "350000", "151116" ], + "251057" : [ "17:37", "350000", "151117" ], + "251058" : [ "17:38", "350000", "151118" ], + "251059" : [ "17:39", "350000", "151119" ], + "251060" : [ "17:40", "350000", "151120" ], + "251061" : [ "17:41", "350000", "151121" ], + "251062" : [ "17:42", "350000", "151122" ], + "251063" : [ "17:43", "350000", "151123" ], + "251064" : [ "17:44", "350000", "151124" ], + "251065" : [ "17:45", "350000", "151125" ], + "251066" : [ "17:46", "350000", "151126" ], + "251067" : [ "17:47", "350000", "151127" ], + "251068" : [ "17:48", "350000", "151128" ], + "251069" : [ "17:49", "350000", "151129" ], + "251070" : [ "17:50", "350000", "151130" ], + "251071" : [ "17:51", "350000", "151131" ], + "251072" : [ "17:52", "350000", "151132" ], + "251073" : [ "17:53", "350000", "151133" ], + "251074" : [ "17:54", "350000", "151134" ], + "251075" : [ "17:55", "350000", "151135" ], + "251076" : [ "17:56", "350000", "151136" ], + "251077" : [ "17:57", "350000", "151137" ], + "251078" : [ "17:58", "350000", "151138" ], + "251079" : [ "17:59", "350000", "151139" ], + "251080" : [ "18:00", "350000", "151140" ], + "251081" : [ "18:01", "350000", "151141" ], + "251082" : [ "18:02", "350000", "151142" ], + "251083" : [ "18:03", "350000", "151143" ], + "251084" : [ "18:04", "350000", "151144" ], + "251085" : [ "18:05", "350000", "151145" ], + "251086" : [ "18:06", "350000", "151146" ], + "251087" : [ "18:07", "350000", "151147" ], + "251088" : [ "18:08", "350000", "151148" ], + "251089" : [ "18:09", "350000", "151149" ], + "251090" : [ "18:10", "350000", "151150" ], + "251091" : [ "18:11", "350000", "151151" ], + "251092" : [ "18:12", "350000", "151152" ], + "251093" : [ "18:13", "350000", "151153" ], + "251094" : [ "18:14", "350000", "151154" ], + "251095" : [ "18:15", "350000", "151155" ], + "251096" : [ "18:16", "350000", "151156" ], + "251097" : [ "18:17", "350000", "151157" ], + "251098" : [ "18:18", "350000", "151158" ], + "251099" : [ "18:19", "350000", "151159" ], + "251100" : [ "18:20", "350000", "151160" ], + "251101" : [ "18:21", "350000", "151161" ], + "251102" : [ "18:22", "350000", "151162" ], + "251103" : [ "18:23", "350000", "151163" ], + "251104" : [ "18:24", "350000", "151164" ], + "251105" : [ "18:25", "350000", "151165" ], + "251106" : [ "18:26", "350000", "151166" ], + "251107" : [ "18:27", "350000", "151167" ], + "251108" : [ "18:28", "350000", "151168" ], + "251109" : [ "18:29", "350000", "151169" ], + "251110" : [ "18:30", "350000", "151170" ], + "251111" : [ "18:31", "350000", "151171" ], + "251112" : [ "18:32", "350000", "151172" ], + "251113" : [ "18:33", "350000", "151173" ], + "251114" : [ "18:34", "350000", "151174" ], + "251115" : [ "18:35", "350000", "151175" ], + "251116" : [ "18:36", "350000", "151176" ], + "251117" : [ "18:37", "350000", "151177" ], + "251118" : [ "18:38", "350000", "151178" ], + "251119" : [ "18:39", "350000", "151179" ], + "251120" : [ "18:40", "350000", "151180" ], + "251121" : [ "18:41", "350000", "151181" ], + "251122" : [ "18:42", "350000", "151182" ], + "251123" : [ "18:43", "350000", "151183" ], + "251124" : [ "18:44", "350000", "151184" ], + "251125" : [ "18:45", "350000", "151185" ], + "251126" : [ "18:46", "350000", "151186" ], + "251127" : [ "18:47", "350000", "151187" ], + "251128" : [ "18:48", "350000", "151188" ], + "251129" : [ "18:49", "350000", "151189" ], + "251130" : [ "18:50", "350000", "151190" ], + "251131" : [ "18:51", "350000", "151191" ], + "251132" : [ "18:52", "350000", "151192" ], + "251133" : [ "18:53", "350000", "151193" ], + "251134" : [ "18:54", "350000", "151194" ], + "251135" : [ "18:55", "350000", "151195" ], + "251136" : [ "18:56", "350000", "151196" ], + "251137" : [ "18:57", "350000", "151197" ], + "251138" : [ "18:58", "350000", "151198" ], + "251139" : [ "18:59", "350000", "151199" ], + "251140" : [ "19:00", "350000", "151200" ], + "251141" : [ "19:01", "350000", "151200" ], + "251142" : [ "19:02", "350000", "151200" ], + "251143" : [ "19:03", "350000", "151200" ], + "251144" : [ "19:04", "350000", "151200" ], + "251145" : [ "19:05", "350000", "151200" ], + "251146" : [ "19:06", "350000", "151200" ], + "251147" : [ "19:07", "350000", "151200" ], + "251148" : [ "19:08", "350000", "151200" ], + "251149" : [ "19:09", "350000", "151200" ], + "251150" : [ "19:10", "350000", "151200" ], + "251151" : [ "19:11", "350000", "151200" ], + "251152" : [ "19:12", "350000", "151200" ], + "251153" : [ "19:13", "350000", "151200" ], + "251154" : [ "19:14", "350000", "151200" ], + "251155" : [ "19:15", "350000", "151200" ], + "251156" : [ "19:16", "350000", "151200" ], + "251157" : [ "19:17", "350000", "151200" ], + "251158" : [ "19:18", "350000", "151200" ], + "251159" : [ "19:19", "350000", "151200" ], + "251160" : [ "19:20", "350000", "151200" ], + "251161" : [ "19:21", "350000", "151200" ], + "251162" : [ "19:22", "350000", "151200" ], + "251163" : [ "19:23", "350000", "151200" ], + "251164" : [ "19:24", "350000", "151200" ], + "251165" : [ "19:25", "350000", "151200" ], + "251166" : [ "19:26", "350000", "151200" ], + "251167" : [ "19:27", "350000", "151200" ], + "251168" : [ "19:28", "350000", "151200" ], + "251169" : [ "19:29", "350000", "151200" ], + "251170" : [ "19:30", "350000", "151200" ], + "251171" : [ "19:31", "350000", "151200" ], + "251172" : [ "19:32", "350000", "151200" ], + "251173" : [ "19:33", "350000", "151200" ], + "251174" : [ "19:34", "350000", "151200" ], + "251175" : [ "19:35", "350000", "151200" ], + "251176" : [ "19:36", "350000", "151200" ], + "251177" : [ "19:37", "350000", "151200" ], + "251178" : [ "19:38", "350000", "151200" ], + "251179" : [ "19:39", "350000", "151200" ], + "251180" : [ "19:40", "350000", "151200" ], + "251181" : [ "19:41", "350000", "151200" ], + "251182" : [ "19:42", "350000", "151200" ], + "251183" : [ "19:43", "350000", "151200" ], + "251184" : [ "19:44", "350000", "151200" ], + "251185" : [ "19:45", "350000", "151200" ], + "251186" : [ "19:46", "350000", "151200" ], + "251187" : [ "19:47", "350000", "151200" ], + "251188" : [ "19:48", "350000", "151200" ], + "251189" : [ "19:49", "350000", "151200" ], + "251190" : [ "19:50", "350000", "151200" ], + "251191" : [ "19:51", "350000", "151200" ], + "251192" : [ "19:52", "350000", "151200" ], + "251193" : [ "19:53", "350000", "151200" ], + "251194" : [ "19:54", "350000", "151200" ], + "251195" : [ "19:55", "350000", "151200" ], + "251196" : [ "19:56", "350000", "151200" ], + "251197" : [ "19:57", "350000", "151200" ], + "251198" : [ "19:58", "350000", "151200" ], + "251199" : [ "19:59", "350000", "151200" ], + "251200" : [ "20:00", "800000", "160420" ], + "251201" : [ "20:01", "800000", "160420" ], + "251202" : [ "20:02", "800000", "160420" ], + "251203" : [ "20:03", "800000", "160420" ], + "251204" : [ "20:04", "800000", "160420" ], + "251205" : [ "20:05", "800000", "160420" ], + "251206" : [ "20:06", "800000", "160420" ], + "251207" : [ "20:07", "800000", "160420" ], + "251208" : [ "20:08", "800000", "160420" ], + "251209" : [ "20:09", "800000", "160420" ], + "251210" : [ "20:10", "800000", "160420" ], + "251211" : [ "20:11", "800000", "160420" ], + "251212" : [ "20:12", "800000", "160420" ], + "251213" : [ "20:13", "800000", "160420" ], + "251214" : [ "20:14", "800000", "160420" ], + "251215" : [ "20:15", "800000", "160420" ], + "251216" : [ "20:16", "800000", "160420" ], + "251217" : [ "20:17", "800000", "160420" ], + "251218" : [ "20:18", "800000", "160420" ], + "251219" : [ "20:19", "800000", "160420" ], + "251220" : [ "20:20", "800000", "160420" ], + "251221" : [ "20:21", "800000", "160420" ], + "251222" : [ "20:22", "800000", "160420" ], + "251223" : [ "20:23", "800000", "160420" ], + "251224" : [ "20:24", "800000", "160420" ], + "251225" : [ "20:25", "800000", "160420" ], + "251226" : [ "20:26", "800000", "160420" ], + "251227" : [ "20:27", "800000", "160420" ], + "251228" : [ "20:28", "800000", "160420" ], + "251229" : [ "20:29", "800000", "160420" ], + "251230" : [ "20:30", "800000", "160420" ], + "251231" : [ "20:31", "800000", "160420" ], + "251232" : [ "20:32", "800000", "160420" ], + "251233" : [ "20:33", "800000", "160420" ], + "251234" : [ "20:34", "800000", "160420" ], + "251235" : [ "20:35", "800000", "160420" ], + "251236" : [ "20:36", "800000", "160420" ], + "251237" : [ "20:37", "800000", "160420" ], + "251238" : [ "20:38", "800000", "160420" ], + "251239" : [ "20:39", "800000", "160420" ], + "251240" : [ "20:40", "800000", "160420" ], + "251241" : [ "20:41", "800000", "160420" ], + "251242" : [ "20:42", "800000", "160420" ], + "251243" : [ "20:43", "800000", "160420" ], + "251244" : [ "20:44", "800000", "160420" ], + "251245" : [ "20:45", "800000", "160420" ], + "251246" : [ "20:46", "800000", "160420" ], + "251247" : [ "20:47", "800000", "160420" ], + "251248" : [ "20:48", "800000", "160420" ], + "251249" : [ "20:49", "800000", "160420" ], + "251250" : [ "20:50", "800000", "160420" ], + "251251" : [ "20:51", "800000", "160420" ], + "251252" : [ "20:52", "800000", "160420" ], + "251253" : [ "20:53", "800000", "160420" ], + "251254" : [ "20:54", "800000", "160420" ], + "251255" : [ "20:55", "800000", "160420" ], + "251256" : [ "20:56", "800000", "160420" ], + "251257" : [ "20:57", "800000", "160420" ], + "251258" : [ "20:58", "800000", "160420" ], + "251259" : [ "20:59", "800000", "160420" ], + "251260" : [ "21:00", "800000", "160420" ], + "251261" : [ "21:01", "800000", "160420" ], + "251262" : [ "21:02", "800000", "160420" ], + "251263" : [ "21:03", "800000", "160420" ], + "251264" : [ "21:04", "800000", "160420" ], + "251265" : [ "21:05", "800000", "160420" ], + "251266" : [ "21:06", "800000", "160420" ], + "251267" : [ "21:07", "800000", "160420" ], + "251268" : [ "21:08", "800000", "160420" ], + "251269" : [ "21:09", "800000", "160420" ], + "251270" : [ "21:10", "800000", "160420" ], + "251271" : [ "21:11", "800000", "160420" ], + "251272" : [ "21:12", "800000", "160420" ], + "251273" : [ "21:13", "800000", "160420" ], + "251274" : [ "21:14", "800000", "160420" ], + "251275" : [ "21:15", "800000", "160420" ], + "251276" : [ "21:16", "800000", "160420" ], + "251277" : [ "21:17", "800000", "160420" ], + "251278" : [ "21:18", "800000", "160420" ], + "251279" : [ "21:19", "800000", "160420" ], + "251280" : [ "21:20", "800000", "160420" ], + "251281" : [ "21:21", "800000", "160420" ], + "251282" : [ "21:22", "800000", "160420" ], + "251283" : [ "21:23", "800000", "160420" ], + "251284" : [ "21:24", "800000", "160420" ], + "251285" : [ "21:25", "800000", "160420" ], + "251286" : [ "21:26", "800000", "160420" ], + "251287" : [ "21:27", "800000", "160420" ], + "251288" : [ "21:28", "800000", "160420" ], + "251289" : [ "21:29", "800000", "160420" ], + "251290" : [ "21:30", "800000", "160420" ], + "251291" : [ "21:31", "800000", "160420" ], + "251292" : [ "21:32", "800000", "160420" ], + "251293" : [ "21:33", "800000", "160420" ], + "251294" : [ "21:34", "800000", "160420" ], + "251295" : [ "21:35", "800000", "160420" ], + "251296" : [ "21:36", "800000", "160420" ], + "251297" : [ "21:37", "800000", "160420" ], + "251298" : [ "21:38", "800000", "160420" ], + "251299" : [ "21:39", "800000", "160420" ], + "251300" : [ "21:40", "800000", "160420" ], + "251301" : [ "21:41", "800000", "160420" ], + "251302" : [ "21:42", "800000", "160420" ], + "251303" : [ "21:43", "800000", "160420" ], + "251304" : [ "21:44", "800000", "160420" ], + "251305" : [ "21:45", "800000", "160420" ], + "251306" : [ "21:46", "800000", "160420" ], + "251307" : [ "21:47", "800000", "160420" ], + "251308" : [ "21:48", "800000", "160420" ], + "251309" : [ "21:49", "800000", "160420" ], + "251310" : [ "21:50", "800000", "160420" ], + "251311" : [ "21:51", "800000", "160420" ], + "251312" : [ "21:52", "800000", "160420" ], + "251313" : [ "21:53", "800000", "160420" ], + "251314" : [ "21:54", "800000", "160420" ], + "251315" : [ "21:55", "800000", "160420" ], + "251316" : [ "21:56", "800000", "160420" ], + "251317" : [ "21:57", "800000", "160420" ], + "251318" : [ "21:58", "800000", "160420" ], + "251319" : [ "21:59", "800000", "160420" ], + "251320" : [ "22:00", "800000", "160420" ], + "251321" : [ "22:01", "800000", "160420" ], + "251322" : [ "22:02", "800000", "160420" ], + "251323" : [ "22:03", "800000", "160420" ], + "251324" : [ "22:04", "800000", "160420" ], + "251325" : [ "22:05", "800000", "160420" ], + "251326" : [ "22:06", "800000", "160420" ], + "251327" : [ "22:07", "800000", "160420" ], + "251328" : [ "22:08", "800000", "160420" ], + "251329" : [ "22:09", "800000", "160420" ], + "251330" : [ "22:10", "800000", "160420" ], + "251331" : [ "22:11", "800000", "160420" ], + "251332" : [ "22:12", "800000", "160420" ], + "251333" : [ "22:13", "800000", "160420" ], + "251334" : [ "22:14", "800000", "160420" ], + "251335" : [ "22:15", "800000", "160420" ], + "251336" : [ "22:16", "800000", "160420" ], + "251337" : [ "22:17", "800000", "160420" ], + "251338" : [ "22:18", "800000", "160420" ], + "251339" : [ "22:19", "800000", "160420" ], + "251340" : [ "22:20", "800000", "160420" ], + "251341" : [ "22:21", "800000", "160420" ], + "251342" : [ "22:22", "800000", "160420" ], + "251343" : [ "22:23", "800000", "160420" ], + "251344" : [ "22:24", "800000", "160420" ], + "251345" : [ "22:25", "800000", "160420" ], + "251346" : [ "22:26", "800000", "160420" ], + "251347" : [ "22:27", "800000", "160420" ], + "251348" : [ "22:28", "800000", "160420" ], + "251349" : [ "22:29", "800000", "160420" ], + "251350" : [ "22:30", "800000", "160420" ], + "251351" : [ "22:31", "800000", "160420" ], + "251352" : [ "22:32", "800000", "160420" ], + "251353" : [ "22:33", "800000", "160420" ], + "251354" : [ "22:34", "800000", "160420" ], + "251355" : [ "22:35", "800000", "160420" ], + "251356" : [ "22:36", "800000", "160420" ], + "251357" : [ "22:37", "800000", "160420" ], + "251358" : [ "22:38", "800000", "160420" ], + "251359" : [ "22:39", "800000", "160420" ], + "251360" : [ "22:40", "800000", "160420" ], + "251361" : [ "22:41", "800000", "160420" ], + "251362" : [ "22:42", "800000", "160420" ], + "251363" : [ "22:43", "800000", "160420" ], + "251364" : [ "22:44", "800000", "160420" ], + "251365" : [ "22:45", "800000", "160420" ], + "251366" : [ "22:46", "800000", "160420" ], + "251367" : [ "22:47", "800000", "160420" ], + "251368" : [ "22:48", "800000", "160420" ], + "251369" : [ "22:49", "800000", "160420" ], + "251370" : [ "22:50", "800000", "160420" ], + "251371" : [ "22:51", "800000", "160420" ], + "251372" : [ "22:52", "800000", "160420" ], + "251373" : [ "22:53", "800000", "160420" ], + "251374" : [ "22:54", "800000", "160420" ], + "251375" : [ "22:55", "800000", "160420" ], + "251376" : [ "22:56", "800000", "160420" ], + "251377" : [ "22:57", "800000", "160420" ], + "251378" : [ "22:58", "800000", "160420" ], + "251379" : [ "22:59", "800000", "160420" ], + "251380" : [ "23:00", "800000", "160420" ], + "251381" : [ "23:01", "800000", "160420" ], + "251382" : [ "23:02", "800000", "160420" ], + "251383" : [ "23:03", "800000", "160420" ], + "251384" : [ "23:04", "800000", "160420" ], + "251385" : [ "23:05", "800000", "160420" ], + "251386" : [ "23:06", "800000", "160420" ], + "251387" : [ "23:07", "800000", "160420" ], + "251388" : [ "23:08", "800000", "160420" ], + "251389" : [ "23:09", "800000", "160420" ], + "251390" : [ "23:10", "800000", "160420" ], + "251391" : [ "23:11", "800000", "160420" ], + "251392" : [ "23:12", "800000", "160420" ], + "251393" : [ "23:13", "800000", "160420" ], + "251394" : [ "23:14", "800000", "160420" ], + "251395" : [ "23:15", "800000", "160420" ], + "251396" : [ "23:16", "800000", "160420" ], + "251397" : [ "23:17", "800000", "160420" ], + "251398" : [ "23:18", "800000", "160420" ], + "251399" : [ "23:19", "800000", "160420" ], + "251400" : [ "23:20", "800000", "160420" ], + "251401" : [ "23:21", "800000", "160420" ], + "251402" : [ "23:22", "800000", "160420" ], + "251403" : [ "23:23", "800000", "160420" ], + "251404" : [ "23:24", "800000", "160420" ], + "251405" : [ "23:25", "800000", "160420" ], + "251406" : [ "23:26", "800000", "160420" ], + "251407" : [ "23:27", "800000", "160420" ], + "251408" : [ "23:28", "800000", "160420" ], + "251409" : [ "23:29", "800000", "160420" ], + "251410" : [ "23:30", "800000", "160420" ], + "251411" : [ "23:31", "800000", "160420" ], + "251412" : [ "23:32", "800000", "160420" ], + "251413" : [ "23:33", "800000", "160420" ], + "251414" : [ "23:34", "800000", "160420" ], + "251415" : [ "23:35", "800000", "160420" ], + "251416" : [ "23:36", "800000", "160420" ], + "251417" : [ "23:37", "800000", "160420" ], + "251418" : [ "23:38", "800000", "160420" ], + "251419" : [ "23:39", "800000", "160420" ], + "251420" : [ "23:40", "800000", "160420" ], + "251421" : [ "23:41", "800000", "160420" ], + "251422" : [ "23:42", "800000", "160420" ], + "251423" : [ "23:43", "800000", "160420" ], + "251424" : [ "23:44", "800000", "160420" ], + "251425" : [ "23:45", "800000", "160420" ], + "251426" : [ "23:46", "800000", "160420" ], + "251427" : [ "23:47", "800000", "160420" ], + "251428" : [ "23:48", "800000", "160420" ], + "251429" : [ "23:49", "800000", "160420" ], + "251430" : [ "23:50", "800000", "160420" ], + "251431" : [ "23:51", "800000", "160420" ], + "251432" : [ "23:52", "800000", "160420" ], + "251433" : [ "23:53", "800000", "160420" ], + "251434" : [ "23:54", "800000", "160420" ], + "251435" : [ "23:55", "800000", "160420" ], + "251436" : [ "23:56", "800000", "160420" ], + "251437" : [ "23:57", "800000", "160420" ], + "251438" : [ "23:58", "800000", "160420" ], + "251439" : [ "23:59", "800000", "160420" ] + }, + "Sunday": { + "260000" : [ "00:00", "800000", "160420" ], + "260001" : [ "00:01", "800000", "160420" ], + "260002" : [ "00:02", "800000", "160420" ], + "260003" : [ "00:03", "800000", "160420" ], + "260004" : [ "00:04", "800000", "160420" ], + "260005" : [ "00:05", "800000", "160420" ], + "260006" : [ "00:06", "800000", "160420" ], + "260007" : [ "00:07", "800000", "160420" ], + "260008" : [ "00:08", "800000", "160420" ], + "260009" : [ "00:09", "800000", "160420" ], + "260010" : [ "00:10", "800000", "160420" ], + "260011" : [ "00:11", "800000", "160420" ], + "260012" : [ "00:12", "800000", "160420" ], + "260013" : [ "00:13", "800000", "160420" ], + "260014" : [ "00:14", "800000", "160420" ], + "260015" : [ "00:15", "800000", "160420" ], + "260016" : [ "00:16", "800000", "160420" ], + "260017" : [ "00:17", "800000", "160420" ], + "260018" : [ "00:18", "800000", "160420" ], + "260019" : [ "00:19", "800000", "160420" ], + "260020" : [ "00:20", "800000", "160420" ], + "260021" : [ "00:21", "800000", "160420" ], + "260022" : [ "00:22", "800000", "160420" ], + "260023" : [ "00:23", "800000", "160420" ], + "260024" : [ "00:24", "800000", "160420" ], + "260025" : [ "00:25", "800000", "160420" ], + "260026" : [ "00:26", "800000", "160420" ], + "260027" : [ "00:27", "800000", "160420" ], + "260028" : [ "00:28", "800000", "160420" ], + "260029" : [ "00:29", "800000", "160420" ], + "260030" : [ "00:30", "800000", "160420" ], + "260031" : [ "00:31", "800000", "160420" ], + "260032" : [ "00:32", "800000", "160420" ], + "260033" : [ "00:33", "800000", "160420" ], + "260034" : [ "00:34", "800000", "160420" ], + "260035" : [ "00:35", "800000", "160420" ], + "260036" : [ "00:36", "800000", "160420" ], + "260037" : [ "00:37", "800000", "160420" ], + "260038" : [ "00:38", "800000", "160420" ], + "260039" : [ "00:39", "800000", "160420" ], + "260040" : [ "00:40", "800000", "160420" ], + "260041" : [ "00:41", "800000", "160420" ], + "260042" : [ "00:42", "800000", "160420" ], + "260043" : [ "00:43", "800000", "160420" ], + "260044" : [ "00:44", "800000", "160420" ], + "260045" : [ "00:45", "800000", "160420" ], + "260046" : [ "00:46", "800000", "160420" ], + "260047" : [ "00:47", "800000", "160420" ], + "260048" : [ "00:48", "800000", "160420" ], + "260049" : [ "00:49", "800000", "160420" ], + "260050" : [ "00:50", "800000", "160420" ], + "260051" : [ "00:51", "800000", "160420" ], + "260052" : [ "00:52", "800000", "160420" ], + "260053" : [ "00:53", "800000", "160420" ], + "260054" : [ "00:54", "800000", "160420" ], + "260055" : [ "00:55", "800000", "160420" ], + "260056" : [ "00:56", "800000", "160420" ], + "260057" : [ "00:57", "800000", "160420" ], + "260058" : [ "00:58", "800000", "160420" ], + "260059" : [ "00:59", "800000", "160420" ], + "260060" : [ "01:00", "800000", "160420" ], + "260061" : [ "01:01", "800000", "160420" ], + "260062" : [ "01:02", "800000", "160420" ], + "260063" : [ "01:03", "800000", "160420" ], + "260064" : [ "01:04", "800000", "160420" ], + "260065" : [ "01:05", "800000", "160420" ], + "260066" : [ "01:06", "800000", "160420" ], + "260067" : [ "01:07", "800000", "160420" ], + "260068" : [ "01:08", "800000", "160420" ], + "260069" : [ "01:09", "800000", "160420" ], + "260070" : [ "01:10", "800000", "160420" ], + "260071" : [ "01:11", "800000", "160420" ], + "260072" : [ "01:12", "800000", "160420" ], + "260073" : [ "01:13", "800000", "160420" ], + "260074" : [ "01:14", "800000", "160420" ], + "260075" : [ "01:15", "800000", "160420" ], + "260076" : [ "01:16", "800000", "160420" ], + "260077" : [ "01:17", "800000", "160420" ], + "260078" : [ "01:18", "800000", "160420" ], + "260079" : [ "01:19", "800000", "160420" ], + "260080" : [ "01:20", "800000", "160420" ], + "260081" : [ "01:21", "800000", "160420" ], + "260082" : [ "01:22", "800000", "160420" ], + "260083" : [ "01:23", "800000", "160420" ], + "260084" : [ "01:24", "800000", "160420" ], + "260085" : [ "01:25", "800000", "160420" ], + "260086" : [ "01:26", "800000", "160420" ], + "260087" : [ "01:27", "800000", "160420" ], + "260088" : [ "01:28", "800000", "160420" ], + "260089" : [ "01:29", "800000", "160420" ], + "260090" : [ "01:30", "800000", "160420" ], + "260091" : [ "01:31", "800000", "160420" ], + "260092" : [ "01:32", "800000", "160420" ], + "260093" : [ "01:33", "800000", "160420" ], + "260094" : [ "01:34", "800000", "160420" ], + "260095" : [ "01:35", "800000", "160420" ], + "260096" : [ "01:36", "800000", "160420" ], + "260097" : [ "01:37", "800000", "160420" ], + "260098" : [ "01:38", "800000", "160420" ], + "260099" : [ "01:39", "800000", "160420" ], + "260100" : [ "01:40", "800000", "160420" ], + "260101" : [ "01:41", "800000", "160420" ], + "260102" : [ "01:42", "800000", "160420" ], + "260103" : [ "01:43", "800000", "160420" ], + "260104" : [ "01:44", "800000", "160420" ], + "260105" : [ "01:45", "800000", "160420" ], + "260106" : [ "01:46", "800000", "160420" ], + "260107" : [ "01:47", "800000", "160420" ], + "260108" : [ "01:48", "800000", "160420" ], + "260109" : [ "01:49", "800000", "160420" ], + "260110" : [ "01:50", "800000", "160420" ], + "260111" : [ "01:51", "800000", "160420" ], + "260112" : [ "01:52", "800000", "160420" ], + "260113" : [ "01:53", "800000", "160420" ], + "260114" : [ "01:54", "800000", "160420" ], + "260115" : [ "01:55", "800000", "160420" ], + "260116" : [ "01:56", "800000", "160420" ], + "260117" : [ "01:57", "800000", "160420" ], + "260118" : [ "01:58", "800000", "160420" ], + "260119" : [ "01:59", "800000", "160420" ], + "260120" : [ "02:00", "800000", "160420" ], + "260121" : [ "02:01", "800000", "160420" ], + "260122" : [ "02:02", "800000", "160420" ], + "260123" : [ "02:03", "800000", "160420" ], + "260124" : [ "02:04", "800000", "160420" ], + "260125" : [ "02:05", "800000", "160420" ], + "260126" : [ "02:06", "800000", "160420" ], + "260127" : [ "02:07", "800000", "160420" ], + "260128" : [ "02:08", "800000", "160420" ], + "260129" : [ "02:09", "800000", "160420" ], + "260130" : [ "02:10", "800000", "160420" ], + "260131" : [ "02:11", "800000", "160420" ], + "260132" : [ "02:12", "800000", "160420" ], + "260133" : [ "02:13", "800000", "160420" ], + "260134" : [ "02:14", "800000", "160420" ], + "260135" : [ "02:15", "800000", "160420" ], + "260136" : [ "02:16", "800000", "160420" ], + "260137" : [ "02:17", "800000", "160420" ], + "260138" : [ "02:18", "800000", "160420" ], + "260139" : [ "02:19", "800000", "160420" ], + "260140" : [ "02:20", "800000", "160420" ], + "260141" : [ "02:21", "800000", "160420" ], + "260142" : [ "02:22", "800000", "160420" ], + "260143" : [ "02:23", "800000", "160420" ], + "260144" : [ "02:24", "800000", "160420" ], + "260145" : [ "02:25", "800000", "160420" ], + "260146" : [ "02:26", "800000", "160420" ], + "260147" : [ "02:27", "800000", "160420" ], + "260148" : [ "02:28", "800000", "160420" ], + "260149" : [ "02:29", "800000", "160420" ], + "260150" : [ "02:30", "800000", "160420" ], + "260151" : [ "02:31", "800000", "160420" ], + "260152" : [ "02:32", "800000", "160420" ], + "260153" : [ "02:33", "800000", "160420" ], + "260154" : [ "02:34", "800000", "160420" ], + "260155" : [ "02:35", "800000", "160420" ], + "260156" : [ "02:36", "800000", "160420" ], + "260157" : [ "02:37", "800000", "160420" ], + "260158" : [ "02:38", "800000", "160420" ], + "260159" : [ "02:39", "800000", "160420" ], + "260160" : [ "02:40", "800000", "160420" ], + "260161" : [ "02:41", "800000", "160420" ], + "260162" : [ "02:42", "800000", "160420" ], + "260163" : [ "02:43", "800000", "160420" ], + "260164" : [ "02:44", "800000", "160420" ], + "260165" : [ "02:45", "800000", "160420" ], + "260166" : [ "02:46", "800000", "160420" ], + "260167" : [ "02:47", "800000", "160420" ], + "260168" : [ "02:48", "800000", "160420" ], + "260169" : [ "02:49", "800000", "160420" ], + "260170" : [ "02:50", "800000", "160420" ], + "260171" : [ "02:51", "800000", "160420" ], + "260172" : [ "02:52", "800000", "160420" ], + "260173" : [ "02:53", "800000", "160420" ], + "260174" : [ "02:54", "800000", "160420" ], + "260175" : [ "02:55", "800000", "160420" ], + "260176" : [ "02:56", "800000", "160420" ], + "260177" : [ "02:57", "800000", "160420" ], + "260178" : [ "02:58", "800000", "160420" ], + "260179" : [ "02:59", "800000", "160420" ], + "260180" : [ "03:00", "800000", "160420" ], + "260181" : [ "03:01", "800000", "160420" ], + "260182" : [ "03:02", "800000", "160420" ], + "260183" : [ "03:03", "800000", "160420" ], + "260184" : [ "03:04", "800000", "160420" ], + "260185" : [ "03:05", "800000", "160420" ], + "260186" : [ "03:06", "800000", "160420" ], + "260187" : [ "03:07", "800000", "160420" ], + "260188" : [ "03:08", "800000", "160420" ], + "260189" : [ "03:09", "800000", "160420" ], + "260190" : [ "03:10", "800000", "160420" ], + "260191" : [ "03:11", "800000", "160420" ], + "260192" : [ "03:12", "800000", "160420" ], + "260193" : [ "03:13", "800000", "160420" ], + "260194" : [ "03:14", "800000", "160420" ], + "260195" : [ "03:15", "800000", "160420" ], + "260196" : [ "03:16", "800000", "160420" ], + "260197" : [ "03:17", "800000", "160420" ], + "260198" : [ "03:18", "800000", "160420" ], + "260199" : [ "03:19", "800000", "160420" ], + "260200" : [ "03:20", "800000", "160420" ], + "260201" : [ "03:21", "800000", "160420" ], + "260202" : [ "03:22", "800000", "160420" ], + "260203" : [ "03:23", "800000", "160420" ], + "260204" : [ "03:24", "800000", "160420" ], + "260205" : [ "03:25", "800000", "160420" ], + "260206" : [ "03:26", "800000", "160420" ], + "260207" : [ "03:27", "800000", "160420" ], + "260208" : [ "03:28", "800000", "160420" ], + "260209" : [ "03:29", "800000", "160420" ], + "260210" : [ "03:30", "800000", "160420" ], + "260211" : [ "03:31", "800000", "160420" ], + "260212" : [ "03:32", "800000", "160420" ], + "260213" : [ "03:33", "800000", "160420" ], + "260214" : [ "03:34", "800000", "160420" ], + "260215" : [ "03:35", "800000", "160420" ], + "260216" : [ "03:36", "800000", "160420" ], + "260217" : [ "03:37", "800000", "160420" ], + "260218" : [ "03:38", "800000", "160420" ], + "260219" : [ "03:39", "800000", "160420" ], + "260220" : [ "03:40", "800000", "160420" ], + "260221" : [ "03:41", "800000", "160420" ], + "260222" : [ "03:42", "800000", "160420" ], + "260223" : [ "03:43", "800000", "160420" ], + "260224" : [ "03:44", "800000", "160420" ], + "260225" : [ "03:45", "800000", "160420" ], + "260226" : [ "03:46", "800000", "160420" ], + "260227" : [ "03:47", "800000", "160420" ], + "260228" : [ "03:48", "800000", "160420" ], + "260229" : [ "03:49", "800000", "160420" ], + "260230" : [ "03:50", "800000", "160420" ], + "260231" : [ "03:51", "800000", "160420" ], + "260232" : [ "03:52", "800000", "160420" ], + "260233" : [ "03:53", "800000", "160420" ], + "260234" : [ "03:54", "800000", "160420" ], + "260235" : [ "03:55", "800000", "160420" ], + "260236" : [ "03:56", "800000", "160420" ], + "260237" : [ "03:57", "800000", "160420" ], + "260238" : [ "03:58", "800000", "160420" ], + "260239" : [ "03:59", "800000", "160420" ], + "260240" : [ "04:00", "800000", "160420" ], + "260241" : [ "04:01", "800000", "160420" ], + "260242" : [ "04:02", "800000", "160420" ], + "260243" : [ "04:03", "800000", "160420" ], + "260244" : [ "04:04", "800000", "160420" ], + "260245" : [ "04:05", "800000", "160420" ], + "260246" : [ "04:06", "800000", "160420" ], + "260247" : [ "04:07", "800000", "160420" ], + "260248" : [ "04:08", "800000", "160420" ], + "260249" : [ "04:09", "800000", "160420" ], + "260250" : [ "04:10", "800000", "160420" ], + "260251" : [ "04:11", "800000", "160420" ], + "260252" : [ "04:12", "800000", "160420" ], + "260253" : [ "04:13", "800000", "160420" ], + "260254" : [ "04:14", "800000", "160420" ], + "260255" : [ "04:15", "800000", "160420" ], + "260256" : [ "04:16", "800000", "160420" ], + "260257" : [ "04:17", "800000", "160420" ], + "260258" : [ "04:18", "800000", "160420" ], + "260259" : [ "04:19", "800000", "160420" ], + "260260" : [ "04:20", "800000", "160420" ], + "260261" : [ "04:21", "800000", "160420" ], + "260262" : [ "04:22", "800000", "160420" ], + "260263" : [ "04:23", "800000", "160420" ], + "260264" : [ "04:24", "800000", "160420" ], + "260265" : [ "04:25", "800000", "160420" ], + "260266" : [ "04:26", "800000", "160420" ], + "260267" : [ "04:27", "800000", "160420" ], + "260268" : [ "04:28", "800000", "160420" ], + "260269" : [ "04:29", "800000", "160420" ], + "260270" : [ "04:30", "800000", "160420" ], + "260271" : [ "04:31", "800000", "160420" ], + "260272" : [ "04:32", "800000", "160420" ], + "260273" : [ "04:33", "800000", "160420" ], + "260274" : [ "04:34", "800000", "160420" ], + "260275" : [ "04:35", "800000", "160420" ], + "260276" : [ "04:36", "800000", "160420" ], + "260277" : [ "04:37", "800000", "160420" ], + "260278" : [ "04:38", "800000", "160420" ], + "260279" : [ "04:39", "800000", "160420" ], + "260280" : [ "04:40", "800000", "160420" ], + "260281" : [ "04:41", "800000", "160420" ], + "260282" : [ "04:42", "800000", "160420" ], + "260283" : [ "04:43", "800000", "160420" ], + "260284" : [ "04:44", "800000", "160420" ], + "260285" : [ "04:45", "800000", "160420" ], + "260286" : [ "04:46", "800000", "160420" ], + "260287" : [ "04:47", "800000", "160420" ], + "260288" : [ "04:48", "800000", "160420" ], + "260289" : [ "04:49", "800000", "160420" ], + "260290" : [ "04:50", "800000", "160420" ], + "260291" : [ "04:51", "800000", "160420" ], + "260292" : [ "04:52", "800000", "160420" ], + "260293" : [ "04:53", "800000", "160420" ], + "260294" : [ "04:54", "800000", "160420" ], + "260295" : [ "04:55", "800000", "160420" ], + "260296" : [ "04:56", "800000", "160420" ], + "260297" : [ "04:57", "800000", "160420" ], + "260298" : [ "04:58", "800000", "160420" ], + "260299" : [ "04:59", "800000", "160420" ], + "260300" : [ "05:00", "800000", "160420" ], + "260301" : [ "05:01", "800000", "160420" ], + "260302" : [ "05:02", "800000", "160420" ], + "260303" : [ "05:03", "800000", "160420" ], + "260304" : [ "05:04", "800000", "160420" ], + "260305" : [ "05:05", "800000", "160420" ], + "260306" : [ "05:06", "800000", "160420" ], + "260307" : [ "05:07", "800000", "160420" ], + "260308" : [ "05:08", "800000", "160420" ], + "260309" : [ "05:09", "800000", "160420" ], + "260310" : [ "05:10", "800000", "160420" ], + "260311" : [ "05:11", "800000", "160420" ], + "260312" : [ "05:12", "800000", "160420" ], + "260313" : [ "05:13", "800000", "160420" ], + "260314" : [ "05:14", "800000", "160420" ], + "260315" : [ "05:15", "800000", "160420" ], + "260316" : [ "05:16", "800000", "160420" ], + "260317" : [ "05:17", "800000", "160420" ], + "260318" : [ "05:18", "800000", "160420" ], + "260319" : [ "05:19", "800000", "160420" ], + "260320" : [ "05:20", "800000", "160420" ], + "260321" : [ "05:21", "800000", "160420" ], + "260322" : [ "05:22", "800000", "160420" ], + "260323" : [ "05:23", "800000", "160420" ], + "260324" : [ "05:24", "800000", "160420" ], + "260325" : [ "05:25", "800000", "160420" ], + "260326" : [ "05:26", "800000", "160420" ], + "260327" : [ "05:27", "800000", "160420" ], + "260328" : [ "05:28", "800000", "160420" ], + "260329" : [ "05:29", "800000", "160420" ], + "260330" : [ "05:30", "800000", "160420" ], + "260331" : [ "05:31", "800000", "160420" ], + "260332" : [ "05:32", "800000", "160420" ], + "260333" : [ "05:33", "800000", "160420" ], + "260334" : [ "05:34", "800000", "160420" ], + "260335" : [ "05:35", "800000", "160420" ], + "260336" : [ "05:36", "800000", "160420" ], + "260337" : [ "05:37", "800000", "160420" ], + "260338" : [ "05:38", "800000", "160420" ], + "260339" : [ "05:39", "800000", "160420" ], + "260340" : [ "05:40", "800000", "160420" ], + "260341" : [ "05:41", "800000", "160420" ], + "260342" : [ "05:42", "800000", "160420" ], + "260343" : [ "05:43", "800000", "160420" ], + "260344" : [ "05:44", "800000", "160420" ], + "260345" : [ "05:45", "800000", "160420" ], + "260346" : [ "05:46", "800000", "160420" ], + "260347" : [ "05:47", "800000", "160420" ], + "260348" : [ "05:48", "800000", "160420" ], + "260349" : [ "05:49", "800000", "160420" ], + "260350" : [ "05:50", "800000", "160420" ], + "260351" : [ "05:51", "800000", "160420" ], + "260352" : [ "05:52", "800000", "160420" ], + "260353" : [ "05:53", "800000", "160420" ], + "260354" : [ "05:54", "800000", "160420" ], + "260355" : [ "05:55", "800000", "160420" ], + "260356" : [ "05:56", "800000", "160420" ], + "260357" : [ "05:57", "800000", "160420" ], + "260358" : [ "05:58", "800000", "160420" ], + "260359" : [ "05:59", "800000", "160420" ], + "260360" : [ "06:00", "800000", "160420" ], + "260361" : [ "06:01", "800000", "160420" ], + "260362" : [ "06:02", "800000", "160420" ], + "260363" : [ "06:03", "800000", "160420" ], + "260364" : [ "06:04", "800000", "160420" ], + "260365" : [ "06:05", "800000", "160420" ], + "260366" : [ "06:06", "800000", "160420" ], + "260367" : [ "06:07", "800000", "160420" ], + "260368" : [ "06:08", "800000", "160420" ], + "260369" : [ "06:09", "800000", "160420" ], + "260370" : [ "06:10", "800000", "160420" ], + "260371" : [ "06:11", "800000", "160420" ], + "260372" : [ "06:12", "800000", "160420" ], + "260373" : [ "06:13", "800000", "160420" ], + "260374" : [ "06:14", "800000", "160420" ], + "260375" : [ "06:15", "800000", "160420" ], + "260376" : [ "06:16", "800000", "160420" ], + "260377" : [ "06:17", "800000", "160420" ], + "260378" : [ "06:18", "800000", "160420" ], + "260379" : [ "06:19", "800000", "160420" ], + "260380" : [ "06:20", "800000", "160420" ], + "260381" : [ "06:21", "800000", "160420" ], + "260382" : [ "06:22", "800000", "160420" ], + "260383" : [ "06:23", "800000", "160420" ], + "260384" : [ "06:24", "800000", "160420" ], + "260385" : [ "06:25", "800000", "160420" ], + "260386" : [ "06:26", "800000", "160420" ], + "260387" : [ "06:27", "800000", "160420" ], + "260388" : [ "06:28", "800000", "160420" ], + "260389" : [ "06:29", "800000", "160420" ], + "260390" : [ "06:30", "800000", "160420" ], + "260391" : [ "06:31", "800000", "160420" ], + "260392" : [ "06:32", "800000", "160420" ], + "260393" : [ "06:33", "800000", "160420" ], + "260394" : [ "06:34", "800000", "160420" ], + "260395" : [ "06:35", "800000", "160420" ], + "260396" : [ "06:36", "800000", "160420" ], + "260397" : [ "06:37", "800000", "160420" ], + "260398" : [ "06:38", "800000", "160420" ], + "260399" : [ "06:39", "800000", "160420" ], + "260400" : [ "06:40", "800000", "160420" ], + "260401" : [ "06:41", "800000", "160420" ], + "260402" : [ "06:42", "800000", "160420" ], + "260403" : [ "06:43", "800000", "160420" ], + "260404" : [ "06:44", "800000", "160420" ], + "260405" : [ "06:45", "800000", "160420" ], + "260406" : [ "06:46", "800000", "160420" ], + "260407" : [ "06:47", "800000", "160420" ], + "260408" : [ "06:48", "800000", "160420" ], + "260409" : [ "06:49", "800000", "160420" ], + "260410" : [ "06:50", "800000", "160420" ], + "260411" : [ "06:51", "800000", "160420" ], + "260412" : [ "06:52", "800000", "160420" ], + "260413" : [ "06:53", "800000", "160420" ], + "260414" : [ "06:54", "800000", "160420" ], + "260415" : [ "06:55", "800000", "160420" ], + "260416" : [ "06:56", "800000", "160420" ], + "260417" : [ "06:57", "800000", "160420" ], + "260418" : [ "06:58", "800000", "160420" ], + "260419" : [ "06:59", "800000", "160420" ], + "260420" : [ "07:00", "350000", "160480" ], + "260421" : [ "07:01", "350000", "160481" ], + "260422" : [ "07:02", "350000", "160482" ], + "260423" : [ "07:03", "350000", "160483" ], + "260424" : [ "07:04", "350000", "160484" ], + "260425" : [ "07:05", "350000", "160485" ], + "260426" : [ "07:06", "350000", "160486" ], + "260427" : [ "07:07", "350000", "160487" ], + "260428" : [ "07:08", "350000", "160488" ], + "260429" : [ "07:09", "350000", "160489" ], + "260430" : [ "07:10", "350000", "160490" ], + "260431" : [ "07:11", "350000", "160491" ], + "260432" : [ "07:12", "350000", "160492" ], + "260433" : [ "07:13", "350000", "160493" ], + "260434" : [ "07:14", "350000", "160494" ], + "260435" : [ "07:15", "350000", "160495" ], + "260436" : [ "07:16", "350000", "160496" ], + "260437" : [ "07:17", "350000", "160497" ], + "260438" : [ "07:18", "350000", "160498" ], + "260439" : [ "07:19", "350000", "160499" ], + "260440" : [ "07:20", "350000", "160500" ], + "260441" : [ "07:21", "350000", "160501" ], + "260442" : [ "07:22", "350000", "160502" ], + "260443" : [ "07:23", "350000", "160503" ], + "260444" : [ "07:24", "350000", "160504" ], + "260445" : [ "07:25", "350000", "160505" ], + "260446" : [ "07:26", "350000", "160506" ], + "260447" : [ "07:27", "350000", "160507" ], + "260448" : [ "07:28", "350000", "160508" ], + "260449" : [ "07:29", "350000", "160509" ], + "260450" : [ "07:30", "350000", "160510" ], + "260451" : [ "07:31", "350000", "160511" ], + "260452" : [ "07:32", "350000", "160512" ], + "260453" : [ "07:33", "350000", "160513" ], + "260454" : [ "07:34", "350000", "160514" ], + "260455" : [ "07:35", "350000", "160515" ], + "260456" : [ "07:36", "350000", "160516" ], + "260457" : [ "07:37", "350000", "160517" ], + "260458" : [ "07:38", "350000", "160518" ], + "260459" : [ "07:39", "350000", "160519" ], + "260460" : [ "07:40", "350000", "160520" ], + "260461" : [ "07:41", "350000", "160521" ], + "260462" : [ "07:42", "350000", "160522" ], + "260463" : [ "07:43", "350000", "160523" ], + "260464" : [ "07:44", "350000", "160524" ], + "260465" : [ "07:45", "350000", "160525" ], + "260466" : [ "07:46", "350000", "160526" ], + "260467" : [ "07:47", "350000", "160527" ], + "260468" : [ "07:48", "350000", "160528" ], + "260469" : [ "07:49", "350000", "160529" ], + "260470" : [ "07:50", "350000", "160530" ], + "260471" : [ "07:51", "350000", "160531" ], + "260472" : [ "07:52", "350000", "160532" ], + "260473" : [ "07:53", "350000", "160533" ], + "260474" : [ "07:54", "350000", "160534" ], + "260475" : [ "07:55", "350000", "160535" ], + "260476" : [ "07:56", "350000", "160536" ], + "260477" : [ "07:57", "350000", "160537" ], + "260478" : [ "07:58", "350000", "160538" ], + "260479" : [ "07:59", "350000", "160539" ], + "260480" : [ "08:00", "350000", "160540" ], + "260481" : [ "08:01", "350000", "160541" ], + "260482" : [ "08:02", "350000", "160542" ], + "260483" : [ "08:03", "350000", "160543" ], + "260484" : [ "08:04", "350000", "160544" ], + "260485" : [ "08:05", "350000", "160545" ], + "260486" : [ "08:06", "350000", "160546" ], + "260487" : [ "08:07", "350000", "160547" ], + "260488" : [ "08:08", "350000", "160548" ], + "260489" : [ "08:09", "350000", "160549" ], + "260490" : [ "08:10", "350000", "160550" ], + "260491" : [ "08:11", "350000", "160551" ], + "260492" : [ "08:12", "350000", "160552" ], + "260493" : [ "08:13", "350000", "160553" ], + "260494" : [ "08:14", "350000", "160554" ], + "260495" : [ "08:15", "350000", "160555" ], + "260496" : [ "08:16", "350000", "160556" ], + "260497" : [ "08:17", "350000", "160557" ], + "260498" : [ "08:18", "350000", "160558" ], + "260499" : [ "08:19", "350000", "160559" ], + "260500" : [ "08:20", "350000", "160560" ], + "260501" : [ "08:21", "350000", "160561" ], + "260502" : [ "08:22", "350000", "160562" ], + "260503" : [ "08:23", "350000", "160563" ], + "260504" : [ "08:24", "350000", "160564" ], + "260505" : [ "08:25", "350000", "160565" ], + "260506" : [ "08:26", "350000", "160566" ], + "260507" : [ "08:27", "350000", "160567" ], + "260508" : [ "08:28", "350000", "160568" ], + "260509" : [ "08:29", "350000", "160569" ], + "260510" : [ "08:30", "350000", "160570" ], + "260511" : [ "08:31", "350000", "160571" ], + "260512" : [ "08:32", "350000", "160572" ], + "260513" : [ "08:33", "350000", "160573" ], + "260514" : [ "08:34", "350000", "160574" ], + "260515" : [ "08:35", "350000", "160575" ], + "260516" : [ "08:36", "350000", "160576" ], + "260517" : [ "08:37", "350000", "160577" ], + "260518" : [ "08:38", "350000", "160578" ], + "260519" : [ "08:39", "350000", "160579" ], + "260520" : [ "08:40", "350000", "160580" ], + "260521" : [ "08:41", "350000", "160581" ], + "260522" : [ "08:42", "350000", "160582" ], + "260523" : [ "08:43", "350000", "160583" ], + "260524" : [ "08:44", "350000", "160584" ], + "260525" : [ "08:45", "350000", "160585" ], + "260526" : [ "08:46", "350000", "160586" ], + "260527" : [ "08:47", "350000", "160587" ], + "260528" : [ "08:48", "350000", "160588" ], + "260529" : [ "08:49", "350000", "160589" ], + "260530" : [ "08:50", "350000", "160590" ], + "260531" : [ "08:51", "350000", "160591" ], + "260532" : [ "08:52", "350000", "160592" ], + "260533" : [ "08:53", "350000", "160593" ], + "260534" : [ "08:54", "350000", "160594" ], + "260535" : [ "08:55", "350000", "160595" ], + "260536" : [ "08:56", "350000", "160596" ], + "260537" : [ "08:57", "350000", "160597" ], + "260538" : [ "08:58", "350000", "160598" ], + "260539" : [ "08:59", "350000", "160599" ], + "260540" : [ "09:00", "350000", "160600" ], + "260541" : [ "09:01", "350000", "160601" ], + "260542" : [ "09:02", "350000", "160602" ], + "260543" : [ "09:03", "350000", "160603" ], + "260544" : [ "09:04", "350000", "160604" ], + "260545" : [ "09:05", "350000", "160605" ], + "260546" : [ "09:06", "350000", "160606" ], + "260547" : [ "09:07", "350000", "160607" ], + "260548" : [ "09:08", "350000", "160608" ], + "260549" : [ "09:09", "350000", "160609" ], + "260550" : [ "09:10", "350000", "160610" ], + "260551" : [ "09:11", "350000", "160611" ], + "260552" : [ "09:12", "350000", "160612" ], + "260553" : [ "09:13", "350000", "160613" ], + "260554" : [ "09:14", "350000", "160614" ], + "260555" : [ "09:15", "350000", "160615" ], + "260556" : [ "09:16", "350000", "160616" ], + "260557" : [ "09:17", "350000", "160617" ], + "260558" : [ "09:18", "350000", "160618" ], + "260559" : [ "09:19", "350000", "160619" ], + "260560" : [ "09:20", "350000", "160620" ], + "260561" : [ "09:21", "350000", "160621" ], + "260562" : [ "09:22", "350000", "160622" ], + "260563" : [ "09:23", "350000", "160623" ], + "260564" : [ "09:24", "350000", "160624" ], + "260565" : [ "09:25", "350000", "160625" ], + "260566" : [ "09:26", "350000", "160626" ], + "260567" : [ "09:27", "350000", "160627" ], + "260568" : [ "09:28", "350000", "160628" ], + "260569" : [ "09:29", "350000", "160629" ], + "260570" : [ "09:30", "350000", "160630" ], + "260571" : [ "09:31", "350000", "160631" ], + "260572" : [ "09:32", "350000", "160632" ], + "260573" : [ "09:33", "350000", "160633" ], + "260574" : [ "09:34", "350000", "160634" ], + "260575" : [ "09:35", "350000", "160635" ], + "260576" : [ "09:36", "350000", "160636" ], + "260577" : [ "09:37", "350000", "160637" ], + "260578" : [ "09:38", "350000", "160638" ], + "260579" : [ "09:39", "350000", "160639" ], + "260580" : [ "09:40", "350000", "160640" ], + "260581" : [ "09:41", "350000", "160641" ], + "260582" : [ "09:42", "350000", "160642" ], + "260583" : [ "09:43", "350000", "160643" ], + "260584" : [ "09:44", "350000", "160644" ], + "260585" : [ "09:45", "350000", "160645" ], + "260586" : [ "09:46", "350000", "160646" ], + "260587" : [ "09:47", "350000", "160647" ], + "260588" : [ "09:48", "350000", "160648" ], + "260589" : [ "09:49", "350000", "160649" ], + "260590" : [ "09:50", "350000", "160650" ], + "260591" : [ "09:51", "350000", "160651" ], + "260592" : [ "09:52", "350000", "160652" ], + "260593" : [ "09:53", "350000", "160653" ], + "260594" : [ "09:54", "350000", "160654" ], + "260595" : [ "09:55", "350000", "160655" ], + "260596" : [ "09:56", "350000", "160656" ], + "260597" : [ "09:57", "350000", "160657" ], + "260598" : [ "09:58", "350000", "160658" ], + "260599" : [ "09:59", "350000", "160659" ], + "260600" : [ "10:00", "350000", "160660" ], + "260601" : [ "10:01", "350000", "160661" ], + "260602" : [ "10:02", "350000", "160662" ], + "260603" : [ "10:03", "350000", "160663" ], + "260604" : [ "10:04", "350000", "160664" ], + "260605" : [ "10:05", "350000", "160665" ], + "260606" : [ "10:06", "350000", "160666" ], + "260607" : [ "10:07", "350000", "160667" ], + "260608" : [ "10:08", "350000", "160668" ], + "260609" : [ "10:09", "350000", "160669" ], + "260610" : [ "10:10", "350000", "160670" ], + "260611" : [ "10:11", "350000", "160671" ], + "260612" : [ "10:12", "350000", "160672" ], + "260613" : [ "10:13", "350000", "160673" ], + "260614" : [ "10:14", "350000", "160674" ], + "260615" : [ "10:15", "350000", "160675" ], + "260616" : [ "10:16", "350000", "160676" ], + "260617" : [ "10:17", "350000", "160677" ], + "260618" : [ "10:18", "350000", "160678" ], + "260619" : [ "10:19", "350000", "160679" ], + "260620" : [ "10:20", "350000", "160680" ], + "260621" : [ "10:21", "350000", "160681" ], + "260622" : [ "10:22", "350000", "160682" ], + "260623" : [ "10:23", "350000", "160683" ], + "260624" : [ "10:24", "350000", "160684" ], + "260625" : [ "10:25", "350000", "160685" ], + "260626" : [ "10:26", "350000", "160686" ], + "260627" : [ "10:27", "350000", "160687" ], + "260628" : [ "10:28", "350000", "160688" ], + "260629" : [ "10:29", "350000", "160689" ], + "260630" : [ "10:30", "350000", "160690" ], + "260631" : [ "10:31", "350000", "160691" ], + "260632" : [ "10:32", "350000", "160692" ], + "260633" : [ "10:33", "350000", "160693" ], + "260634" : [ "10:34", "350000", "160694" ], + "260635" : [ "10:35", "350000", "160695" ], + "260636" : [ "10:36", "350000", "160696" ], + "260637" : [ "10:37", "350000", "160697" ], + "260638" : [ "10:38", "350000", "160698" ], + "260639" : [ "10:39", "350000", "160699" ], + "260640" : [ "10:40", "350000", "160700" ], + "260641" : [ "10:41", "350000", "160701" ], + "260642" : [ "10:42", "350000", "160702" ], + "260643" : [ "10:43", "350000", "160703" ], + "260644" : [ "10:44", "350000", "160704" ], + "260645" : [ "10:45", "350000", "160705" ], + "260646" : [ "10:46", "350000", "160706" ], + "260647" : [ "10:47", "350000", "160707" ], + "260648" : [ "10:48", "350000", "160708" ], + "260649" : [ "10:49", "350000", "160709" ], + "260650" : [ "10:50", "350000", "160710" ], + "260651" : [ "10:51", "350000", "160711" ], + "260652" : [ "10:52", "350000", "160712" ], + "260653" : [ "10:53", "350000", "160713" ], + "260654" : [ "10:54", "350000", "160714" ], + "260655" : [ "10:55", "350000", "160715" ], + "260656" : [ "10:56", "350000", "160716" ], + "260657" : [ "10:57", "350000", "160717" ], + "260658" : [ "10:58", "350000", "160718" ], + "260659" : [ "10:59", "350000", "160719" ], + "260660" : [ "11:00", "350000", "160720" ], + "260661" : [ "11:01", "350000", "160721" ], + "260662" : [ "11:02", "350000", "160722" ], + "260663" : [ "11:03", "350000", "160723" ], + "260664" : [ "11:04", "350000", "160724" ], + "260665" : [ "11:05", "350000", "160725" ], + "260666" : [ "11:06", "350000", "160726" ], + "260667" : [ "11:07", "350000", "160727" ], + "260668" : [ "11:08", "350000", "160728" ], + "260669" : [ "11:09", "350000", "160729" ], + "260670" : [ "11:10", "350000", "160730" ], + "260671" : [ "11:11", "350000", "160731" ], + "260672" : [ "11:12", "350000", "160732" ], + "260673" : [ "11:13", "350000", "160733" ], + "260674" : [ "11:14", "350000", "160734" ], + "260675" : [ "11:15", "350000", "160735" ], + "260676" : [ "11:16", "350000", "160736" ], + "260677" : [ "11:17", "350000", "160737" ], + "260678" : [ "11:18", "350000", "160738" ], + "260679" : [ "11:19", "350000", "160739" ], + "260680" : [ "11:20", "350000", "160740" ], + "260681" : [ "11:21", "350000", "160741" ], + "260682" : [ "11:22", "350000", "160742" ], + "260683" : [ "11:23", "350000", "160743" ], + "260684" : [ "11:24", "350000", "160744" ], + "260685" : [ "11:25", "350000", "160745" ], + "260686" : [ "11:26", "350000", "160746" ], + "260687" : [ "11:27", "350000", "160747" ], + "260688" : [ "11:28", "350000", "160748" ], + "260689" : [ "11:29", "350000", "160749" ], + "260690" : [ "11:30", "350000", "160750" ], + "260691" : [ "11:31", "350000", "160751" ], + "260692" : [ "11:32", "350000", "160752" ], + "260693" : [ "11:33", "350000", "160753" ], + "260694" : [ "11:34", "350000", "160754" ], + "260695" : [ "11:35", "350000", "160755" ], + "260696" : [ "11:36", "350000", "160756" ], + "260697" : [ "11:37", "350000", "160757" ], + "260698" : [ "11:38", "350000", "160758" ], + "260699" : [ "11:39", "350000", "160759" ], + "260700" : [ "11:40", "350000", "160760" ], + "260701" : [ "11:41", "350000", "160761" ], + "260702" : [ "11:42", "350000", "160762" ], + "260703" : [ "11:43", "350000", "160763" ], + "260704" : [ "11:44", "350000", "160764" ], + "260705" : [ "11:45", "350000", "160765" ], + "260706" : [ "11:46", "350000", "160766" ], + "260707" : [ "11:47", "350000", "160767" ], + "260708" : [ "11:48", "350000", "160768" ], + "260709" : [ "11:49", "350000", "160769" ], + "260710" : [ "11:50", "350000", "160770" ], + "260711" : [ "11:51", "350000", "160771" ], + "260712" : [ "11:52", "350000", "160772" ], + "260713" : [ "11:53", "350000", "160773" ], + "260714" : [ "11:54", "350000", "160774" ], + "260715" : [ "11:55", "350000", "160775" ], + "260716" : [ "11:56", "350000", "160776" ], + "260717" : [ "11:57", "350000", "160777" ], + "260718" : [ "11:58", "350000", "160778" ], + "260719" : [ "11:59", "350000", "160779" ], + "260720" : [ "12:00", "350000", "160780" ], + "260721" : [ "12:01", "350000", "160781" ], + "260722" : [ "12:02", "350000", "160782" ], + "260723" : [ "12:03", "350000", "160783" ], + "260724" : [ "12:04", "350000", "160784" ], + "260725" : [ "12:05", "350000", "160785" ], + "260726" : [ "12:06", "350000", "160786" ], + "260727" : [ "12:07", "350000", "160787" ], + "260728" : [ "12:08", "350000", "160788" ], + "260729" : [ "12:09", "350000", "160789" ], + "260730" : [ "12:10", "350000", "160790" ], + "260731" : [ "12:11", "350000", "160791" ], + "260732" : [ "12:12", "350000", "160792" ], + "260733" : [ "12:13", "350000", "160793" ], + "260734" : [ "12:14", "350000", "160794" ], + "260735" : [ "12:15", "350000", "160795" ], + "260736" : [ "12:16", "350000", "160796" ], + "260737" : [ "12:17", "350000", "160797" ], + "260738" : [ "12:18", "350000", "160798" ], + "260739" : [ "12:19", "350000", "160799" ], + "260740" : [ "12:20", "350000", "160800" ], + "260741" : [ "12:21", "350000", "160801" ], + "260742" : [ "12:22", "350000", "160802" ], + "260743" : [ "12:23", "350000", "160803" ], + "260744" : [ "12:24", "350000", "160804" ], + "260745" : [ "12:25", "350000", "160805" ], + "260746" : [ "12:26", "350000", "160806" ], + "260747" : [ "12:27", "350000", "160807" ], + "260748" : [ "12:28", "350000", "160808" ], + "260749" : [ "12:29", "350000", "160809" ], + "260750" : [ "12:30", "350000", "160810" ], + "260751" : [ "12:31", "350000", "160811" ], + "260752" : [ "12:32", "350000", "160812" ], + "260753" : [ "12:33", "350000", "160813" ], + "260754" : [ "12:34", "350000", "160814" ], + "260755" : [ "12:35", "350000", "160815" ], + "260756" : [ "12:36", "350000", "160816" ], + "260757" : [ "12:37", "350000", "160817" ], + "260758" : [ "12:38", "350000", "160818" ], + "260759" : [ "12:39", "350000", "160819" ], + "260760" : [ "12:40", "350000", "160820" ], + "260761" : [ "12:41", "350000", "160821" ], + "260762" : [ "12:42", "350000", "160822" ], + "260763" : [ "12:43", "350000", "160823" ], + "260764" : [ "12:44", "350000", "160824" ], + "260765" : [ "12:45", "350000", "160825" ], + "260766" : [ "12:46", "350000", "160826" ], + "260767" : [ "12:47", "350000", "160827" ], + "260768" : [ "12:48", "350000", "160828" ], + "260769" : [ "12:49", "350000", "160829" ], + "260770" : [ "12:50", "350000", "160830" ], + "260771" : [ "12:51", "350000", "160831" ], + "260772" : [ "12:52", "350000", "160832" ], + "260773" : [ "12:53", "350000", "160833" ], + "260774" : [ "12:54", "350000", "160834" ], + "260775" : [ "12:55", "350000", "160835" ], + "260776" : [ "12:56", "350000", "160836" ], + "260777" : [ "12:57", "350000", "160837" ], + "260778" : [ "12:58", "350000", "160838" ], + "260779" : [ "12:59", "350000", "160839" ], + "260780" : [ "13:00", "350000", "160840" ], + "260781" : [ "13:01", "350000", "160841" ], + "260782" : [ "13:02", "350000", "160842" ], + "260783" : [ "13:03", "350000", "160843" ], + "260784" : [ "13:04", "350000", "160844" ], + "260785" : [ "13:05", "350000", "160845" ], + "260786" : [ "13:06", "350000", "160846" ], + "260787" : [ "13:07", "350000", "160847" ], + "260788" : [ "13:08", "350000", "160848" ], + "260789" : [ "13:09", "350000", "160849" ], + "260790" : [ "13:10", "350000", "160850" ], + "260791" : [ "13:11", "350000", "160851" ], + "260792" : [ "13:12", "350000", "160852" ], + "260793" : [ "13:13", "350000", "160853" ], + "260794" : [ "13:14", "350000", "160854" ], + "260795" : [ "13:15", "350000", "160855" ], + "260796" : [ "13:16", "350000", "160856" ], + "260797" : [ "13:17", "350000", "160857" ], + "260798" : [ "13:18", "350000", "160858" ], + "260799" : [ "13:19", "350000", "160859" ], + "260800" : [ "13:20", "350000", "160860" ], + "260801" : [ "13:21", "350000", "160861" ], + "260802" : [ "13:22", "350000", "160862" ], + "260803" : [ "13:23", "350000", "160863" ], + "260804" : [ "13:24", "350000", "160864" ], + "260805" : [ "13:25", "350000", "160865" ], + "260806" : [ "13:26", "350000", "160866" ], + "260807" : [ "13:27", "350000", "160867" ], + "260808" : [ "13:28", "350000", "160868" ], + "260809" : [ "13:29", "350000", "160869" ], + "260810" : [ "13:30", "350000", "160870" ], + "260811" : [ "13:31", "350000", "160871" ], + "260812" : [ "13:32", "350000", "160872" ], + "260813" : [ "13:33", "350000", "160873" ], + "260814" : [ "13:34", "350000", "160874" ], + "260815" : [ "13:35", "350000", "160875" ], + "260816" : [ "13:36", "350000", "160876" ], + "260817" : [ "13:37", "350000", "160877" ], + "260818" : [ "13:38", "350000", "160878" ], + "260819" : [ "13:39", "350000", "160879" ], + "260820" : [ "13:40", "350000", "160880" ], + "260821" : [ "13:41", "350000", "160881" ], + "260822" : [ "13:42", "350000", "160882" ], + "260823" : [ "13:43", "350000", "160883" ], + "260824" : [ "13:44", "350000", "160884" ], + "260825" : [ "13:45", "350000", "160885" ], + "260826" : [ "13:46", "350000", "160886" ], + "260827" : [ "13:47", "350000", "160887" ], + "260828" : [ "13:48", "350000", "160888" ], + "260829" : [ "13:49", "350000", "160889" ], + "260830" : [ "13:50", "350000", "160890" ], + "260831" : [ "13:51", "350000", "160891" ], + "260832" : [ "13:52", "350000", "160892" ], + "260833" : [ "13:53", "350000", "160893" ], + "260834" : [ "13:54", "350000", "160894" ], + "260835" : [ "13:55", "350000", "160895" ], + "260836" : [ "13:56", "350000", "160896" ], + "260837" : [ "13:57", "350000", "160897" ], + "260838" : [ "13:58", "350000", "160898" ], + "260839" : [ "13:59", "350000", "160899" ], + "260840" : [ "14:00", "350000", "160900" ], + "260841" : [ "14:01", "350000", "160901" ], + "260842" : [ "14:02", "350000", "160902" ], + "260843" : [ "14:03", "350000", "160903" ], + "260844" : [ "14:04", "350000", "160904" ], + "260845" : [ "14:05", "350000", "160905" ], + "260846" : [ "14:06", "350000", "160906" ], + "260847" : [ "14:07", "350000", "160907" ], + "260848" : [ "14:08", "350000", "160908" ], + "260849" : [ "14:09", "350000", "160909" ], + "260850" : [ "14:10", "350000", "160910" ], + "260851" : [ "14:11", "350000", "160911" ], + "260852" : [ "14:12", "350000", "160912" ], + "260853" : [ "14:13", "350000", "160913" ], + "260854" : [ "14:14", "350000", "160914" ], + "260855" : [ "14:15", "350000", "160915" ], + "260856" : [ "14:16", "350000", "160916" ], + "260857" : [ "14:17", "350000", "160917" ], + "260858" : [ "14:18", "350000", "160918" ], + "260859" : [ "14:19", "350000", "160919" ], + "260860" : [ "14:20", "350000", "160920" ], + "260861" : [ "14:21", "350000", "160921" ], + "260862" : [ "14:22", "350000", "160922" ], + "260863" : [ "14:23", "350000", "160923" ], + "260864" : [ "14:24", "350000", "160924" ], + "260865" : [ "14:25", "350000", "160925" ], + "260866" : [ "14:26", "350000", "160926" ], + "260867" : [ "14:27", "350000", "160927" ], + "260868" : [ "14:28", "350000", "160928" ], + "260869" : [ "14:29", "350000", "160929" ], + "260870" : [ "14:30", "350000", "160930" ], + "260871" : [ "14:31", "350000", "160931" ], + "260872" : [ "14:32", "350000", "160932" ], + "260873" : [ "14:33", "350000", "160933" ], + "260874" : [ "14:34", "350000", "160934" ], + "260875" : [ "14:35", "350000", "160935" ], + "260876" : [ "14:36", "350000", "160936" ], + "260877" : [ "14:37", "350000", "160937" ], + "260878" : [ "14:38", "350000", "160938" ], + "260879" : [ "14:39", "350000", "160939" ], + "260880" : [ "14:40", "350000", "160940" ], + "260881" : [ "14:41", "350000", "160941" ], + "260882" : [ "14:42", "350000", "160942" ], + "260883" : [ "14:43", "350000", "160943" ], + "260884" : [ "14:44", "350000", "160944" ], + "260885" : [ "14:45", "350000", "160945" ], + "260886" : [ "14:46", "350000", "160946" ], + "260887" : [ "14:47", "350000", "160947" ], + "260888" : [ "14:48", "350000", "160948" ], + "260889" : [ "14:49", "350000", "160949" ], + "260890" : [ "14:50", "350000", "160950" ], + "260891" : [ "14:51", "350000", "160951" ], + "260892" : [ "14:52", "350000", "160952" ], + "260893" : [ "14:53", "350000", "160953" ], + "260894" : [ "14:54", "350000", "160954" ], + "260895" : [ "14:55", "350000", "160955" ], + "260896" : [ "14:56", "350000", "160956" ], + "260897" : [ "14:57", "350000", "160957" ], + "260898" : [ "14:58", "350000", "160958" ], + "260899" : [ "14:59", "350000", "160959" ], + "260900" : [ "15:00", "350000", "160960" ], + "260901" : [ "15:01", "350000", "160961" ], + "260902" : [ "15:02", "350000", "160962" ], + "260903" : [ "15:03", "350000", "160963" ], + "260904" : [ "15:04", "350000", "160964" ], + "260905" : [ "15:05", "350000", "160965" ], + "260906" : [ "15:06", "350000", "160966" ], + "260907" : [ "15:07", "350000", "160967" ], + "260908" : [ "15:08", "350000", "160968" ], + "260909" : [ "15:09", "350000", "160969" ], + "260910" : [ "15:10", "350000", "160970" ], + "260911" : [ "15:11", "350000", "160971" ], + "260912" : [ "15:12", "350000", "160972" ], + "260913" : [ "15:13", "350000", "160973" ], + "260914" : [ "15:14", "350000", "160974" ], + "260915" : [ "15:15", "350000", "160975" ], + "260916" : [ "15:16", "350000", "160976" ], + "260917" : [ "15:17", "350000", "160977" ], + "260918" : [ "15:18", "350000", "160978" ], + "260919" : [ "15:19", "350000", "160979" ], + "260920" : [ "15:20", "350000", "160980" ], + "260921" : [ "15:21", "350000", "160981" ], + "260922" : [ "15:22", "350000", "160982" ], + "260923" : [ "15:23", "350000", "160983" ], + "260924" : [ "15:24", "350000", "160984" ], + "260925" : [ "15:25", "350000", "160985" ], + "260926" : [ "15:26", "350000", "160986" ], + "260927" : [ "15:27", "350000", "160987" ], + "260928" : [ "15:28", "350000", "160988" ], + "260929" : [ "15:29", "350000", "160989" ], + "260930" : [ "15:30", "350000", "160990" ], + "260931" : [ "15:31", "350000", "160991" ], + "260932" : [ "15:32", "350000", "160992" ], + "260933" : [ "15:33", "350000", "160993" ], + "260934" : [ "15:34", "350000", "160994" ], + "260935" : [ "15:35", "350000", "160995" ], + "260936" : [ "15:36", "350000", "160996" ], + "260937" : [ "15:37", "350000", "160997" ], + "260938" : [ "15:38", "350000", "160998" ], + "260939" : [ "15:39", "350000", "160999" ], + "260940" : [ "15:40", "350000", "161000" ], + "260941" : [ "15:41", "350000", "161001" ], + "260942" : [ "15:42", "350000", "161002" ], + "260943" : [ "15:43", "350000", "161003" ], + "260944" : [ "15:44", "350000", "161004" ], + "260945" : [ "15:45", "350000", "161005" ], + "260946" : [ "15:46", "350000", "161006" ], + "260947" : [ "15:47", "350000", "161007" ], + "260948" : [ "15:48", "350000", "161008" ], + "260949" : [ "15:49", "350000", "161009" ], + "260950" : [ "15:50", "350000", "161010" ], + "260951" : [ "15:51", "350000", "161011" ], + "260952" : [ "15:52", "350000", "161012" ], + "260953" : [ "15:53", "350000", "161013" ], + "260954" : [ "15:54", "350000", "161014" ], + "260955" : [ "15:55", "350000", "161015" ], + "260956" : [ "15:56", "350000", "161016" ], + "260957" : [ "15:57", "350000", "161017" ], + "260958" : [ "15:58", "350000", "161018" ], + "260959" : [ "15:59", "350000", "161019" ], + "260960" : [ "16:00", "350000", "161020" ], + "260961" : [ "16:01", "350000", "161021" ], + "260962" : [ "16:02", "350000", "161022" ], + "260963" : [ "16:03", "350000", "161023" ], + "260964" : [ "16:04", "350000", "161024" ], + "260965" : [ "16:05", "350000", "161025" ], + "260966" : [ "16:06", "350000", "161026" ], + "260967" : [ "16:07", "350000", "161027" ], + "260968" : [ "16:08", "350000", "161028" ], + "260969" : [ "16:09", "350000", "161029" ], + "260970" : [ "16:10", "350000", "161030" ], + "260971" : [ "16:11", "350000", "161031" ], + "260972" : [ "16:12", "350000", "161032" ], + "260973" : [ "16:13", "350000", "161033" ], + "260974" : [ "16:14", "350000", "161034" ], + "260975" : [ "16:15", "350000", "161035" ], + "260976" : [ "16:16", "350000", "161036" ], + "260977" : [ "16:17", "350000", "161037" ], + "260978" : [ "16:18", "350000", "161038" ], + "260979" : [ "16:19", "350000", "161039" ], + "260980" : [ "16:20", "350000", "161040" ], + "260981" : [ "16:21", "350000", "161041" ], + "260982" : [ "16:22", "350000", "161042" ], + "260983" : [ "16:23", "350000", "161043" ], + "260984" : [ "16:24", "350000", "161044" ], + "260985" : [ "16:25", "350000", "161045" ], + "260986" : [ "16:26", "350000", "161046" ], + "260987" : [ "16:27", "350000", "161047" ], + "260988" : [ "16:28", "350000", "161048" ], + "260989" : [ "16:29", "350000", "161049" ], + "260990" : [ "16:30", "350000", "161050" ], + "260991" : [ "16:31", "350000", "161051" ], + "260992" : [ "16:32", "350000", "161052" ], + "260993" : [ "16:33", "350000", "161053" ], + "260994" : [ "16:34", "350000", "161054" ], + "260995" : [ "16:35", "350000", "161055" ], + "260996" : [ "16:36", "350000", "161056" ], + "260997" : [ "16:37", "350000", "161057" ], + "260998" : [ "16:38", "350000", "161058" ], + "260999" : [ "16:39", "350000", "161059" ], + "261000" : [ "16:40", "350000", "161060" ], + "261001" : [ "16:41", "350000", "161061" ], + "261002" : [ "16:42", "350000", "161062" ], + "261003" : [ "16:43", "350000", "161063" ], + "261004" : [ "16:44", "350000", "161064" ], + "261005" : [ "16:45", "350000", "161065" ], + "261006" : [ "16:46", "350000", "161066" ], + "261007" : [ "16:47", "350000", "161067" ], + "261008" : [ "16:48", "350000", "161068" ], + "261009" : [ "16:49", "350000", "161069" ], + "261010" : [ "16:50", "350000", "161070" ], + "261011" : [ "16:51", "350000", "161071" ], + "261012" : [ "16:52", "350000", "161072" ], + "261013" : [ "16:53", "350000", "161073" ], + "261014" : [ "16:54", "350000", "161074" ], + "261015" : [ "16:55", "350000", "161075" ], + "261016" : [ "16:56", "350000", "161076" ], + "261017" : [ "16:57", "350000", "161077" ], + "261018" : [ "16:58", "350000", "161078" ], + "261019" : [ "16:59", "350000", "161079" ], + "261020" : [ "17:00", "350000", "161080" ], + "261021" : [ "17:01", "350000", "161081" ], + "261022" : [ "17:02", "350000", "161082" ], + "261023" : [ "17:03", "350000", "161083" ], + "261024" : [ "17:04", "350000", "161084" ], + "261025" : [ "17:05", "350000", "161085" ], + "261026" : [ "17:06", "350000", "161086" ], + "261027" : [ "17:07", "350000", "161087" ], + "261028" : [ "17:08", "350000", "161088" ], + "261029" : [ "17:09", "350000", "161089" ], + "261030" : [ "17:10", "350000", "161090" ], + "261031" : [ "17:11", "350000", "161091" ], + "261032" : [ "17:12", "350000", "161092" ], + "261033" : [ "17:13", "350000", "161093" ], + "261034" : [ "17:14", "350000", "161094" ], + "261035" : [ "17:15", "350000", "161095" ], + "261036" : [ "17:16", "350000", "161096" ], + "261037" : [ "17:17", "350000", "161097" ], + "261038" : [ "17:18", "350000", "161098" ], + "261039" : [ "17:19", "350000", "161099" ], + "261040" : [ "17:20", "350000", "161100" ], + "261041" : [ "17:21", "350000", "161101" ], + "261042" : [ "17:22", "350000", "161102" ], + "261043" : [ "17:23", "350000", "161103" ], + "261044" : [ "17:24", "350000", "161104" ], + "261045" : [ "17:25", "350000", "161105" ], + "261046" : [ "17:26", "350000", "161106" ], + "261047" : [ "17:27", "350000", "161107" ], + "261048" : [ "17:28", "350000", "161108" ], + "261049" : [ "17:29", "350000", "161109" ], + "261050" : [ "17:30", "350000", "161110" ], + "261051" : [ "17:31", "350000", "161111" ], + "261052" : [ "17:32", "350000", "161112" ], + "261053" : [ "17:33", "350000", "161113" ], + "261054" : [ "17:34", "350000", "161114" ], + "261055" : [ "17:35", "350000", "161115" ], + "261056" : [ "17:36", "350000", "161116" ], + "261057" : [ "17:37", "350000", "161117" ], + "261058" : [ "17:38", "350000", "161118" ], + "261059" : [ "17:39", "350000", "161119" ], + "261060" : [ "17:40", "350000", "161120" ], + "261061" : [ "17:41", "350000", "161121" ], + "261062" : [ "17:42", "350000", "161122" ], + "261063" : [ "17:43", "350000", "161123" ], + "261064" : [ "17:44", "350000", "161124" ], + "261065" : [ "17:45", "350000", "161125" ], + "261066" : [ "17:46", "350000", "161126" ], + "261067" : [ "17:47", "350000", "161127" ], + "261068" : [ "17:48", "350000", "161128" ], + "261069" : [ "17:49", "350000", "161129" ], + "261070" : [ "17:50", "350000", "161130" ], + "261071" : [ "17:51", "350000", "161131" ], + "261072" : [ "17:52", "350000", "161132" ], + "261073" : [ "17:53", "350000", "161133" ], + "261074" : [ "17:54", "350000", "161134" ], + "261075" : [ "17:55", "350000", "161135" ], + "261076" : [ "17:56", "350000", "161136" ], + "261077" : [ "17:57", "350000", "161137" ], + "261078" : [ "17:58", "350000", "161138" ], + "261079" : [ "17:59", "350000", "161139" ], + "261080" : [ "18:00", "350000", "161140" ], + "261081" : [ "18:01", "350000", "161141" ], + "261082" : [ "18:02", "350000", "161142" ], + "261083" : [ "18:03", "350000", "161143" ], + "261084" : [ "18:04", "350000", "161144" ], + "261085" : [ "18:05", "350000", "161145" ], + "261086" : [ "18:06", "350000", "161146" ], + "261087" : [ "18:07", "350000", "161147" ], + "261088" : [ "18:08", "350000", "161148" ], + "261089" : [ "18:09", "350000", "161149" ], + "261090" : [ "18:10", "350000", "161150" ], + "261091" : [ "18:11", "350000", "161151" ], + "261092" : [ "18:12", "350000", "161152" ], + "261093" : [ "18:13", "350000", "161153" ], + "261094" : [ "18:14", "350000", "161154" ], + "261095" : [ "18:15", "350000", "161155" ], + "261096" : [ "18:16", "350000", "161156" ], + "261097" : [ "18:17", "350000", "161157" ], + "261098" : [ "18:18", "350000", "161158" ], + "261099" : [ "18:19", "350000", "161159" ], + "261100" : [ "18:20", "350000", "161160" ], + "261101" : [ "18:21", "350000", "161161" ], + "261102" : [ "18:22", "350000", "161162" ], + "261103" : [ "18:23", "350000", "161163" ], + "261104" : [ "18:24", "350000", "161164" ], + "261105" : [ "18:25", "350000", "161165" ], + "261106" : [ "18:26", "350000", "161166" ], + "261107" : [ "18:27", "350000", "161167" ], + "261108" : [ "18:28", "350000", "161168" ], + "261109" : [ "18:29", "350000", "161169" ], + "261110" : [ "18:30", "350000", "161170" ], + "261111" : [ "18:31", "350000", "161171" ], + "261112" : [ "18:32", "350000", "161172" ], + "261113" : [ "18:33", "350000", "161173" ], + "261114" : [ "18:34", "350000", "161174" ], + "261115" : [ "18:35", "350000", "161175" ], + "261116" : [ "18:36", "350000", "161176" ], + "261117" : [ "18:37", "350000", "161177" ], + "261118" : [ "18:38", "350000", "161178" ], + "261119" : [ "18:39", "350000", "161179" ], + "261120" : [ "18:40", "350000", "161180" ], + "261121" : [ "18:41", "350000", "161181" ], + "261122" : [ "18:42", "350000", "161182" ], + "261123" : [ "18:43", "350000", "161183" ], + "261124" : [ "18:44", "350000", "161184" ], + "261125" : [ "18:45", "350000", "161185" ], + "261126" : [ "18:46", "350000", "161186" ], + "261127" : [ "18:47", "350000", "161187" ], + "261128" : [ "18:48", "350000", "161188" ], + "261129" : [ "18:49", "350000", "161189" ], + "261130" : [ "18:50", "350000", "161190" ], + "261131" : [ "18:51", "350000", "161191" ], + "261132" : [ "18:52", "350000", "161192" ], + "261133" : [ "18:53", "350000", "161193" ], + "261134" : [ "18:54", "350000", "161194" ], + "261135" : [ "18:55", "350000", "161195" ], + "261136" : [ "18:56", "350000", "161196" ], + "261137" : [ "18:57", "350000", "161197" ], + "261138" : [ "18:58", "350000", "161198" ], + "261139" : [ "18:59", "350000", "161199" ], + "261140" : [ "19:00", "350000", "161200" ], + "261141" : [ "19:01", "350000", "161200" ], + "261142" : [ "19:02", "350000", "161200" ], + "261143" : [ "19:03", "350000", "161200" ], + "261144" : [ "19:04", "350000", "161200" ], + "261145" : [ "19:05", "350000", "161200" ], + "261146" : [ "19:06", "350000", "161200" ], + "261147" : [ "19:07", "350000", "161200" ], + "261148" : [ "19:08", "350000", "161200" ], + "261149" : [ "19:09", "350000", "161200" ], + "261150" : [ "19:10", "350000", "161200" ], + "261151" : [ "19:11", "350000", "161200" ], + "261152" : [ "19:12", "350000", "161200" ], + "261153" : [ "19:13", "350000", "161200" ], + "261154" : [ "19:14", "350000", "161200" ], + "261155" : [ "19:15", "350000", "161200" ], + "261156" : [ "19:16", "350000", "161200" ], + "261157" : [ "19:17", "350000", "161200" ], + "261158" : [ "19:18", "350000", "161200" ], + "261159" : [ "19:19", "350000", "161200" ], + "261160" : [ "19:20", "350000", "161200" ], + "261161" : [ "19:21", "350000", "161200" ], + "261162" : [ "19:22", "350000", "161200" ], + "261163" : [ "19:23", "350000", "161200" ], + "261164" : [ "19:24", "350000", "161200" ], + "261165" : [ "19:25", "350000", "161200" ], + "261166" : [ "19:26", "350000", "161200" ], + "261167" : [ "19:27", "350000", "161200" ], + "261168" : [ "19:28", "350000", "161200" ], + "261169" : [ "19:29", "350000", "161200" ], + "261170" : [ "19:30", "350000", "161200" ], + "261171" : [ "19:31", "350000", "161200" ], + "261172" : [ "19:32", "350000", "161200" ], + "261173" : [ "19:33", "350000", "161200" ], + "261174" : [ "19:34", "350000", "161200" ], + "261175" : [ "19:35", "350000", "161200" ], + "261176" : [ "19:36", "350000", "161200" ], + "261177" : [ "19:37", "350000", "161200" ], + "261178" : [ "19:38", "350000", "161200" ], + "261179" : [ "19:39", "350000", "161200" ], + "261180" : [ "19:40", "350000", "161200" ], + "261181" : [ "19:41", "350000", "161200" ], + "261182" : [ "19:42", "350000", "161200" ], + "261183" : [ "19:43", "350000", "161200" ], + "261184" : [ "19:44", "350000", "161200" ], + "261185" : [ "19:45", "350000", "161200" ], + "261186" : [ "19:46", "350000", "161200" ], + "261187" : [ "19:47", "350000", "161200" ], + "261188" : [ "19:48", "350000", "161200" ], + "261189" : [ "19:49", "350000", "161200" ], + "261190" : [ "19:50", "350000", "161200" ], + "261191" : [ "19:51", "350000", "161200" ], + "261192" : [ "19:52", "350000", "161200" ], + "261193" : [ "19:53", "350000", "161200" ], + "261194" : [ "19:54", "350000", "161200" ], + "261195" : [ "19:55", "350000", "161200" ], + "261196" : [ "19:56", "350000", "161200" ], + "261197" : [ "19:57", "350000", "161200" ], + "261198" : [ "19:58", "350000", "161200" ], + "261199" : [ "19:59", "350000", "161200" ], + "261200" : [ "20:00", "800000", "060420" ], + "261201" : [ "20:01", "800000", "060420" ], + "261202" : [ "20:02", "800000", "060420" ], + "261203" : [ "20:03", "800000", "060420" ], + "261204" : [ "20:04", "800000", "060420" ], + "261205" : [ "20:05", "800000", "060420" ], + "261206" : [ "20:06", "800000", "060420" ], + "261207" : [ "20:07", "800000", "060420" ], + "261208" : [ "20:08", "800000", "060420" ], + "261209" : [ "20:09", "800000", "060420" ], + "261210" : [ "20:10", "800000", "060420" ], + "261211" : [ "20:11", "800000", "060420" ], + "261212" : [ "20:12", "800000", "060420" ], + "261213" : [ "20:13", "800000", "060420" ], + "261214" : [ "20:14", "800000", "060420" ], + "261215" : [ "20:15", "800000", "060420" ], + "261216" : [ "20:16", "800000", "060420" ], + "261217" : [ "20:17", "800000", "060420" ], + "261218" : [ "20:18", "800000", "060420" ], + "261219" : [ "20:19", "800000", "060420" ], + "261220" : [ "20:20", "800000", "060420" ], + "261221" : [ "20:21", "800000", "060420" ], + "261222" : [ "20:22", "800000", "060420" ], + "261223" : [ "20:23", "800000", "060420" ], + "261224" : [ "20:24", "800000", "060420" ], + "261225" : [ "20:25", "800000", "060420" ], + "261226" : [ "20:26", "800000", "060420" ], + "261227" : [ "20:27", "800000", "060420" ], + "261228" : [ "20:28", "800000", "060420" ], + "261229" : [ "20:29", "800000", "060420" ], + "261230" : [ "20:30", "800000", "060420" ], + "261231" : [ "20:31", "800000", "060420" ], + "261232" : [ "20:32", "800000", "060420" ], + "261233" : [ "20:33", "800000", "060420" ], + "261234" : [ "20:34", "800000", "060420" ], + "261235" : [ "20:35", "800000", "060420" ], + "261236" : [ "20:36", "800000", "060420" ], + "261237" : [ "20:37", "800000", "060420" ], + "261238" : [ "20:38", "800000", "060420" ], + "261239" : [ "20:39", "800000", "060420" ], + "261240" : [ "20:40", "800000", "060420" ], + "261241" : [ "20:41", "800000", "060420" ], + "261242" : [ "20:42", "800000", "060420" ], + "261243" : [ "20:43", "800000", "060420" ], + "261244" : [ "20:44", "800000", "060420" ], + "261245" : [ "20:45", "800000", "060420" ], + "261246" : [ "20:46", "800000", "060420" ], + "261247" : [ "20:47", "800000", "060420" ], + "261248" : [ "20:48", "800000", "060420" ], + "261249" : [ "20:49", "800000", "060420" ], + "261250" : [ "20:50", "800000", "060420" ], + "261251" : [ "20:51", "800000", "060420" ], + "261252" : [ "20:52", "800000", "060420" ], + "261253" : [ "20:53", "800000", "060420" ], + "261254" : [ "20:54", "800000", "060420" ], + "261255" : [ "20:55", "800000", "060420" ], + "261256" : [ "20:56", "800000", "060420" ], + "261257" : [ "20:57", "800000", "060420" ], + "261258" : [ "20:58", "800000", "060420" ], + "261259" : [ "20:59", "800000", "060420" ], + "261260" : [ "21:00", "800000", "060420" ], + "261261" : [ "21:01", "800000", "060420" ], + "261262" : [ "21:02", "800000", "060420" ], + "261263" : [ "21:03", "800000", "060420" ], + "261264" : [ "21:04", "800000", "060420" ], + "261265" : [ "21:05", "800000", "060420" ], + "261266" : [ "21:06", "800000", "060420" ], + "261267" : [ "21:07", "800000", "060420" ], + "261268" : [ "21:08", "800000", "060420" ], + "261269" : [ "21:09", "800000", "060420" ], + "261270" : [ "21:10", "800000", "060420" ], + "261271" : [ "21:11", "800000", "060420" ], + "261272" : [ "21:12", "800000", "060420" ], + "261273" : [ "21:13", "800000", "060420" ], + "261274" : [ "21:14", "800000", "060420" ], + "261275" : [ "21:15", "800000", "060420" ], + "261276" : [ "21:16", "800000", "060420" ], + "261277" : [ "21:17", "800000", "060420" ], + "261278" : [ "21:18", "800000", "060420" ], + "261279" : [ "21:19", "800000", "060420" ], + "261280" : [ "21:20", "800000", "060420" ], + "261281" : [ "21:21", "800000", "060420" ], + "261282" : [ "21:22", "800000", "060420" ], + "261283" : [ "21:23", "800000", "060420" ], + "261284" : [ "21:24", "800000", "060420" ], + "261285" : [ "21:25", "800000", "060420" ], + "261286" : [ "21:26", "800000", "060420" ], + "261287" : [ "21:27", "800000", "060420" ], + "261288" : [ "21:28", "800000", "060420" ], + "261289" : [ "21:29", "800000", "060420" ], + "261290" : [ "21:30", "800000", "060420" ], + "261291" : [ "21:31", "800000", "060420" ], + "261292" : [ "21:32", "800000", "060420" ], + "261293" : [ "21:33", "800000", "060420" ], + "261294" : [ "21:34", "800000", "060420" ], + "261295" : [ "21:35", "800000", "060420" ], + "261296" : [ "21:36", "800000", "060420" ], + "261297" : [ "21:37", "800000", "060420" ], + "261298" : [ "21:38", "800000", "060420" ], + "261299" : [ "21:39", "800000", "060420" ], + "261300" : [ "21:40", "800000", "000420" ], + "261301" : [ "21:41", "800000", "000420" ], + "261302" : [ "21:42", "800000", "000420" ], + "261303" : [ "21:43", "800000", "000420" ], + "261304" : [ "21:44", "800000", "000420" ], + "261305" : [ "21:45", "800000", "000420" ], + "261306" : [ "21:46", "800000", "000420" ], + "261307" : [ "21:47", "800000", "000420" ], + "261308" : [ "21:48", "800000", "000420" ], + "261309" : [ "21:49", "800000", "000420" ], + "261310" : [ "21:50", "800000", "000420" ], + "261311" : [ "21:51", "800000", "000420" ], + "261312" : [ "21:52", "800000", "000420" ], + "261313" : [ "21:53", "800000", "000420" ], + "261314" : [ "21:54", "800000", "000420" ], + "261315" : [ "21:55", "800000", "000420" ], + "261316" : [ "21:56", "800000", "000420" ], + "261317" : [ "21:57", "800000", "000420" ], + "261318" : [ "21:58", "800000", "000420" ], + "261319" : [ "21:59", "800000", "000420" ], + "261320" : [ "22:00", "800000", "000420" ], + "261321" : [ "22:01", "800000", "000420" ], + "261322" : [ "22:02", "800000", "000420" ], + "261323" : [ "22:03", "800000", "000420" ], + "261324" : [ "22:04", "800000", "000420" ], + "261325" : [ "22:05", "800000", "000420" ], + "261326" : [ "22:06", "800000", "000420" ], + "261327" : [ "22:07", "800000", "000420" ], + "261328" : [ "22:08", "800000", "000420" ], + "261329" : [ "22:09", "800000", "000420" ], + "261330" : [ "22:10", "800000", "000420" ], + "261331" : [ "22:11", "800000", "000420" ], + "261332" : [ "22:12", "800000", "000420" ], + "261333" : [ "22:13", "800000", "000420" ], + "261334" : [ "22:14", "800000", "000420" ], + "261335" : [ "22:15", "800000", "000420" ], + "261336" : [ "22:16", "800000", "000420" ], + "261337" : [ "22:17", "800000", "000420" ], + "261338" : [ "22:18", "800000", "000420" ], + "261339" : [ "22:19", "800000", "000420" ], + "261340" : [ "22:20", "800000", "000420" ], + "261341" : [ "22:21", "800000", "000420" ], + "261342" : [ "22:22", "800000", "000420" ], + "261343" : [ "22:23", "800000", "000420" ], + "261344" : [ "22:24", "800000", "000420" ], + "261345" : [ "22:25", "800000", "000420" ], + "261346" : [ "22:26", "800000", "000420" ], + "261347" : [ "22:27", "800000", "000420" ], + "261348" : [ "22:28", "800000", "000420" ], + "261349" : [ "22:29", "800000", "000420" ], + "261350" : [ "22:30", "800000", "000420" ], + "261351" : [ "22:31", "800000", "000420" ], + "261352" : [ "22:32", "800000", "000420" ], + "261353" : [ "22:33", "800000", "000420" ], + "261354" : [ "22:34", "800000", "000420" ], + "261355" : [ "22:35", "800000", "000420" ], + "261356" : [ "22:36", "800000", "000420" ], + "261357" : [ "22:37", "800000", "000420" ], + "261358" : [ "22:38", "800000", "000420" ], + "261359" : [ "22:39", "800000", "000420" ], + "261360" : [ "22:40", "800000", "000420" ], + "261361" : [ "22:41", "800000", "000420" ], + "261362" : [ "22:42", "800000", "000420" ], + "261363" : [ "22:43", "800000", "000420" ], + "261364" : [ "22:44", "800000", "000420" ], + "261365" : [ "22:45", "800000", "000420" ], + "261366" : [ "22:46", "800000", "000420" ], + "261367" : [ "22:47", "800000", "000420" ], + "261368" : [ "22:48", "800000", "000420" ], + "261369" : [ "22:49", "800000", "000420" ], + "261370" : [ "22:50", "800000", "000420" ], + "261371" : [ "22:51", "800000", "000420" ], + "261372" : [ "22:52", "800000", "000420" ], + "261373" : [ "22:53", "800000", "000420" ], + "261374" : [ "22:54", "800000", "000420" ], + "261375" : [ "22:55", "800000", "000420" ], + "261376" : [ "22:56", "800000", "000420" ], + "261377" : [ "22:57", "800000", "000420" ], + "261378" : [ "22:58", "800000", "000420" ], + "261379" : [ "22:59", "800000", "000420" ], + "261380" : [ "23:00", "800000", "000420" ], + "261381" : [ "23:01", "800000", "000420" ], + "261382" : [ "23:02", "800000", "000420" ], + "261383" : [ "23:03", "800000", "000420" ], + "261384" : [ "23:04", "800000", "000420" ], + "261385" : [ "23:05", "800000", "000420" ], + "261386" : [ "23:06", "800000", "000420" ], + "261387" : [ "23:07", "800000", "000420" ], + "261388" : [ "23:08", "800000", "000420" ], + "261389" : [ "23:09", "800000", "000420" ], + "261390" : [ "23:10", "800000", "000420" ], + "261391" : [ "23:11", "800000", "000420" ], + "261392" : [ "23:12", "800000", "000420" ], + "261393" : [ "23:13", "800000", "000420" ], + "261394" : [ "23:14", "800000", "000420" ], + "261395" : [ "23:15", "800000", "000420" ], + "261396" : [ "23:16", "800000", "000420" ], + "261397" : [ "23:17", "800000", "000420" ], + "261398" : [ "23:18", "800000", "000420" ], + "261399" : [ "23:19", "800000", "000420" ], + "261400" : [ "23:20", "800000", "000420" ], + "261401" : [ "23:21", "800000", "000420" ], + "261402" : [ "23:22", "800000", "000420" ], + "261403" : [ "23:23", "800000", "000420" ], + "261404" : [ "23:24", "800000", "000420" ], + "261405" : [ "23:25", "800000", "000420" ], + "261406" : [ "23:26", "800000", "000420" ], + "261407" : [ "23:27", "800000", "000420" ], + "261408" : [ "23:28", "800000", "000420" ], + "261409" : [ "23:29", "800000", "000420" ], + "261410" : [ "23:30", "800000", "000420" ], + "261411" : [ "23:31", "800000", "000420" ], + "261412" : [ "23:32", "800000", "000420" ], + "261413" : [ "23:33", "800000", "000420" ], + "261414" : [ "23:34", "800000", "000420" ], + "261415" : [ "23:35", "800000", "000420" ], + "261416" : [ "23:36", "800000", "000420" ], + "261417" : [ "23:37", "800000", "000420" ], + "261418" : [ "23:38", "800000", "000420" ], + "261419" : [ "23:39", "800000", "000420" ], + "261420" : [ "23:40", "800000", "000420" ], + "261421" : [ "23:41", "800000", "000420" ], + "261422" : [ "23:42", "800000", "000420" ], + "261423" : [ "23:43", "800000", "000420" ], + "261424" : [ "23:44", "800000", "000420" ], + "261425" : [ "23:45", "800000", "000420" ], + "261426" : [ "23:46", "800000", "000420" ], + "261427" : [ "23:47", "800000", "000420" ], + "261428" : [ "23:48", "800000", "000420" ], + "261429" : [ "23:49", "800000", "000420" ], + "261430" : [ "23:50", "800000", "000420" ], + "261431" : [ "23:51", "800000", "000420" ], + "261432" : [ "23:52", "800000", "000420" ], + "261433" : [ "23:53", "800000", "000420" ], + "261434" : [ "23:54", "800000", "000420" ], + "261435" : [ "23:55", "800000", "000420" ], + "261436" : [ "23:56", "800000", "000420" ], + "261437" : [ "23:57", "800000", "000420" ], + "261438" : [ "23:58", "800000", "000420" ], + "261439" : [ "23:59", "800000", "000420" ] + } + } +} diff --git a/calculate_parking_tickets/germersheim.conf.bck b/calculate_parking_tickets/germersheim.conf.bck new file mode 100644 index 0000000..2d4ef36 --- /dev/null +++ b/calculate_parking_tickets/germersheim.conf.bck @@ -0,0 +1,368 @@ +{ + "name":"test", + "properties": [ + ], + "week1" : { + "Monday": { + "TariffStep000" : [ "00:00", "800000", "TariffStep001" ], + "TariffStep001" : [ "07:00", "350000", "TariffStep002" ], + "TariffStep002" : [ "08:00", "350000", "TariffStep003" ], + "TariffStep003" : [ "09:00", "350000", "TariffStep004" ], + "TariffStep004" : [ "10:00", "350000", "TariffStep005" ], + "TariffStep005" : [ "11:00", "350000", "TariffStep006" ], + "TariffStep006" : [ "12:00", "350000", "TariffStep007" ], + "TariffStep007" : [ "13:00", "350000", "TariffStep008" ], + "TariffStep008" : [ "14:00", "350000", "TariffStep009" ], + "TariffStep009" : [ "15:00", "350000", "TariffStep0010"], + "TariffStep0010": [ "16:00", "350000", "TariffStep0011"], + "TariffStep0011": [ "17:00", "350000", "TariffStep0012"], + "TariffStep0012": [ "18:00", "350000", "TariffStep0013"], + "TariffStep0013": [ "19:00", "350000", "TariffStep0014"], + "TariffStep0014": [ "20:00", "800000", "TariffStep011" ] + }, + "Tuesday": { + "TariffStep010" : [ "00:00", "800000", "TariffStep011" ], + "TariffStep011" : [ "07:00", "350000", "TariffStep012" ], + "TariffStep012" : [ "08:00", "350000", "TariffStep013" ], + "TariffStep013" : [ "09:00", "350000", "TariffStep014" ], + "TariffStep014" : [ "10:00", "350000", "TariffStep015" ], + "TariffStep015" : [ "11:00", "350000", "TariffStep016" ], + "TariffStep016" : [ "12:00", "350000", "TariffStep017" ], + "TariffStep017" : [ "13:00", "350000", "TariffStep018" ], + "TariffStep018" : [ "14:00", "350000", "TariffStep019" ], + "TariffStep019" : [ "15:00", "350000", "TariffStep0110"], + "TariffStep0110": [ "16:00", "350000", "TariffStep0111"], + "TariffStep0111": [ "17:00", "350000", "TariffStep0112"], + "TariffStep0112": [ "18:00", "350000", "TariffStep0113"], + "TariffStep0113": [ "19:00", "350000", "TariffStep0114"], + "TariffStep0114": [ "20:00", "800000", "TariffStep021" ] + }, + "Wednesday": { + "TariffStep020" : [ "00:00", "800000", "TariffStep021" ], + "TariffStep021" : [ "07:00", "350000", "TariffStep022" ], + "TariffStep022" : [ "08:00", "350000", "TariffStep023" ], + "TariffStep023" : [ "09:00", "350000", "TariffStep024" ], + "TariffStep024" : [ "10:00", "350000", "TariffStep025" ], + "TariffStep025" : [ "11:00", "350000", "TariffStep026" ], + "TariffStep026" : [ "12:00", "350000", "TariffStep027" ], + "TariffStep027" : [ "13:00", "350000", "TariffStep028" ], + "TariffStep028" : [ "14:00", "350000", "TariffStep029" ], + "TariffStep029" : [ "15:00", "350000", "TariffStep0210"], + "TariffStep0210": [ "16:00", "350000", "TariffStep0211"], + "TariffStep0211": [ "17:00", "350000", "TariffStep0212"], + "TariffStep0212": [ "18:00", "350000", "TariffStep0213"], + "TariffStep0213": [ "19:00", "350000", "TariffStep0214"], + "TariffStep0214": [ "20:00", "800000", "TariffStep031" ] + }, + "Thursday": { + "TariffStep030" : [ "00:00", "800000", "TariffStep031" ], + "TariffStep031" : [ "07:00", "350000", "TariffStep032" ], + "TariffStep032" : [ "08:00", "350000", "TariffStep033" ], + "TariffStep033" : [ "09:00", "350000", "TariffStep034" ], + "TariffStep034" : [ "10:00", "350000", "TariffStep035" ], + "TariffStep035" : [ "11:00", "350000", "TariffStep036" ], + "TariffStep036" : [ "12:00", "350000", "TariffStep037" ], + "TariffStep037" : [ "13:00", "350000", "TariffStep038" ], + "TariffStep038" : [ "14:00", "350000", "TariffStep039" ], + "TariffStep039" : [ "15:00", "350000", "TariffStep0310"], + "TariffStep0310": [ "16:00", "350000", "TariffStep0311"], + "TariffStep0311": [ "17:00", "350000", "TariffStep0312"], + "TariffStep0312": [ "18:00", "350000", "TariffStep0313"], + "TariffStep0313": [ "19:00", "350000", "TariffStep0314"], + "TariffStep0314": [ "20:00", "800000", "TariffStep041" ] + }, + "Friday": { + "TariffStep040" : [ "00:00", "800000", "TariffStep041" ], + "TariffStep041" : [ "07:00", "350000", "TariffStep042" ], + "TariffStep042" : [ "08:00", "350000", "TariffStep043" ], + "TariffStep043" : [ "09:00", "350000", "TariffStep044" ], + "TariffStep044" : [ "10:00", "350000", "TariffStep045" ], + "TariffStep045" : [ "11:00", "350000", "TariffStep046" ], + "TariffStep046" : [ "12:00", "350000", "TariffStep047" ], + "TariffStep047" : [ "13:00", "350000", "TariffStep048" ], + "TariffStep048" : [ "14:00", "350000", "TariffStep049" ], + "TariffStep049" : [ "15:00", "350000", "TariffStep0410"], + "TariffStep0410": [ "16:00", "350000", "TariffStep0411"], + "TariffStep0411": [ "17:00", "350000", "TariffStep0412"], + "TariffStep0412": [ "18:00", "350000", "TariffStep0413"], + "TariffStep0413": [ "19:00", "350000", "TariffStep0414"], + "TariffStep0414": [ "20:00", "800000", "TariffStep051" ] + }, + "Saturday": { + "TariffStep050" : [ "00:00", "800000", "TariffStep051" ], + "TariffStep051" : [ "07:00", "350000", "TariffStep052" ], + "TariffStep052" : [ "08:00", "350000", "TariffStep053" ], + "TariffStep053" : [ "09:00", "350000", "TariffStep054" ], + "TariffStep054" : [ "10:00", "350000", "TariffStep055" ], + "TariffStep055" : [ "11:00", "350000", "TariffStep056" ], + "TariffStep056" : [ "12:00", "350000", "TariffStep057" ], + "TariffStep057" : [ "13:00", "350000", "TariffStep058" ], + "TariffStep058" : [ "14:00", "350000", "TariffStep059" ], + "TariffStep059" : [ "15:00", "350000", "TariffStep0510"], + "TariffStep0510": [ "16:00", "350000", "TariffStep0511"], + "TariffStep0511": [ "17:00", "350000", "TariffStep0512"], + "TariffStep0512": [ "18:00", "350000", "TariffStep0513"], + "TariffStep0513": [ "19:00", "350000", "TariffStep0514"], + "TariffStep0514": [ "20:00", "800000", "TariffStep061" ] + }, + "Sunday": { + "TariffStep060" : [ "00:00", "800000", "TariffStep061" ], + "TariffStep061" : [ "07:00", "350000", "TariffStep062" ], + "TariffStep062" : [ "08:00", "350000", "TariffStep063" ], + "TariffStep063" : [ "09:00", "350000", "TariffStep064" ], + "TariffStep064" : [ "10:00", "350000", "TariffStep065" ], + "TariffStep065" : [ "11:00", "350000", "TariffStep066" ], + "TariffStep066" : [ "12:00", "350000", "TariffStep067" ], + "TariffStep067" : [ "13:00", "350000", "TariffStep068" ], + "TariffStep068" : [ "14:00", "350000", "TariffStep069" ], + "TariffStep069" : [ "15:00", "350000", "TariffStep0610"], + "TariffStep0610": [ "16:00", "350000", "TariffStep0611"], + "TariffStep0611": [ "17:00", "350000", "TariffStep0612"], + "TariffStep0612": [ "18:00", "350000", "TariffStep0613"], + "TariffStep0613": [ "19:00", "350000", "TariffStep0614"], + "TariffStep0614": [ "20:00", "800000", "TariffStep101" ] + } + }, + "week2" : { + "Monday": { + "TariffStep100" : [ "00:00", "800000", "TariffStep101" ], + "TariffStep101" : [ "07:00", "350000", "TariffStep102" ], + "TariffStep102" : [ "08:00", "350000", "TariffStep103" ], + "TariffStep103" : [ "09:00", "350000", "TariffStep104" ], + "TariffStep104" : [ "10:00", "350000", "TariffStep105" ], + "TariffStep105" : [ "11:00", "350000", "TariffStep106" ], + "TariffStep106" : [ "12:00", "350000", "TariffStep107" ], + "TariffStep107" : [ "13:00", "350000", "TariffStep108" ], + "TariffStep108" : [ "14:00", "350000", "TariffStep109" ], + "TariffStep109" : [ "15:00", "350000", "TariffStep1010"], + "TariffStep1010": [ "16:00", "350000", "TariffStep1011"], + "TariffStep1011": [ "17:00", "350000", "TariffStep1012"], + "TariffStep1012": [ "18:00", "350000", "TariffStep1013"], + "TariffStep1013": [ "19:00", "350000", "TariffStep1014"], + "TariffStep1014": [ "20:00", "800000", "TariffStep111" ] + }, + "Tuesday": { + "TariffStep110" : [ "00:00", "800000", "TariffStep111" ], + "TariffStep111" : [ "07:00", "350000", "TariffStep112" ], + "TariffStep112" : [ "08:00", "350000", "TariffStep113" ], + "TariffStep113" : [ "09:00", "350000", "TariffStep114" ], + "TariffStep114" : [ "10:00", "350000", "TariffStep115" ], + "TariffStep115" : [ "11:00", "350000", "TariffStep116" ], + "TariffStep116" : [ "12:00", "350000", "TariffStep117" ], + "TariffStep117" : [ "13:00", "350000", "TariffStep118" ], + "TariffStep118" : [ "14:00", "350000", "TariffStep119" ], + "TariffStep119" : [ "15:00", "350000", "TariffStep1110"], + "TariffStep1110": [ "16:00", "350000", "TariffStep1111"], + "TariffStep1111": [ "17:00", "350000", "TariffStep1112"], + "TariffStep1112": [ "18:00", "350000", "TariffStep1113"], + "TariffStep1113": [ "19:00", "350000", "TariffStep1114"], + "TariffStep1114": [ "20:00", "800000", "TariffStep121" ] + }, + "Wednesday": { + "TariffStep120" : [ "00:00", "800000", "TariffStep121" ], + "TariffStep121" : [ "07:00", "350000", "TariffStep122" ], + "TariffStep122" : [ "08:00", "350000", "TariffStep123" ], + "TariffStep123" : [ "09:00", "350000", "TariffStep124" ], + "TariffStep124" : [ "10:00", "350000", "TariffStep125" ], + "TariffStep125" : [ "11:00", "350000", "TariffStep126" ], + "TariffStep126" : [ "12:00", "350000", "TariffStep127" ], + "TariffStep127" : [ "13:00", "350000", "TariffStep128" ], + "TariffStep128" : [ "14:00", "350000", "TariffStep129" ], + "TariffStep129" : [ "15:00", "350000", "TariffStep1210"], + "TariffStep1210": [ "16:00", "350000", "TariffStep1211"], + "TariffStep1211": [ "17:00", "350000", "TariffStep1212"], + "TariffStep1212": [ "18:00", "350000", "TariffStep1213"], + "TariffStep1213": [ "19:00", "350000", "TariffStep1214"], + "TariffStep1214": [ "20:00", "800000", "TariffStep131" ] + }, + "Thursday": { + "TariffStep130" : [ "00:00", "800000", "TariffStep131" ], + "TariffStep131" : [ "07:00", "350000", "TariffStep132" ], + "TariffStep132" : [ "08:00", "350000", "TariffStep133" ], + "TariffStep133" : [ "09:00", "350000", "TariffStep134" ], + "TariffStep134" : [ "10:00", "350000", "TariffStep135" ], + "TariffStep135" : [ "11:00", "350000", "TariffStep136" ], + "TariffStep136" : [ "12:00", "350000", "TariffStep137" ], + "TariffStep137" : [ "13:00", "350000", "TariffStep138" ], + "TariffStep138" : [ "14:00", "350000", "TariffStep139" ], + "TariffStep139" : [ "15:00", "350000", "TariffStep1310"], + "TariffStep1310": [ "16:00", "350000", "TariffStep1311"], + "TariffStep1311": [ "17:00", "350000", "TariffStep1312"], + "TariffStep1312": [ "18:00", "350000", "TariffStep1313"], + "TariffStep1313": [ "19:00", "350000", "TariffStep1314"], + "TariffStep1314": [ "20:00", "800000", "TariffStep141" ] + }, + "Friday": { + "TariffStep140" : [ "00:00", "800000", "TariffStep141" ], + "TariffStep141" : [ "07:00", "350000", "TariffStep142" ], + "TariffStep142" : [ "08:00", "350000", "TariffStep143" ], + "TariffStep143" : [ "09:00", "350000", "TariffStep144" ], + "TariffStep144" : [ "10:00", "350000", "TariffStep145" ], + "TariffStep145" : [ "11:00", "350000", "TariffStep146" ], + "TariffStep146" : [ "12:00", "350000", "TariffStep147" ], + "TariffStep147" : [ "13:00", "350000", "TariffStep148" ], + "TariffStep148" : [ "14:00", "350000", "TariffStep149" ], + "TariffStep149" : [ "15:00", "350000", "TariffStep1410"], + "TariffStep1410": [ "16:00", "350000", "TariffStep1411"], + "TariffStep1411": [ "17:00", "350000", "TariffStep1412"], + "TariffStep1412": [ "18:00", "350000", "TariffStep1413"], + "TariffStep1413": [ "19:00", "350000", "TariffStep1414"], + "TariffStep1414": [ "20:00", "800000", "TariffStep151" ] + }, + "Saturday": { + "TariffStep150" : [ "00:00", "800000", "TariffStep151" ], + "TariffStep151" : [ "07:00", "350000", "TariffStep152" ], + "TariffStep152" : [ "08:00", "350000", "TariffStep153" ], + "TariffStep153" : [ "09:00", "350000", "TariffStep154" ], + "TariffStep154" : [ "10:00", "350000", "TariffStep155" ], + "TariffStep155" : [ "11:00", "350000", "TariffStep156" ], + "TariffStep156" : [ "12:00", "350000", "TariffStep157" ], + "TariffStep157" : [ "13:00", "350000", "TariffStep158" ], + "TariffStep158" : [ "14:00", "350000", "TariffStep159" ], + "TariffStep159" : [ "15:00", "350000", "TariffStep1510"], + "TariffStep1510": [ "16:00", "350000", "TariffStep1511"], + "TariffStep1511": [ "17:00", "350000", "TariffStep1512"], + "TariffStep1512": [ "18:00", "350000", "TariffStep1513"], + "TariffStep1513": [ "19:00", "350000", "TariffStep1514"], + "TariffStep1514": [ "20:00", "800000", "TariffStep161" ] + }, + "Sunday": { + "TariffStep160" : [ "00:00", "800000", "TariffStep161" ], + "TariffStep161" : [ "07:00", "350000", "TariffStep162" ], + "TariffStep162" : [ "08:00", "350000", "TariffStep163" ], + "TariffStep163" : [ "09:00", "350000", "TariffStep164" ], + "TariffStep164" : [ "10:00", "350000", "TariffStep165" ], + "TariffStep165" : [ "11:00", "350000", "TariffStep166" ], + "TariffStep166" : [ "12:00", "350000", "TariffStep167" ], + "TariffStep167" : [ "13:00", "350000", "TariffStep168" ], + "TariffStep168" : [ "14:00", "350000", "TariffStep169" ], + "TariffStep169" : [ "15:00", "350000", "TariffStep1610"], + "TariffStep1610": [ "16:00", "350000", "TariffStep1611"], + "TariffStep1611": [ "17:00", "350000", "TariffStep1612"], + "TariffStep1612": [ "18:00", "350000", "TariffStep1613"], + "TariffStep1613": [ "19:00", "350000", "TariffStep1614"], + "TariffStep1614": [ "20:00", "800000", "TariffStep201" ] + } + }, + "week3" : { + "Monday": { + "TariffStep200" : [ "00:00", "800000", "TariffStep201" ], + "TariffStep201" : [ "07:00", "350000", "TariffStep202" ], + "TariffStep202" : [ "08:00", "350000", "TariffStep203" ], + "TariffStep203" : [ "09:00", "350000", "TariffStep204" ], + "TariffStep204" : [ "10:00", "350000", "TariffStep205" ], + "TariffStep205" : [ "11:00", "350000", "TariffStep206" ], + "TariffStep206" : [ "12:00", "350000", "TariffStep207" ], + "TariffStep207" : [ "13:00", "350000", "TariffStep208" ], + "TariffStep208" : [ "14:00", "350000", "TariffStep209" ], + "TariffStep209" : [ "15:00", "350000", "TariffStep2010"], + "TariffStep2010": [ "16:00", "350000", "TariffStep2011"], + "TariffStep2011": [ "17:00", "350000", "TariffStep2012"], + "TariffStep2012": [ "18:00", "350000", "TariffStep2013"], + "TariffStep2013": [ "19:00", "350000", "TariffStep2014"], + "TariffStep2014": [ "20:00", "800000", "TariffStep211" ] + }, + "Tuesday": { + "TariffStep210" : [ "00:00", "800000", "TariffStep211" ], + "TariffStep211" : [ "07:00", "350000", "TariffStep212" ], + "TariffStep212" : [ "08:00", "350000", "TariffStep213" ], + "TariffStep213" : [ "09:00", "350000", "TariffStep214" ], + "TariffStep214" : [ "10:00", "350000", "TariffStep215" ], + "TariffStep215" : [ "11:00", "350000", "TariffStep216" ], + "TariffStep216" : [ "12:00", "350000", "TariffStep217" ], + "TariffStep217" : [ "13:00", "350000", "TariffStep218" ], + "TariffStep218" : [ "14:00", "350000", "TariffStep219" ], + "TariffStep219" : [ "15:00", "350000", "TariffStep2110"], + "TariffStep2110": [ "16:00", "350000", "TariffStep2111"], + "TariffStep2111": [ "17:00", "350000", "TariffStep2112"], + "TariffStep2112": [ "18:00", "350000", "TariffStep2113"], + "TariffStep2113": [ "19:00", "350000", "TariffStep2114"], + "TariffStep2114": [ "20:00", "800000", "TariffStep221" ] + }, + "Wednesday": { + "TariffStep220" : [ "00:00", "800000", "TariffStep221" ], + "TariffStep221" : [ "07:00", "350000", "TariffStep222" ], + "TariffStep222" : [ "08:00", "350000", "TariffStep223" ], + "TariffStep223" : [ "09:00", "350000", "TariffStep224" ], + "TariffStep224" : [ "10:00", "350000", "TariffStep225" ], + "TariffStep225" : [ "11:00", "350000", "TariffStep226" ], + "TariffStep226" : [ "12:00", "350000", "TariffStep227" ], + "TariffStep227" : [ "13:00", "350000", "TariffStep228" ], + "TariffStep228" : [ "14:00", "350000", "TariffStep229" ], + "TariffStep229" : [ "15:00", "350000", "TariffStep2210"], + "TariffStep2210": [ "16:00", "350000", "TariffStep2211"], + "TariffStep2211": [ "17:00", "350000", "TariffStep2212"], + "TariffStep2212": [ "18:00", "350000", "TariffStep2213"], + "TariffStep2213": [ "19:00", "350000", "TariffStep2214"], + "TariffStep2214": [ "20:00", "800000", "TariffStep231" ] + }, + "Thursday": { + "TariffStep230" : [ "00:00", "800000", "TariffStep231" ], + "TariffStep231" : [ "07:00", "350000", "TariffStep232" ], + "TariffStep232" : [ "08:00", "350000", "TariffStep233" ], + "TariffStep233" : [ "09:00", "350000", "TariffStep234" ], + "TariffStep234" : [ "10:00", "350000", "TariffStep235" ], + "TariffStep235" : [ "11:00", "350000", "TariffStep236" ], + "TariffStep236" : [ "12:00", "350000", "TariffStep237" ], + "TariffStep237" : [ "13:00", "350000", "TariffStep238" ], + "TariffStep238" : [ "14:00", "350000", "TariffStep239" ], + "TariffStep239" : [ "15:00", "350000", "TariffStep2310"], + "TariffStep2310": [ "16:00", "350000", "TariffStep2311"], + "TariffStep2311": [ "17:00", "350000", "TariffStep2312"], + "TariffStep2312": [ "18:00", "350000", "TariffStep2313"], + "TariffStep2313": [ "19:00", "350000", "TariffStep2314"], + "TariffStep2314": [ "20:00", "800000", "TariffStep241" ] + }, + "Friday": { + "TariffStep240" : [ "00:00", "800000", "TariffStep241" ], + "TariffStep241" : [ "07:00", "350000", "TariffStep242" ], + "TariffStep242" : [ "08:00", "350000", "TariffStep243" ], + "TariffStep243" : [ "09:00", "350000", "TariffStep244" ], + "TariffStep244" : [ "10:00", "350000", "TariffStep245" ], + "TariffStep245" : [ "11:00", "350000", "TariffStep246" ], + "TariffStep246" : [ "12:00", "350000", "TariffStep247" ], + "TariffStep247" : [ "13:00", "350000", "TariffStep248" ], + "TariffStep248" : [ "14:00", "350000", "TariffStep249" ], + "TariffStep249" : [ "15:00", "350000", "TariffStep2410"], + "TariffStep2410": [ "16:00", "350000", "TariffStep2411"], + "TariffStep2411": [ "17:00", "350000", "TariffStep2412"], + "TariffStep2412": [ "18:00", "350000", "TariffStep2413"], + "TariffStep2413": [ "19:00", "350000", "TariffStep2414"], + "TariffStep2414": [ "20:00", "800000", "TariffStep251" ] + }, + "Saturday": { + "TariffStep250" : [ "00:00", "800000", "TariffStep251" ], + "TariffStep251" : [ "07:00", "350000", "TariffStep252" ], + "TariffStep252" : [ "08:00", "350000", "TariffStep253" ], + "TariffStep253" : [ "09:00", "350000", "TariffStep254" ], + "TariffStep254" : [ "10:00", "350000", "TariffStep255" ], + "TariffStep255" : [ "11:00", "350000", "TariffStep256" ], + "TariffStep256" : [ "12:00", "350000", "TariffStep257" ], + "TariffStep257" : [ "13:00", "350000", "TariffStep258" ], + "TariffStep258" : [ "14:00", "350000", "TariffStep259" ], + "TariffStep259" : [ "15:00", "350000", "TariffStep2510"], + "TariffStep2510": [ "16:00", "350000", "TariffStep2511"], + "TariffStep2511": [ "17:00", "350000", "TariffStep2512"], + "TariffStep2512": [ "18:00", "350000", "TariffStep2513"], + "TariffStep2513": [ "19:00", "350000", "TariffStep2514"], + "TariffStep2514": [ "20:00", "800000", "TariffStep261" ] + }, + "Sunday": { + "TariffStep260" : [ "00:00", "800000", "TariffStep261" ], + "TariffStep261" : [ "07:00", "350000", "TariffStep262" ], + "TariffStep262" : [ "08:00", "350000", "TariffStep263" ], + "TariffStep263" : [ "09:00", "350000", "TariffStep264" ], + "TariffStep264" : [ "10:00", "350000", "TariffStep265" ], + "TariffStep265" : [ "11:00", "350000", "TariffStep266" ], + "TariffStep266" : [ "12:00", "350000", "TariffStep267" ], + "TariffStep267" : [ "13:00", "350000", "TariffStep268" ], + "TariffStep268" : [ "14:00", "350000", "TariffStep269" ], + "TariffStep269" : [ "15:00", "350000", "TariffStep2610"], + "TariffStep2610": [ "16:00", "350000", "TariffStep2611"], + "TariffStep2611": [ "17:00", "350000", "TariffStep2612"], + "TariffStep2612": [ "18:00", "350000", "TariffStep2613"], + "TariffStep2613": [ "19:00", "350000", "TariffStep2614"], + "TariffStep2614": [ "20:00", "800000", "TariffStep001" ] + } + } +} diff --git a/calculate_parking_tickets/germersheim.conf.bck1 b/calculate_parking_tickets/germersheim.conf.bck1 new file mode 100644 index 0000000..1fb814f --- /dev/null +++ b/calculate_parking_tickets/germersheim.conf.bck1 @@ -0,0 +1,368 @@ +{ + "name":"test", + "properties": [ + ], + "week1" : { + "Monday": [ + { "TariffStep000" : [ "00:00", "800000", "TariffStep001" ]}, + { "TariffStep001" : [ "07:00", "350000", "TariffStep002" ]}, + { "TariffStep002" : [ "08:00", "350000", "TariffStep003" ]}, + { "TariffStep003" : [ "09:00", "350000", "TariffStep004" ]}, + { "TariffStep004" : [ "10:00", "350000", "TariffStep005" ]}, + { "TariffStep005" : [ "11:00", "350000", "TariffStep006" ]}, + { "TariffStep006" : [ "12:00", "350000", "TariffStep007" ]}, + { "TariffStep007" : [ "13:00", "350000", "TariffStep008" ]}, + { "TariffStep008" : [ "14:00", "350000", "TariffStep009" ]}, + { "TariffStep009" : [ "15:00", "350000", "TariffStep0010"]}, + { "TariffStep0010": [ "16:00", "350000", "TariffStep0011"]}, + { "TariffStep0011": [ "17:00", "350000", "TariffStep0012"]}, + { "TariffStep0012": [ "18:00", "350000", "TariffStep0013"]}, + { "TariffStep0013": [ "19:00", "350000", "TariffStep0014"]}, + { "TariffStep0014": [ "20:00", "800000", "TariffStep011" ]} + ], + "Tuesday": [ + { "TariffStep010" : [ "00:00", "800000", "TariffStep011" ]}, + { "TariffStep011" : [ "07:00", "350000", "TariffStep012" ]}, + { "TariffStep012" : [ "08:00", "350000", "TariffStep013" ]}, + { "TariffStep013" : [ "09:00", "350000", "TariffStep014" ]}, + { "TariffStep014" : [ "10:00", "350000", "TariffStep015" ]}, + { "TariffStep015" : [ "11:00", "350000", "TariffStep016" ]}, + { "TariffStep016" : [ "12:00", "350000", "TariffStep017" ]}, + { "TariffStep017" : [ "13:00", "350000", "TariffStep018" ]}, + { "TariffStep018" : [ "14:00", "350000", "TariffStep019" ]}, + { "TariffStep019" : [ "15:00", "350000", "TariffStep0110"]}, + { "TariffStep0110": [ "16:00", "350000", "TariffStep0111"]}, + { "TariffStep0111": [ "17:00", "350000", "TariffStep0112"]}, + { "TariffStep0112": [ "18:00", "350000", "TariffStep0113"]}, + { "TariffStep0113": [ "19:00", "350000", "TariffStep0114"]}, + { "TariffStep0114": [ "20:00", "800000", "TariffStep021" ]} + ], + "Wednesday": [ + { "TariffStep020" : [ "00:00", "800000", "TariffStep021" ]}, + { "TariffStep021" : [ "07:00", "350000", "TariffStep022" ]}, + { "TariffStep022" : [ "08:00", "350000", "TariffStep023" ]}, + { "TariffStep023" : [ "09:00", "350000", "TariffStep024" ]}, + { "TariffStep024" : [ "10:00", "350000", "TariffStep025" ]}, + { "TariffStep025" : [ "11:00", "350000", "TariffStep026" ]}, + { "TariffStep026" : [ "12:00", "350000", "TariffStep027" ]}, + { "TariffStep027" : [ "13:00", "350000", "TariffStep028" ]}, + { "TariffStep028" : [ "14:00", "350000", "TariffStep029" ]}, + { "TariffStep029" : [ "15:00", "350000", "TariffStep0210"]}, + { "TariffStep0210": [ "16:00", "350000", "TariffStep0211"]}, + { "TariffStep0211": [ "17:00", "350000", "TariffStep0212"]}, + { "TariffStep0212": [ "18:00", "350000", "TariffStep0213"]}, + { "TariffStep0213": [ "19:00", "350000", "TariffStep0214"]}, + { "TariffStep0214": [ "20:00", "800000", "TariffStep031" ]} + ], + "Thursday": [ + { "TariffStep030" : [ "00:00", "800000", "TariffStep031" ]}, + { "TariffStep031" : [ "07:00", "350000", "TariffStep032" ]}, + { "TariffStep032" : [ "08:00", "350000", "TariffStep033" ]}, + { "TariffStep033" : [ "09:00", "350000", "TariffStep034" ]}, + { "TariffStep034" : [ "10:00", "350000", "TariffStep035" ]}, + { "TariffStep035" : [ "11:00", "350000", "TariffStep036" ]}, + { "TariffStep036" : [ "12:00", "350000", "TariffStep037" ]}, + { "TariffStep037" : [ "13:00", "350000", "TariffStep038" ]}, + { "TariffStep038" : [ "14:00", "350000", "TariffStep039" ]}, + { "TariffStep039" : [ "15:00", "350000", "TariffStep0310"]}, + { "TariffStep0310": [ "16:00", "350000", "TariffStep0311"]}, + { "TariffStep0311": [ "17:00", "350000", "TariffStep0312"]}, + { "TariffStep0312": [ "18:00", "350000", "TariffStep0313"]}, + { "TariffStep0313": [ "19:00", "350000", "TariffStep0314"]}, + { "TariffStep0314": [ "20:00", "800000", "TariffStep041" ]} + ], + "Friday": [ + { "TariffStep040" : [ "00:00", "800000", "TariffStep041" ]}, + { "TariffStep041" : [ "07:00", "350000", "TariffStep042" ]}, + { "TariffStep042" : [ "08:00", "350000", "TariffStep043" ]}, + { "TariffStep043" : [ "09:00", "350000", "TariffStep044" ]}, + { "TariffStep044" : [ "10:00", "350000", "TariffStep045" ]}, + { "TariffStep045" : [ "11:00", "350000", "TariffStep046" ]}, + { "TariffStep046" : [ "12:00", "350000", "TariffStep047" ]}, + { "TariffStep047" : [ "13:00", "350000", "TariffStep048" ]}, + { "TariffStep048" : [ "14:00", "350000", "TariffStep049" ]}, + { "TariffStep049" : [ "15:00", "350000", "TariffStep0410"]}, + { "TariffStep0410": [ "16:00", "350000", "TariffStep0411"]}, + { "TariffStep0411": [ "17:00", "350000", "TariffStep0412"]}, + { "TariffStep0412": [ "18:00", "350000", "TariffStep0413"]}, + { "TariffStep0413": [ "19:00", "350000", "TariffStep0414"]}, + { "TariffStep0414": [ "20:00", "800000", "TariffStep051" ]} + ], + "Saturday": [ + { "TariffStep050" : [ "00:00", "800000", "TariffStep051" ]}, + { "TariffStep051" : [ "07:00", "350000", "TariffStep052" ]}, + { "TariffStep052" : [ "08:00", "350000", "TariffStep053" ]}, + { "TariffStep053" : [ "09:00", "350000", "TariffStep054" ]}, + { "TariffStep054" : [ "10:00", "350000", "TariffStep055" ]}, + { "TariffStep055" : [ "11:00", "350000", "TariffStep056" ]}, + { "TariffStep056" : [ "12:00", "350000", "TariffStep057" ]}, + { "TariffStep057" : [ "13:00", "350000", "TariffStep058" ]}, + { "TariffStep058" : [ "14:00", "350000", "TariffStep059" ]}, + { "TariffStep059" : [ "15:00", "350000", "TariffStep0510"]}, + { "TariffStep0510": [ "16:00", "350000", "TariffStep0511"]}, + { "TariffStep0511": [ "17:00", "350000", "TariffStep0512"]}, + { "TariffStep0512": [ "18:00", "350000", "TariffStep0513"]}, + { "TariffStep0513": [ "19:00", "350000", "TariffStep0514"]}, + { "TariffStep0514": [ "20:00", "800000", "TariffStep061" ]} + ], + "Sunday": [ + { "TariffStep060" : [ "00:00", "800000", "TariffStep061" ]}, + { "TariffStep061" : [ "07:00", "350000", "TariffStep062" ]}, + { "TariffStep062" : [ "08:00", "350000", "TariffStep063" ]}, + { "TariffStep063" : [ "09:00", "350000", "TariffStep064" ]}, + { "TariffStep064" : [ "10:00", "350000", "TariffStep065" ]}, + { "TariffStep065" : [ "11:00", "350000", "TariffStep066" ]}, + { "TariffStep066" : [ "12:00", "350000", "TariffStep067" ]}, + { "TariffStep067" : [ "13:00", "350000", "TariffStep068" ]}, + { "TariffStep068" : [ "14:00", "350000", "TariffStep069" ]}, + { "TariffStep069" : [ "15:00", "350000", "TariffStep0610"]}, + { "TariffStep0610": [ "16:00", "350000", "TariffStep0611"]}, + { "TariffStep0611": [ "17:00", "350000", "TariffStep0612"]}, + { "TariffStep0612": [ "18:00", "350000", "TariffStep0613"]}, + { "TariffStep0613": [ "19:00", "350000", "TariffStep0614"]}, + { "TariffStep0614": [ "20:00", "800000", "TariffStep101" ]} + ] + }, + "week2" : { + "Monday": [ + { "TariffStep100" : [ "00:00", "800000", "TariffStep101" ]}, + { "TariffStep101" : [ "07:00", "350000", "TariffStep102" ]}, + { "TariffStep102" : [ "08:00", "350000", "TariffStep103" ]}, + { "TariffStep103" : [ "09:00", "350000", "TariffStep104" ]}, + { "TariffStep104" : [ "10:00", "350000", "TariffStep105" ]}, + { "TariffStep105" : [ "11:00", "350000", "TariffStep106" ]}, + { "TariffStep106" : [ "12:00", "350000", "TariffStep107" ]}, + { "TariffStep107" : [ "13:00", "350000", "TariffStep108" ]}, + { "TariffStep108" : [ "14:00", "350000", "TariffStep109" ]}, + { "TariffStep109" : [ "15:00", "350000", "TariffStep1010"]}, + { "TariffStep1010": [ "16:00", "350000", "TariffStep1011"]}, + { "TariffStep1011": [ "17:00", "350000", "TariffStep1012"]}, + { "TariffStep1012": [ "18:00", "350000", "TariffStep1013"]}, + { "TariffStep1013": [ "19:00", "350000", "TariffStep1014"]}, + { "TariffStep1014": [ "20:00", "800000", "TariffStep111" ]} + ], + "Tuesday": [ + { "TariffStep110" : [ "00:00", "800000", "TariffStep111" ]}, + { "TariffStep111" : [ "07:00", "350000", "TariffStep112" ]}, + { "TariffStep112" : [ "08:00", "350000", "TariffStep113" ]}, + { "TariffStep113" : [ "09:00", "350000", "TariffStep114" ]}, + { "TariffStep114" : [ "10:00", "350000", "TariffStep115" ]}, + { "TariffStep115" : [ "11:00", "350000", "TariffStep116" ]}, + { "TariffStep116" : [ "12:00", "350000", "TariffStep117" ]}, + { "TariffStep117" : [ "13:00", "350000", "TariffStep118" ]}, + { "TariffStep118" : [ "14:00", "350000", "TariffStep119" ]}, + { "TariffStep119" : [ "15:00", "350000", "TariffStep1110"]}, + { "TariffStep1110": [ "16:00", "350000", "TariffStep1111"]}, + { "TariffStep1111": [ "17:00", "350000", "TariffStep1112"]}, + { "TariffStep1112": [ "18:00", "350000", "TariffStep1113"]}, + { "TariffStep1113": [ "19:00", "350000", "TariffStep1114"]}, + { "TariffStep1114": [ "20:00", "800000", "TariffStep121" ]} + ], + "Wednesday": [ + { "TariffStep120" : [ "00:00", "800000", "TariffStep121" ]}, + { "TariffStep121" : [ "07:00", "350000", "TariffStep122" ]}, + { "TariffStep122" : [ "08:00", "350000", "TariffStep123" ]}, + { "TariffStep123" : [ "09:00", "350000", "TariffStep124" ]}, + { "TariffStep124" : [ "10:00", "350000", "TariffStep125" ]}, + { "TariffStep125" : [ "11:00", "350000", "TariffStep126" ]}, + { "TariffStep126" : [ "12:00", "350000", "TariffStep127" ]}, + { "TariffStep127" : [ "13:00", "350000", "TariffStep128" ]}, + { "TariffStep128" : [ "14:00", "350000", "TariffStep129" ]}, + { "TariffStep129" : [ "15:00", "350000", "TariffStep1210"]}, + { "TariffStep1210": [ "16:00", "350000", "TariffStep1211"]}, + { "TariffStep1211": [ "17:00", "350000", "TariffStep1212"]}, + { "TariffStep1212": [ "18:00", "350000", "TariffStep1213"]}, + { "TariffStep1213": [ "19:00", "350000", "TariffStep1214"]}, + { "TariffStep1214": [ "20:00", "800000", "TariffStep131" ]} + ], + "Thursday": [ + { "TariffStep130" : [ "00:00", "800000", "TariffStep131" ]}, + { "TariffStep131" : [ "07:00", "350000", "TariffStep132" ]}, + { "TariffStep132" : [ "08:00", "350000", "TariffStep133" ]}, + { "TariffStep133" : [ "09:00", "350000", "TariffStep134" ]}, + { "TariffStep134" : [ "10:00", "350000", "TariffStep135" ]}, + { "TariffStep135" : [ "11:00", "350000", "TariffStep136" ]}, + { "TariffStep136" : [ "12:00", "350000", "TariffStep137" ]}, + { "TariffStep137" : [ "13:00", "350000", "TariffStep138" ]}, + { "TariffStep138" : [ "14:00", "350000", "TariffStep139" ]}, + { "TariffStep139" : [ "15:00", "350000", "TariffStep1310"]}, + { "TariffStep1310": [ "16:00", "350000", "TariffStep1311"]}, + { "TariffStep1311": [ "17:00", "350000", "TariffStep1312"]}, + { "TariffStep1312": [ "18:00", "350000", "TariffStep1313"]}, + { "TariffStep1313": [ "19:00", "350000", "TariffStep1314"]}, + { "TariffStep1314": [ "20:00", "800000", "TariffStep141" ]} + ], + "Friday": [ + { "TariffStep140" : [ "00:00", "800000", "TariffStep141" ]}, + { "TariffStep141" : [ "07:00", "350000", "TariffStep142" ]}, + { "TariffStep142" : [ "08:00", "350000", "TariffStep143" ]}, + { "TariffStep143" : [ "09:00", "350000", "TariffStep144" ]}, + { "TariffStep144" : [ "10:00", "350000", "TariffStep145" ]}, + { "TariffStep145" : [ "11:00", "350000", "TariffStep146" ]}, + { "TariffStep146" : [ "12:00", "350000", "TariffStep147" ]}, + { "TariffStep147" : [ "13:00", "350000", "TariffStep148" ]}, + { "TariffStep148" : [ "14:00", "350000", "TariffStep149" ]}, + { "TariffStep149" : [ "15:00", "350000", "TariffStep1410"]}, + { "TariffStep1410": [ "16:00", "350000", "TariffStep1411"]}, + { "TariffStep1411": [ "17:00", "350000", "TariffStep1412"]}, + { "TariffStep1412": [ "18:00", "350000", "TariffStep1413"]}, + { "TariffStep1413": [ "19:00", "350000", "TariffStep1414"]}, + { "TariffStep1414": [ "20:00", "800000", "TariffStep151" ]} + ], + "Saturday": [ + { "TariffStep150" : [ "00:00", "800000", "TariffStep151" ]}, + { "TariffStep151" : [ "07:00", "350000", "TariffStep152" ]}, + { "TariffStep152" : [ "08:00", "350000", "TariffStep153" ]}, + { "TariffStep153" : [ "09:00", "350000", "TariffStep154" ]}, + { "TariffStep154" : [ "10:00", "350000", "TariffStep155" ]}, + { "TariffStep155" : [ "11:00", "350000", "TariffStep156" ]}, + { "TariffStep156" : [ "12:00", "350000", "TariffStep157" ]}, + { "TariffStep157" : [ "13:00", "350000", "TariffStep158" ]}, + { "TariffStep158" : [ "14:00", "350000", "TariffStep159" ]}, + { "TariffStep159" : [ "15:00", "350000", "TariffStep1510"]}, + { "TariffStep1510": [ "16:00", "350000", "TariffStep1511"]}, + { "TariffStep1511": [ "17:00", "350000", "TariffStep1512"]}, + { "TariffStep1512": [ "18:00", "350000", "TariffStep1513"]}, + { "TariffStep1513": [ "19:00", "350000", "TariffStep1514"]}, + { "TariffStep1514": [ "20:00", "800000", "TariffStep161" ]} + ], + "Sunday": [ + { "TariffStep160" : [ "00:00", "800000", "TariffStep161" ]}, + { "TariffStep161" : [ "07:00", "350000", "TariffStep162" ]}, + { "TariffStep162" : [ "08:00", "350000", "TariffStep163" ]}, + { "TariffStep163" : [ "09:00", "350000", "TariffStep164" ]}, + { "TariffStep164" : [ "10:00", "350000", "TariffStep165" ]}, + { "TariffStep165" : [ "11:00", "350000", "TariffStep166" ]}, + { "TariffStep166" : [ "12:00", "350000", "TariffStep167" ]}, + { "TariffStep167" : [ "13:00", "350000", "TariffStep168" ]}, + { "TariffStep168" : [ "14:00", "350000", "TariffStep169" ]}, + { "TariffStep169" : [ "15:00", "350000", "TariffStep1610"]}, + { "TariffStep1610": [ "16:00", "350000", "TariffStep1611"]}, + { "TariffStep1611": [ "17:00", "350000", "TariffStep1612"]}, + { "TariffStep1612": [ "18:00", "350000", "TariffStep1613"]}, + { "TariffStep1613": [ "19:00", "350000", "TariffStep1614"]}, + { "TariffStep1614": [ "20:00", "800000", "TariffStep201" ]} + ] + }, + "week3" : { + "Monday": [ + { "TariffStep200" : [ "00:00", "800000", "TariffStep201" ]}, + { "TariffStep201" : [ "07:00", "350000", "TariffStep202" ]}, + { "TariffStep202" : [ "08:00", "350000", "TariffStep203" ]}, + { "TariffStep203" : [ "09:00", "350000", "TariffStep204" ]}, + { "TariffStep204" : [ "10:00", "350000", "TariffStep205" ]}, + { "TariffStep205" : [ "11:00", "350000", "TariffStep206" ]}, + { "TariffStep206" : [ "12:00", "350000", "TariffStep207" ]}, + { "TariffStep207" : [ "13:00", "350000", "TariffStep208" ]}, + { "TariffStep208" : [ "14:00", "350000", "TariffStep209" ]}, + { "TariffStep209" : [ "15:00", "350000", "TariffStep2010"]}, + { "TariffStep2010": [ "16:00", "350000", "TariffStep2011"]}, + { "TariffStep2011": [ "17:00", "350000", "TariffStep2012"]}, + { "TariffStep2012": [ "18:00", "350000", "TariffStep2013"]}, + { "TariffStep2013": [ "19:00", "350000", "TariffStep2014"]}, + { "TariffStep2014": [ "20:00", "800000", "TariffStep211" ]} + ], + "Tuesday": [ + { "TariffStep210" : [ "00:00", "800000", "TariffStep211" ]}, + { "TariffStep211" : [ "07:00", "350000", "TariffStep212" ]}, + { "TariffStep212" : [ "08:00", "350000", "TariffStep213" ]}, + { "TariffStep213" : [ "09:00", "350000", "TariffStep214" ]}, + { "TariffStep214" : [ "10:00", "350000", "TariffStep215" ]}, + { "TariffStep215" : [ "11:00", "350000", "TariffStep216" ]}, + { "TariffStep216" : [ "12:00", "350000", "TariffStep217" ]}, + { "TariffStep217" : [ "13:00", "350000", "TariffStep218" ]}, + { "TariffStep218" : [ "14:00", "350000", "TariffStep219" ]}, + { "TariffStep219" : [ "15:00", "350000", "TariffStep2110"]}, + { "TariffStep2110": [ "16:00", "350000", "TariffStep2111"]}, + { "TariffStep2111": [ "17:00", "350000", "TariffStep2112"]}, + { "TariffStep2112": [ "18:00", "350000", "TariffStep2113"]}, + { "TariffStep2113": [ "19:00", "350000", "TariffStep2114"]}, + { "TariffStep2114": [ "20:00", "800000", "TariffStep221" ]} + ], + "Wednesday": [ + { "TariffStep220" : [ "00:00", "800000", "TariffStep221" ]}, + { "TariffStep221" : [ "07:00", "350000", "TariffStep222" ]}, + { "TariffStep222" : [ "08:00", "350000", "TariffStep223" ]}, + { "TariffStep223" : [ "09:00", "350000", "TariffStep224" ]}, + { "TariffStep224" : [ "10:00", "350000", "TariffStep225" ]}, + { "TariffStep225" : [ "11:00", "350000", "TariffStep226" ]}, + { "TariffStep226" : [ "12:00", "350000", "TariffStep227" ]}, + { "TariffStep227" : [ "13:00", "350000", "TariffStep228" ]}, + { "TariffStep228" : [ "14:00", "350000", "TariffStep229" ]}, + { "TariffStep229" : [ "15:00", "350000", "TariffStep2210"]}, + { "TariffStep2210": [ "16:00", "350000", "TariffStep2211"]}, + { "TariffStep2211": [ "17:00", "350000", "TariffStep2212"]}, + { "TariffStep2212": [ "18:00", "350000", "TariffStep2213"]}, + { "TariffStep2213": [ "19:00", "350000", "TariffStep2214"]}, + { "TariffStep2214": [ "20:00", "800000", "TariffStep231" ]} + ], + "Thursday": [ + { "TariffStep230" : [ "00:00", "800000", "TariffStep231" ]}, + { "TariffStep231" : [ "07:00", "350000", "TariffStep232" ]}, + { "TariffStep232" : [ "08:00", "350000", "TariffStep233" ]}, + { "TariffStep233" : [ "09:00", "350000", "TariffStep234" ]}, + { "TariffStep234" : [ "10:00", "350000", "TariffStep235" ]}, + { "TariffStep235" : [ "11:00", "350000", "TariffStep236" ]}, + { "TariffStep236" : [ "12:00", "350000", "TariffStep237" ]}, + { "TariffStep237" : [ "13:00", "350000", "TariffStep238" ]}, + { "TariffStep238" : [ "14:00", "350000", "TariffStep239" ]}, + { "TariffStep239" : [ "15:00", "350000", "TariffStep2310"]}, + { "TariffStep2310": [ "16:00", "350000", "TariffStep2311"]}, + { "TariffStep2311": [ "17:00", "350000", "TariffStep2312"]}, + { "TariffStep2312": [ "18:00", "350000", "TariffStep2313"]}, + { "TariffStep2313": [ "19:00", "350000", "TariffStep2314"]}, + { "TariffStep2314": [ "20:00", "800000", "TariffStep241" ]} + ], + "Friday": [ + { "TariffStep240" : [ "00:00", "800000", "TariffStep241" ]}, + { "TariffStep241" : [ "07:00", "350000", "TariffStep242" ]}, + { "TariffStep242" : [ "08:00", "350000", "TariffStep243" ]}, + { "TariffStep243" : [ "09:00", "350000", "TariffStep244" ]}, + { "TariffStep244" : [ "10:00", "350000", "TariffStep245" ]}, + { "TariffStep245" : [ "11:00", "350000", "TariffStep246" ]}, + { "TariffStep246" : [ "12:00", "350000", "TariffStep247" ]}, + { "TariffStep247" : [ "13:00", "350000", "TariffStep248" ]}, + { "TariffStep248" : [ "14:00", "350000", "TariffStep249" ]}, + { "TariffStep249" : [ "15:00", "350000", "TariffStep2410"]}, + { "TariffStep2410": [ "16:00", "350000", "TariffStep2411"]}, + { "TariffStep2411": [ "17:00", "350000", "TariffStep2412"]}, + { "TariffStep2412": [ "18:00", "350000", "TariffStep2413"]}, + { "TariffStep2413": [ "19:00", "350000", "TariffStep2414"]}, + { "TariffStep2414": [ "20:00", "800000", "TariffStep251" ]} + ], + "Saturday": [ + { "TariffStep250" : [ "00:00", "800000", "TariffStep251" ]}, + { "TariffStep251" : [ "07:00", "350000", "TariffStep252" ]}, + { "TariffStep252" : [ "08:00", "350000", "TariffStep253" ]}, + { "TariffStep253" : [ "09:00", "350000", "TariffStep254" ]}, + { "TariffStep254" : [ "10:00", "350000", "TariffStep255" ]}, + { "TariffStep255" : [ "11:00", "350000", "TariffStep256" ]}, + { "TariffStep256" : [ "12:00", "350000", "TariffStep257" ]}, + { "TariffStep257" : [ "13:00", "350000", "TariffStep258" ]}, + { "TariffStep258" : [ "14:00", "350000", "TariffStep259" ]}, + { "TariffStep259" : [ "15:00", "350000", "TariffStep2510"]}, + { "TariffStep2510": [ "16:00", "350000", "TariffStep2511"]}, + { "TariffStep2511": [ "17:00", "350000", "TariffStep2512"]}, + { "TariffStep2512": [ "18:00", "350000", "TariffStep2513"]}, + { "TariffStep2513": [ "19:00", "350000", "TariffStep2514"]}, + { "TariffStep2514": [ "20:00", "800000", "TariffStep261" ]} + ], + "Sunday": [ + { "TariffStep260" : [ "00:00", "800000", "TariffStep261" ]}, + { "TariffStep261" : [ "07:00", "350000", "TariffStep262" ]}, + { "TariffStep262" : [ "08:00", "350000", "TariffStep263" ]}, + { "TariffStep263" : [ "09:00", "350000", "TariffStep264" ]}, + { "TariffStep264" : [ "10:00", "350000", "TariffStep265" ]}, + { "TariffStep265" : [ "11:00", "350000", "TariffStep266" ]}, + { "TariffStep266" : [ "12:00", "350000", "TariffStep267" ]}, + { "TariffStep267" : [ "13:00", "350000", "TariffStep268" ]}, + { "TariffStep268" : [ "14:00", "350000", "TariffStep269" ]}, + { "TariffStep269" : [ "15:00", "350000", "TariffStep2610"]}, + { "TariffStep2610": [ "16:00", "350000", "TariffStep2611"]}, + { "TariffStep2611": [ "17:00", "350000", "TariffStep2612"]}, + { "TariffStep2612": [ "18:00", "350000", "TariffStep2613"]}, + { "TariffStep2613": [ "19:00", "350000", "TariffStep2614"]}, + { "TariffStep2614": [ "20:00", "800000", "TariffStep001" ]} + ] + } +} diff --git a/main/kate.txt b/main/kate.txt new file mode 100644 index 0000000..afa7602 --- /dev/null +++ b/main/kate.txt @@ -0,0 +1,10100 @@ +08:22:03: Starte /home/linux/build-calculate_parking-Desktop-Debug/main/main ... + 04.01.2023 08:22:03.049 DEBG 24 (main.cpp:75) + 04.01.2023 08:22:03.050 DEBG 0 3 *** + (main.cpp:123) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:00:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:01:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:02:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:03:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:04:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:05:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:06:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:07:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:08:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:09:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:10:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:11:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:12:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.050 DEBG ==> QTime("00:13:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:14:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:15:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:16:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:17:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:18:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:19:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:20:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:21:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:22:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:23:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:24:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:25:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:26:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:27:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:28:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:29:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:30:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:31:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:32:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:33:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:34:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:35:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:36:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.051 DEBG ==> QTime("00:37:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:38:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:39:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:40:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:41:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:42:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:43:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:44:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:45:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:46:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:47:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:48:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:49:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:50:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:51:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:52:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:53:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:54:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:55:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:56:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:57:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:58:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("00:59:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.052 DEBG ==> QTime("01:00:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:01:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:02:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:03:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:04:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:05:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:06:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:07:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:08:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:09:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:10:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:11:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:12:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:13:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:14:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:15:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:16:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:17:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:18:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:19:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:20:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:21:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:22:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:23:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:24:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.053 DEBG ==> QTime("01:25:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:26:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:27:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:28:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:29:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:30:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:31:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:32:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:33:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:34:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:35:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:36:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:37:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:38:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:39:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:40:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:41:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:42:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:43:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:44:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:45:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:46:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:47:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:48:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:49:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.054 DEBG ==> QTime("01:50:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:51:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:52:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:53:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:54:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:55:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:56:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:57:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:58:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("01:59:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:00:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:01:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:02:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:03:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:04:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:05:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:06:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:07:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:08:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:09:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:10:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:11:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:12:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:13:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.055 DEBG ==> QTime("02:14:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:15:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:16:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:17:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:18:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:19:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:20:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:21:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:22:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:23:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:24:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:25:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:26:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:27:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:28:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:29:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:30:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:31:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:32:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:33:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:34:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:35:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:36:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:37:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.056 DEBG ==> QTime("02:38:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:39:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:40:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:41:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:42:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:43:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:44:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:45:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:46:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:47:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:48:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:49:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:50:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:51:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:52:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.057 DEBG ==> QTime("02:53:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("02:54:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("02:55:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("02:56:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("02:57:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("02:58:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("02:59:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:00:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:01:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:02:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:03:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:04:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:05:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:06:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:07:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:08:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:09:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:10:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:11:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:12:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:13:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:14:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:15:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:16:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.058 DEBG ==> QTime("03:17:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:18:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:19:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:20:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:21:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:22:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:23:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:24:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:25:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:26:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:27:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:28:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:29:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:30:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:31:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:32:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:33:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:34:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:35:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:36:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:37:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.059 DEBG ==> QTime("03:38:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:39:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:40:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:41:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:42:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:43:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:44:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:45:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:46:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:47:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:48:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:49:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:50:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:51:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:52:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.060 DEBG ==> QTime("03:53:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("03:54:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("03:55:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("03:56:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("03:57:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("03:58:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("03:59:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:00:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:01:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:02:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:03:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:04:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:05:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:06:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:07:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:08:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:09:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:10:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:11:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:12:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:13:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:14:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.061 DEBG ==> QTime("04:15:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:16:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:17:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:18:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:19:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:20:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:21:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:22:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:23:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:24:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:25:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:26:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:27:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:28:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:29:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:30:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:31:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:32:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.062 DEBG ==> QTime("04:33:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:34:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:35:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:36:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:37:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:38:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:39:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:40:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:41:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:42:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:43:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:44:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:45:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:46:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:47:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:48:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:49:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:50:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:51:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.063 DEBG ==> QTime("04:52:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("04:53:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("04:54:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("04:55:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("04:56:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("04:57:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("04:58:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("04:59:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:00:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:01:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:02:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:03:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:04:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:05:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:06:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:07:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:08:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:09:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:10:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:11:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:12:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:13:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.064 DEBG ==> QTime("05:14:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:15:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:16:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:17:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:18:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:19:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:20:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:21:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:22:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:23:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:24:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:25:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:26:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:27:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:28:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:29:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.065 DEBG ==> QTime("05:30:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:31:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:32:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:33:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:34:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:35:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:36:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:37:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:38:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:39:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:40:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:41:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:42:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:43:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:44:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:45:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:46:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:47:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:48:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:49:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.066 DEBG ==> QTime("05:50:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:51:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:52:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:53:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:54:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:55:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:56:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:57:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:58:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("05:59:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:00:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:01:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:02:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:03:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:04:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:05:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:06:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:07:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:08:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:09:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:10:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:11:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.067 DEBG ==> QTime("06:12:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:13:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:14:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:15:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:16:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:17:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:18:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:19:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:20:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:21:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:22:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:23:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:24:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:25:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:26:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:27:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:28:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:29:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:30:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:31:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:32:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:33:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:34:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.068 DEBG ==> QTime("06:35:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:36:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:37:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:38:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:39:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:40:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:41:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:42:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:43:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:44:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:45:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:46:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:47:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:48:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:49:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:50:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:51:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:52:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:53:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:54:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:55:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:56:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:57:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:58:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.069 DEBG ==> QTime("06:59:00.000") QDateTime(2023-01-04 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:00:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:01:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:02:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:03:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:04:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:05:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:06:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:07:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:08:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:09:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:10:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:11:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:12:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:13:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:14:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:15:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:16:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:17:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:18:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:19:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.070 DEBG ==> QTime("07:20:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:21:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:22:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:23:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:24:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:25:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:26:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:27:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:28:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:29:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:30:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:31:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:32:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:33:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:34:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:35:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:36:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:37:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:38:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.071 DEBG ==> QTime("07:39:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:40:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:41:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:42:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:43:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:44:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:45:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:46:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:47:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:48:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:49:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:50:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:51:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:52:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:53:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:54:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:55:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:56:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:57:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:58:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("07:59:00.000") QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.072 DEBG ==> QTime("08:00:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:01:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:02:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:03:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:04:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:05:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:06:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:07:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:08:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:09:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:10:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:11:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:12:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:13:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:14:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:15:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:16:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:17:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:18:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:19:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:20:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:21:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.073 DEBG ==> QTime("08:22:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:23:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:24:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:25:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:26:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:27:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:28:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:29:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:30:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:31:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:32:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:33:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:34:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:35:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:36:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:37:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:38:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:39:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:40:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:41:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:42:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.074 DEBG ==> QTime("08:43:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:44:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:45:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:46:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:47:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:48:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:49:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:50:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:51:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:52:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:53:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:54:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:55:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:56:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:57:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:58:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("08:59:00.000") QDateTime(2023-01-04 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("09:00:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("09:01:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("09:02:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("09:03:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.075 DEBG ==> QTime("09:04:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:05:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:06:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:07:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:08:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:09:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:10:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:11:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:12:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:13:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:14:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:15:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:16:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:17:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:18:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:19:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.076 DEBG ==> QTime("09:20:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:21:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:22:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:23:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:24:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:25:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:26:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:27:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:28:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:29:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:30:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:31:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:32:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:33:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.077 DEBG ==> QTime("09:34:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:35:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:36:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:37:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:38:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:39:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:40:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:41:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:42:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:43:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:44:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:45:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:46:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:47:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.078 DEBG ==> QTime("09:48:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:49:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:50:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:51:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:52:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:53:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:54:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:55:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:56:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:57:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:58:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("09:59:00.000") QDateTime(2023-01-04 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("10:00:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.079 DEBG ==> QTime("10:01:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:02:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:03:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:04:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:05:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:06:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:07:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:08:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:09:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:10:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:11:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:12:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:13:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:14:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:15:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.080 DEBG ==> QTime("10:16:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:17:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:18:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:19:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:20:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:21:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:22:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:23:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:24:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:25:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:26:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:27:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:28:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:29:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.081 DEBG ==> QTime("10:30:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:31:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:32:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:33:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:34:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:35:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:36:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:37:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:38:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:39:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:40:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:41:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:42:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.082 DEBG ==> QTime("10:43:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:44:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:45:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:46:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:47:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:48:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:49:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:50:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:51:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:52:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:53:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:54:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:55:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:56:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.083 DEBG ==> QTime("10:57:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("10:58:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("10:59:00.000") QDateTime(2023-01-04 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:00:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:01:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:02:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:03:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:04:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:05:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:06:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:07:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:08:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:09:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:10:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:11:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.084 DEBG ==> QTime("11:12:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:13:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:14:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:15:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:16:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:17:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:18:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:19:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:20:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:21:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:22:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:23:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:24:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:25:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.085 DEBG ==> QTime("11:26:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:27:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:28:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:29:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:30:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:31:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:32:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:33:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:34:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:35:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:36:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:37:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:38:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:39:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.086 DEBG ==> QTime("11:40:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:41:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:42:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:43:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:44:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:45:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:46:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:47:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:48:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:49:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:50:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:51:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:52:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:53:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:54:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.087 DEBG ==> QTime("11:55:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("11:56:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("11:57:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("11:58:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("11:59:00.000") QDateTime(2023-01-04 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:00:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:01:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:02:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:03:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:04:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:05:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:06:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:07:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:08:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.088 DEBG ==> QTime("12:09:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:10:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:11:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:12:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:13:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:14:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:15:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:16:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:17:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:18:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:19:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:20:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:21:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:22:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.089 DEBG ==> QTime("12:23:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:24:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:25:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:26:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:27:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:28:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:29:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:30:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:31:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:32:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:33:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:34:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:35:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:36:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:37:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.090 DEBG ==> QTime("12:38:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:39:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:40:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:41:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:42:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:43:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:44:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:45:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:46:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:47:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:48:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:49:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:50:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.091 DEBG ==> QTime("12:51:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:52:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:53:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:54:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:55:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:56:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:57:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:58:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("12:59:00.000") QDateTime(2023-01-04 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("13:00:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("13:01:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("13:02:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("13:03:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("13:04:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.092 DEBG ==> QTime("13:05:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:06:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:07:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:08:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:09:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:10:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:11:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:12:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:13:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:14:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:15:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:16:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:17:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:18:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.093 DEBG ==> QTime("13:19:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:20:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:21:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:22:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:23:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:24:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:25:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:26:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:27:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:28:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:29:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:30:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:31:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:32:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:33:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.094 DEBG ==> QTime("13:34:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:35:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:36:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:37:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:38:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:39:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:40:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:41:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:42:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:43:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:44:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:45:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:46:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.095 DEBG ==> QTime("13:47:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:48:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:49:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:50:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:51:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:52:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:53:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:54:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:55:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:56:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:57:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:58:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("13:59:00.000") QDateTime(2023-01-04 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("14:00:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("14:01:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.096 DEBG ==> QTime("14:02:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:03:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:04:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:05:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:06:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:07:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:08:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:09:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:10:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:11:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:12:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:13:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:14:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.097 DEBG ==> QTime("14:15:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:16:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:17:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:18:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:19:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:20:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:21:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:22:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:23:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:24:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:25:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:26:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:27:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:28:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.098 DEBG ==> QTime("14:29:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:30:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:31:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:32:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:33:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:34:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:35:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:36:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:37:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:38:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:39:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:40:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:41:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:42:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.099 DEBG ==> QTime("14:43:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:44:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:45:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:46:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:47:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:48:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:49:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:50:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:51:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:52:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:53:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:54:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:55:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:56:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.100 DEBG ==> QTime("14:57:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("14:58:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("14:59:00.000") QDateTime(2023-01-04 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:00:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:01:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:02:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:03:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:04:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:05:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:06:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:07:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:08:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:09:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:10:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.101 DEBG ==> QTime("15:11:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:12:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:13:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:14:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:15:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:16:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:17:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:18:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:19:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:20:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:21:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:22:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:23:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:24:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.102 DEBG ==> QTime("15:25:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:26:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:27:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:28:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:29:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:30:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:31:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:32:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:33:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:34:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:35:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:36:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:37:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:38:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.103 DEBG ==> QTime("15:39:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:40:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:41:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:42:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:43:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:44:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:45:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:46:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:47:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:48:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:49:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:50:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:51:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:52:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.104 DEBG ==> QTime("15:53:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("15:54:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("15:55:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("15:56:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("15:57:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("15:58:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("15:59:00.000") QDateTime(2023-01-04 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:00:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:01:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:02:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:03:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:04:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:05:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:06:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.105 DEBG ==> QTime("16:07:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:08:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:09:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:10:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:11:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:12:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:13:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:14:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:15:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:16:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:17:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:18:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:19:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:20:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.106 DEBG ==> QTime("16:21:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:22:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:23:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:24:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:25:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:26:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:27:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:28:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:29:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:30:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:31:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:32:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:33:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:34:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:35:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:36:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.107 DEBG ==> QTime("16:37:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:38:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:39:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:40:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:41:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:42:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:43:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:44:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:45:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:46:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:47:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:48:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:49:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:50:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:51:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:52:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:53:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:54:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:55:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:56:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.108 DEBG ==> QTime("16:57:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("16:58:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("16:59:00.000") QDateTime(2023-01-04 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:00:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:01:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:02:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:03:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:04:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:05:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:06:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:07:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:08:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:09:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:10:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:11:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:12:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:13:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:14:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.109 DEBG ==> QTime("17:15:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:16:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:17:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:18:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:19:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:20:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:21:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:22:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:23:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:24:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:25:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:26:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:27:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:28:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.110 DEBG ==> QTime("17:29:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:30:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:31:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:32:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:33:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:34:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:35:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:36:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:37:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:38:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:39:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:40:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:41:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:42:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.111 DEBG ==> QTime("17:43:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:44:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:45:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:46:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:47:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:48:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:49:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:50:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:51:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:52:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:53:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:54:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:55:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:56:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.112 DEBG ==> QTime("17:57:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("17:58:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("17:59:00.000") QDateTime(2023-01-04 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:00:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:01:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:02:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:03:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:04:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:05:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:06:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:07:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:08:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:09:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:10:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.113 DEBG ==> QTime("18:11:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:12:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:13:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:14:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:15:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:16:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:17:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:18:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:19:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:20:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:21:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:22:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:23:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:24:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.114 DEBG ==> QTime("18:25:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:26:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:27:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:28:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:29:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:30:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:31:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:32:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:33:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:34:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:35:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:36:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:37:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:38:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.115 DEBG ==> QTime("18:39:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:40:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:41:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:42:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:43:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:44:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:45:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:46:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:47:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:48:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:49:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:50:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:51:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:52:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.116 DEBG ==> QTime("18:53:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("18:54:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("18:55:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("18:56:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("18:57:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("18:58:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("18:59:00.000") QDateTime(2023-01-04 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:00:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:01:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:02:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:03:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:04:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:05:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:06:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.117 DEBG ==> QTime("19:07:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:08:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:09:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:10:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:11:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:12:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:13:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:14:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:15:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:16:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:17:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:18:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:19:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:20:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.118 DEBG ==> QTime("19:21:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:22:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:23:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:24:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:25:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:26:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:27:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:28:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:29:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:30:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:31:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:32:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:33:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:34:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.119 DEBG ==> QTime("19:35:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:36:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:37:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:38:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:39:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:40:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:41:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:42:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:43:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:44:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:45:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:46:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:47:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:48:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.120 DEBG ==> QTime("19:49:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:50:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:51:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:52:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:53:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:54:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:55:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:56:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:57:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:58:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("19:59:00.000") QDateTime(2023-01-04 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("20:00:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("20:01:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("20:02:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.121 DEBG ==> QTime("20:03:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:04:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:05:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:06:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:07:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:08:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:09:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:10:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:11:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:12:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:13:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:14:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:15:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:16:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.122 DEBG ==> QTime("20:17:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:18:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:19:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:20:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:21:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:22:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:23:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:24:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:25:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:26:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:27:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:28:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:29:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:30:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:31:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.123 DEBG ==> QTime("20:32:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:33:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:34:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:35:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:36:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:37:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:38:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:39:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:40:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:41:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:42:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:43:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:44:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:45:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.124 DEBG ==> QTime("20:46:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:47:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:48:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:49:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:50:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:51:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:52:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:53:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:54:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:55:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:56:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:57:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:58:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("20:59:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.125 DEBG ==> QTime("21:00:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:01:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:02:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:03:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:04:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:05:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:06:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:07:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:08:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:09:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:10:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:11:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:12:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.126 DEBG ==> QTime("21:13:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:14:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:15:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:16:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:17:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:18:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:19:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:20:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:21:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:22:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:23:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:24:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:25:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:26:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.127 DEBG ==> QTime("21:27:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:28:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:29:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:30:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:31:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:32:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:33:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:34:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:35:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:36:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:37:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:38:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:39:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:40:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.128 DEBG ==> QTime("21:41:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:42:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:43:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:44:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:45:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:46:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:47:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:48:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:49:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:50:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:51:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:52:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:53:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:54:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.129 DEBG ==> QTime("21:55:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("21:56:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("21:57:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("21:58:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("21:59:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:00:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:01:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:02:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:03:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:04:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:05:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:06:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:07:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.130 DEBG ==> QTime("22:08:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:09:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:10:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:11:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:12:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:13:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:14:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:15:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:16:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:17:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:18:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:19:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:20:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:21:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.131 DEBG ==> QTime("22:22:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:23:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:24:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:25:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:26:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:27:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:28:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:29:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:30:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:31:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:32:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:33:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:34:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:35:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.132 DEBG ==> QTime("22:36:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:37:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:38:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:39:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:40:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:41:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:42:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:43:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:44:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:45:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:46:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:47:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:48:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:49:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:50:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:51:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.133 DEBG ==> QTime("22:52:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("22:53:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("22:54:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("22:55:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("22:56:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("22:57:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("22:58:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("22:59:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("23:00:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("23:01:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("23:02:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("23:03:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("23:04:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.134 DEBG ==> QTime("23:05:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:06:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:07:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:08:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:09:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:10:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:11:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:12:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:13:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:14:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:15:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:16:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:17:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:18:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.135 DEBG ==> QTime("23:19:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:20:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:21:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:22:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:23:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:24:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:25:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:26:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:27:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:28:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:29:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:30:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:31:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:32:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.136 DEBG ==> QTime("23:33:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:34:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:35:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:36:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:37:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:38:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:39:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:40:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:41:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:42:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:43:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:44:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:45:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:46:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.137 DEBG ==> QTime("23:47:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:48:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:49:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:50:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:51:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:52:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:53:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:54:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:55:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:56:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:57:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:58:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("23:59:00.000") QDateTime(2023-01-04 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG 1 4 *** + (main.cpp:123) + 04.01.2023 08:22:03.138 DEBG ==> QTime("00:00:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.138 DEBG ==> QTime("00:01:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:02:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:03:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:04:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:05:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:06:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:07:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:08:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:09:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:10:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:11:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:12:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:13:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:14:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:15:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:16:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.139 DEBG ==> QTime("00:17:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:18:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:19:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:20:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:21:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:22:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:23:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:24:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:25:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:26:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:27:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:28:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:29:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:30:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:31:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.140 DEBG ==> QTime("00:32:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:33:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:34:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:35:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:36:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:37:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:38:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:39:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:40:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:41:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:42:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:43:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:44:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:45:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:46:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.141 DEBG ==> QTime("00:47:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:48:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:49:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:50:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:51:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:52:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:53:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:54:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:55:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:56:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:57:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:58:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("00:59:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("01:00:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("01:01:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.142 DEBG ==> QTime("01:02:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:03:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:04:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:05:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:06:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:07:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:08:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:09:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:10:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:11:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:12:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:13:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:14:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:15:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:16:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:17:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:18:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:19:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:20:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:21:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:22:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:23:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:24:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.143 DEBG ==> QTime("01:25:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:26:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:27:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:28:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:29:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:30:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:31:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:32:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:33:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:34:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:35:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:36:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:37:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:38:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:39:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:40:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:41:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:42:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:43:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:44:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:45:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.144 DEBG ==> QTime("01:46:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:47:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:48:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:49:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:50:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:51:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:52:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:53:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:54:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:55:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:56:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:57:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:58:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("01:59:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:00:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:01:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:02:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:03:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:04:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:05:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:06:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:07:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:08:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.145 DEBG ==> QTime("02:09:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:10:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:11:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:12:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:13:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:14:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:15:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:16:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:17:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:18:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:19:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:20:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:21:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:22:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:23:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:24:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:25:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:26:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:27:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:28:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:29:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:30:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:31:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.146 DEBG ==> QTime("02:32:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:33:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:34:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:35:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:36:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:37:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:38:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:39:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:40:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:41:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:42:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:43:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:44:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:45:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:46:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:47:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:48:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:49:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:50:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:51:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:52:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:53:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:54:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.147 DEBG ==> QTime("02:55:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("02:56:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("02:57:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("02:58:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("02:59:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:00:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:01:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:02:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:03:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:04:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:05:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:06:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:07:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:08:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:09:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.148 DEBG ==> QTime("03:10:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:11:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:12:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:13:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:14:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:15:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:16:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:17:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:18:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:19:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:20:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:21:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:22:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:23:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:24:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:25:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.149 DEBG ==> QTime("03:26:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:27:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:28:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:29:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:30:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:31:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:32:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:33:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:34:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:35:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:36:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:37:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:38:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:39:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:40:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.150 DEBG ==> QTime("03:41:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:42:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:43:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:44:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:45:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:46:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:47:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:48:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:49:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:50:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:51:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:52:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:53:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:54:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:55:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.151 DEBG ==> QTime("03:56:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("03:57:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("03:58:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("03:59:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:00:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:01:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:02:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:03:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:04:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:05:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:06:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:07:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:08:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:09:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:10:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.152 DEBG ==> QTime("04:11:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:12:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:13:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:14:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:15:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:16:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:17:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:18:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:19:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:20:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:21:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:22:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:23:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:24:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:25:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.153 DEBG ==> QTime("04:26:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:27:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:28:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:29:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:30:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:31:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:32:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:33:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:34:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:35:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:36:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:37:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:38:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:39:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:40:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.154 DEBG ==> QTime("04:41:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:42:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:43:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:44:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:45:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:46:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:47:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:48:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:49:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:50:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:51:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:52:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:53:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:54:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:55:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.155 DEBG ==> QTime("04:56:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("04:57:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("04:58:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("04:59:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:00:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:01:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:02:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:03:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:04:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:05:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:06:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:07:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:08:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:09:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:10:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:11:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.156 DEBG ==> QTime("05:12:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:13:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:14:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:15:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:16:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:17:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:18:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:19:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:20:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:21:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:22:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:23:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:24:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:25:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.157 DEBG ==> QTime("05:26:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:27:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:28:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:29:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:30:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:31:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:32:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:33:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:34:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:35:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:36:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:37:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:38:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:39:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:40:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:41:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.158 DEBG ==> QTime("05:42:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:43:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:44:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:45:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:46:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:47:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:48:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:49:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:50:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:51:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:52:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:53:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:54:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:55:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.159 DEBG ==> QTime("05:56:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("05:57:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("05:58:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("05:59:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:00:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:01:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:02:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:03:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:04:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:05:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:06:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:07:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:08:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:09:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:10:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:11:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.160 DEBG ==> QTime("06:12:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:13:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:14:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:15:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:16:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:17:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:18:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:19:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:20:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:21:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:22:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:23:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:24:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:25:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:26:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.161 DEBG ==> QTime("06:27:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:28:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:29:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:30:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:31:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:32:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:33:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:34:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:35:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:36:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:37:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:38:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:39:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:40:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:41:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.162 DEBG ==> QTime("06:42:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:43:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:44:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:45:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:46:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:47:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:48:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:49:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:50:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:51:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:52:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:53:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:54:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:55:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:56:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.163 DEBG ==> QTime("06:57:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("06:58:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("06:59:00.000") QDateTime(2023-01-05 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:00:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:01:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:02:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:03:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:04:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:05:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:06:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:07:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:08:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:09:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:10:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:11:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.164 DEBG ==> QTime("07:12:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:13:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:14:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:15:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:16:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:17:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:18:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:19:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:20:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:21:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:22:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:23:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:24:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:25:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.165 DEBG ==> QTime("07:26:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:27:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:28:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:29:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:30:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:31:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:32:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:33:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:34:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:35:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:36:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:37:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:38:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:39:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.166 DEBG ==> QTime("07:40:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:41:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:42:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:43:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:44:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:45:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:46:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:47:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:48:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:49:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:50:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:51:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:52:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:53:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:54:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.167 DEBG ==> QTime("07:55:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("07:56:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("07:57:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("07:58:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("07:59:00.000") QDateTime(2023-01-05 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:00:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:01:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:02:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:03:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:04:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:05:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:06:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:07:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:08:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:09:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.168 DEBG ==> QTime("08:10:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:11:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:12:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:13:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:14:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:15:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:16:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:17:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:18:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:19:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:20:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:21:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:22:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:23:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.169 DEBG ==> QTime("08:24:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:25:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:26:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:27:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:28:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:29:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:30:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:31:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:32:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:33:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:34:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:35:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:36:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:37:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.170 DEBG ==> QTime("08:38:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:39:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:40:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:41:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:42:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:43:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:44:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:45:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:46:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:47:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:48:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:49:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:50:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:51:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.171 DEBG ==> QTime("08:52:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("08:53:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("08:54:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("08:55:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("08:56:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("08:57:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("08:58:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("08:59:00.000") QDateTime(2023-01-05 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("09:00:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("09:01:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("09:02:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("09:03:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("09:04:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("09:05:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.172 DEBG ==> QTime("09:06:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:07:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:08:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:09:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:10:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:11:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:12:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:13:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:14:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:15:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:16:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:17:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:18:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:19:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:20:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.173 DEBG ==> QTime("09:21:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:22:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:23:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:24:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:25:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:26:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:27:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:28:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:29:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:30:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:31:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:32:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:33:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.174 DEBG ==> QTime("09:34:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:35:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:36:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:37:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:38:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:39:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:40:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:41:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:42:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:43:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:44:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:45:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:46:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:47:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:48:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.175 DEBG ==> QTime("09:49:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:50:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:51:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:52:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:53:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:54:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:55:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:56:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:57:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:58:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("09:59:00.000") QDateTime(2023-01-05 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("10:00:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("10:01:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("10:02:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.176 DEBG ==> QTime("10:03:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:04:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:05:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:06:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:07:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:08:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:09:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:10:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:11:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:12:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:13:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:14:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:15:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:16:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.177 DEBG ==> QTime("10:17:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:18:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:19:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:20:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:21:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:22:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:23:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:24:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:25:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:26:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:27:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:28:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:29:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:30:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.178 DEBG ==> QTime("10:31:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:32:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:33:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:34:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:35:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:36:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:37:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:38:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:39:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:40:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:41:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:42:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:43:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:44:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.179 DEBG ==> QTime("10:45:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:46:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:47:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:48:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:49:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:50:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:51:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:52:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:53:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:54:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:55:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:56:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:57:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:58:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.180 DEBG ==> QTime("10:59:00.000") QDateTime(2023-01-05 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:00:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:01:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:02:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:03:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:04:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:05:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:06:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:07:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:08:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:09:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:10:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:11:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:12:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.181 DEBG ==> QTime("11:13:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:14:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:15:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:16:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:17:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:18:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:19:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:20:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:21:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:22:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:23:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:24:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:25:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:26:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.182 DEBG ==> QTime("11:27:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:28:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:29:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:30:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:31:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:32:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:33:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:34:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:35:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:36:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:37:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:38:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:39:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:40:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:41:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:42:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.183 DEBG ==> QTime("11:43:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:44:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:45:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:46:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:47:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:48:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:49:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:50:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:51:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:52:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:53:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:54:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:55:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:56:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.184 DEBG ==> QTime("11:57:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("11:58:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("11:59:00.000") QDateTime(2023-01-05 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:00:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:01:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:02:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:03:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:04:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:05:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:06:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:07:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:08:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:09:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:10:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.185 DEBG ==> QTime("12:11:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:12:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:13:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:14:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:15:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:16:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:17:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:18:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:19:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:20:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:21:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:22:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:23:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:24:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.186 DEBG ==> QTime("12:25:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:26:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:27:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:28:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:29:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:30:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:31:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:32:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:33:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:34:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:35:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:36:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:37:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:38:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.187 DEBG ==> QTime("12:39:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:40:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:41:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:42:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:43:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:44:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:45:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:46:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:47:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:48:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:49:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:50:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:51:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:52:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.188 DEBG ==> QTime("12:53:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("12:54:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("12:55:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("12:56:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("12:57:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("12:58:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("12:59:00.000") QDateTime(2023-01-05 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:00:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:01:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:02:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:03:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:04:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:05:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:06:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.189 DEBG ==> QTime("13:07:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:08:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:09:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:10:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:11:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:12:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:13:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:14:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:15:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:16:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:17:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:18:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:19:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:20:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:21:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.190 DEBG ==> QTime("13:22:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:23:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:24:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:25:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:26:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:27:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:28:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:29:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:30:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:31:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:32:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:33:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:34:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.191 DEBG ==> QTime("13:35:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:36:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:37:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:38:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:39:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:40:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:41:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:42:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:43:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:44:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:45:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:46:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:47:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:48:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.192 DEBG ==> QTime("13:49:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:50:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:51:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:52:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:53:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:54:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:55:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:56:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:57:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:58:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("13:59:00.000") QDateTime(2023-01-05 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("14:00:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("14:01:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("14:02:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.193 DEBG ==> QTime("14:03:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:04:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:05:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:06:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:07:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:08:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:09:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:10:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:11:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:12:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:13:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:14:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:15:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.194 DEBG ==> QTime("14:16:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:17:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:18:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:19:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:20:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:21:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:22:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:23:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:24:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:25:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:26:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:27:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:28:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:29:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.195 DEBG ==> QTime("14:30:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:31:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:32:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:33:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:34:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:35:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:36:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:37:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:38:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:39:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:40:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:41:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:42:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:43:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.196 DEBG ==> QTime("14:44:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:45:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:46:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:47:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:48:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:49:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:50:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:51:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:52:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:53:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:54:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:55:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:56:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:57:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.197 DEBG ==> QTime("14:58:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("14:59:00.000") QDateTime(2023-01-05 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:00:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:01:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:02:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:03:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:04:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:05:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:06:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:07:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:08:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:09:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:10:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:11:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.198 DEBG ==> QTime("15:12:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:13:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:14:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:15:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:16:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:17:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:18:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:19:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:20:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:21:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:22:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:23:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:24:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:25:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.199 DEBG ==> QTime("15:26:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:27:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:28:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:29:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:30:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:31:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:32:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:33:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:34:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:35:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:36:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:37:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:38:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:39:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.200 DEBG ==> QTime("15:40:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:41:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:42:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:43:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:44:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:45:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:46:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:47:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:48:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:49:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:50:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:51:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:52:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:53:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.201 DEBG ==> QTime("15:54:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("15:55:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("15:56:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("15:57:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("15:58:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("15:59:00.000") QDateTime(2023-01-05 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:00:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:01:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:02:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:03:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:04:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:05:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:06:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:07:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.202 DEBG ==> QTime("16:08:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:09:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:10:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:11:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:12:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:13:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:14:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:15:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:16:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:17:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:18:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:19:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:20:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:21:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.203 DEBG ==> QTime("16:22:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:23:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:24:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:25:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:26:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:27:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:28:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:29:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:30:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:31:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:32:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:33:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:34:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:35:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.204 DEBG ==> QTime("16:36:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:37:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:38:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:39:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:40:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:41:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:42:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:43:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:44:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:45:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:46:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:47:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:48:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:49:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.205 DEBG ==> QTime("16:50:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:51:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:52:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:53:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:54:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:55:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:56:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:57:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:58:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("16:59:00.000") QDateTime(2023-01-05 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("17:00:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("17:01:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("17:02:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("17:03:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.206 DEBG ==> QTime("17:04:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:05:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:06:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:07:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:08:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:09:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:10:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:11:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:12:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:13:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:14:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:15:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:16:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:17:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.207 DEBG ==> QTime("17:18:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:19:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:20:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:21:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:22:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:23:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:24:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:25:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:26:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:27:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:28:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:29:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:30:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:31:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.208 DEBG ==> QTime("17:32:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:33:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:34:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:35:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:36:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:37:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:38:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:39:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:40:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:41:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:42:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:43:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:44:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.209 DEBG ==> QTime("17:45:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:46:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:47:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:48:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:49:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:50:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:51:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:52:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:53:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:54:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:55:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:56:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:57:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:58:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.210 DEBG ==> QTime("17:59:00.000") QDateTime(2023-01-05 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:00:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:01:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:02:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:03:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:04:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:05:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:06:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:07:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:08:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:09:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:10:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:11:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:12:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:13:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.211 DEBG ==> QTime("18:14:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:15:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:16:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:17:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:18:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:19:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:20:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:21:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:22:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:23:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:24:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:25:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:26:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:27:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:28:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:29:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:30:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:31:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:32:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:33:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:34:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.212 DEBG ==> QTime("18:35:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:36:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:37:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:38:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:39:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:40:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:41:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:42:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:43:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:44:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:45:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:46:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:47:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:48:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:49:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:50:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:51:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:52:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:53:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:54:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:55:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.213 DEBG ==> QTime("18:56:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("18:57:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("18:58:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("18:59:00.000") QDateTime(2023-01-05 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:00:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:01:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:02:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:03:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:04:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:05:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:06:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:07:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:08:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:09:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:10:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:11:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:12:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:13:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:14:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:15:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:16:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.214 DEBG ==> QTime("19:17:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:18:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:19:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:20:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:21:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:22:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:23:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:24:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:25:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:26:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:27:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:28:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:29:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:30:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:31:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:32:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:33:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:34:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:35:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:36:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.215 DEBG ==> QTime("19:37:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:38:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:39:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:40:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:41:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:42:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:43:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:44:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:45:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:46:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:47:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:48:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:49:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:50:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:51:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:52:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:53:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:54:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:55:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:56:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:57:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:58:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.216 DEBG ==> QTime("19:59:00.000") QDateTime(2023-01-05 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:00:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:01:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:02:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:03:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:04:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:05:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:06:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:07:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:08:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:09:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:10:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:11:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:12:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:13:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:14:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:15:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:16:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:17:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:18:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:19:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:20:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.217 DEBG ==> QTime("20:21:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:22:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:23:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:24:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:25:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:26:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:27:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:28:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:29:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:30:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:31:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:32:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:33:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:34:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:35:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:36:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:37:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:38:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:39:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:40:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:41:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:42:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.218 DEBG ==> QTime("20:43:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:44:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:45:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:46:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:47:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:48:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:49:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:50:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:51:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:52:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:53:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:54:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:55:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:56:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:57:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:58:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("20:59:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("21:00:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("21:01:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("21:02:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("21:03:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("21:04:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.219 DEBG ==> QTime("21:05:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:06:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:07:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:08:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:09:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:10:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:11:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:12:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:13:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:14:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:15:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:16:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:17:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:18:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:19:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:20:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:21:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:22:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:23:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:24:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:25:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:26:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:27:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.220 DEBG ==> QTime("21:28:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:29:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:30:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:31:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:32:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:33:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:34:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:35:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:36:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:37:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:38:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:39:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:40:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:41:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:42:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:43:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:44:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:45:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:46:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:47:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:48:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:49:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.221 DEBG ==> QTime("21:50:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:51:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:52:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:53:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:54:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:55:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:56:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:57:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:58:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("21:59:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:00:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:01:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:02:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:03:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:04:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:05:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:06:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.222 DEBG ==> QTime("22:07:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:08:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:09:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:10:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:11:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:12:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:13:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:14:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:15:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:16:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:17:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:18:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:19:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.223 DEBG ==> QTime("22:20:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:21:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:22:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:23:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:24:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:25:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:26:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:27:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:28:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:29:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:30:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:31:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:32:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:33:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.224 DEBG ==> QTime("22:34:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:35:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:36:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:37:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:38:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:39:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:40:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:41:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:42:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:43:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:44:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:45:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:46:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:47:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:48:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.225 DEBG ==> QTime("22:49:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:50:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:51:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:52:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:53:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:54:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:55:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:56:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:57:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:58:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("22:59:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("23:00:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("23:01:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("23:02:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("23:03:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("23:04:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.226 DEBG ==> QTime("23:05:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:06:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:07:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:08:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:09:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:10:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:11:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:12:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:13:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:14:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:15:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:16:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:17:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:18:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:19:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:20:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:21:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:22:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:23:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:24:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.227 DEBG ==> QTime("23:25:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:26:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:27:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:28:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:29:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:30:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:31:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:32:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:33:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:34:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:35:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:36:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:37:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:38:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:39:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:40:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:41:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:42:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:43:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:44:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:45:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:46:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.228 DEBG ==> QTime("23:47:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:48:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:49:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:50:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:51:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:52:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:53:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:54:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:55:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:56:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:57:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:58:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("23:59:00.000") QDateTime(2023-01-05 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG 2 5 *** + (main.cpp:123) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:00:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:01:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:02:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:03:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:04:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:05:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:06:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:07:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.229 DEBG ==> QTime("00:08:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:09:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:10:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:11:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:12:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:13:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:14:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:15:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:16:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:17:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:18:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:19:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:20:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:21:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:22:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:23:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:24:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:25:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:26:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:27:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:28:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:29:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:30:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.230 DEBG ==> QTime("00:31:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:32:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:33:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:34:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:35:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:36:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:37:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:38:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:39:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:40:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:41:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:42:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:43:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:44:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:45:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:46:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:47:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:48:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:49:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:50:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:51:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:52:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:53:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.231 DEBG ==> QTime("00:54:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("00:55:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("00:56:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("00:57:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("00:58:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("00:59:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:00:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:01:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:02:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:03:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:04:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:05:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:06:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:07:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:08:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:09:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:10:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:11:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:12:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:13:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:14:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:15:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:16:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.232 DEBG ==> QTime("01:17:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:18:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:19:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:20:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:21:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:22:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:23:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:24:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:25:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:26:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:27:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:28:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:29:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:30:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:31:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:32:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:33:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:34:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:35:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:36:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:37:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:38:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:39:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.233 DEBG ==> QTime("01:40:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:41:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:42:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:43:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:44:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:45:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:46:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:47:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:48:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:49:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:50:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:51:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:52:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:53:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:54:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:55:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:56:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:57:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:58:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("01:59:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("02:00:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("02:01:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("02:02:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("02:03:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.234 DEBG ==> QTime("02:04:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:05:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:06:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:07:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:08:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:09:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:10:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:11:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:12:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:13:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:14:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:15:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:16:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:17:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:18:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:19:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:20:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:21:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:22:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:23:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.235 DEBG ==> QTime("02:24:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:25:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:26:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:27:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:28:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:29:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:30:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:31:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:32:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:33:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:34:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:35:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:36:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:37:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:38:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:39:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:40:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:41:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:42:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:43:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:44:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:45:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.236 DEBG ==> QTime("02:46:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:47:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:48:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:49:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:50:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:51:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:52:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:53:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:54:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:55:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:56:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:57:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:58:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("02:59:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:00:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:01:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:02:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:03:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:04:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:05:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:06:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:07:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:08:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.237 DEBG ==> QTime("03:09:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:10:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:11:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:12:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:13:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:14:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:15:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:16:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:17:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:18:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:19:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:20:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:21:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:22:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:23:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:24:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:25:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:26:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:27:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:28:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:29:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:30:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:31:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.238 DEBG ==> QTime("03:32:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:33:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:34:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:35:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:36:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:37:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:38:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:39:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:40:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:41:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:42:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:43:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:44:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:45:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:46:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:47:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:48:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:49:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:50:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:51:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:52:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:53:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:54:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.239 DEBG ==> QTime("03:55:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("03:56:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("03:57:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("03:58:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("03:59:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:00:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:01:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:02:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:03:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:04:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:05:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:06:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:07:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:08:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:09:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:10:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:11:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:12:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:13:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:14:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:15:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:16:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:17:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.240 DEBG ==> QTime("04:18:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:19:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:20:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:21:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:22:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:23:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:24:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:25:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:26:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:27:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:28:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:29:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:30:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:31:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:32:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:33:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:34:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:35:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:36:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:37:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:38:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:39:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:40:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.241 DEBG ==> QTime("04:41:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:42:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:43:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:44:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:45:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:46:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:47:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:48:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:49:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:50:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:51:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:52:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:53:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:54:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:55:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:56:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:57:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.242 DEBG ==> QTime("04:58:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("04:59:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:00:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:01:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:02:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:03:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:04:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:05:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:06:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:07:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:08:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:09:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:10:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:11:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:12:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.243 DEBG ==> QTime("05:13:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:14:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:15:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:16:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:17:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:18:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:19:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:20:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:21:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:22:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:23:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:24:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:25:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:26:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:27:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.244 DEBG ==> QTime("05:28:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:29:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:30:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:31:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:32:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:33:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:34:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:35:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:36:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:37:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:38:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:39:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:40:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:41:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:42:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.245 DEBG ==> QTime("05:43:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:44:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:45:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:46:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:47:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:48:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:49:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:50:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:51:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:52:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:53:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:54:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:55:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:56:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:57:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.246 DEBG ==> QTime("05:58:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("05:59:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:00:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:01:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:02:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:03:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:04:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:05:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:06:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:07:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:08:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:09:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:10:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:11:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:12:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:13:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.247 DEBG ==> QTime("06:14:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:15:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:16:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:17:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:18:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:19:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:20:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:21:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:22:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:23:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:24:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:25:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:26:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:27:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:28:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.248 DEBG ==> QTime("06:29:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:30:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:31:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:32:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:33:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:34:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:35:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:36:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:37:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:38:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:39:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:40:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:41:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:42:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:43:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.249 DEBG ==> QTime("06:44:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:45:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:46:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:47:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:48:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:49:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:50:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:51:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:52:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:53:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:54:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:55:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:56:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:57:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:58:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.250 DEBG ==> QTime("06:59:00.000") QDateTime(2023-01-06 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:00:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:01:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:02:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:03:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:04:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:05:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:06:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:07:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:08:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:09:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:10:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:11:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:12:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:13:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.251 DEBG ==> QTime("07:14:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:15:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:16:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:17:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:18:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:19:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:20:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:21:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:22:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:23:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:24:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:25:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:26:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:27:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.252 DEBG ==> QTime("07:28:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:29:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:30:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:31:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:32:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:33:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:34:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:35:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:36:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:37:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:38:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:39:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:40:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:41:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:42:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.253 DEBG ==> QTime("07:43:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:44:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:45:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:46:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:47:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:48:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:49:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:50:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:51:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:52:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:53:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:54:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:55:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.254 DEBG ==> QTime("07:56:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("07:57:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("07:58:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("07:59:00.000") QDateTime(2023-01-06 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:00:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:01:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:02:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:03:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:04:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:05:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:06:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:07:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:08:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:09:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.255 DEBG ==> QTime("08:10:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:11:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:12:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:13:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:14:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:15:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:16:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:17:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:18:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:19:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:20:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:21:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:22:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:23:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.256 DEBG ==> QTime("08:24:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:25:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:26:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:27:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:28:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:29:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:30:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:31:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:32:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:33:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:34:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:35:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:36:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:37:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.257 DEBG ==> QTime("08:38:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:39:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:40:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:41:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:42:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:43:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:44:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:45:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:46:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:47:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:48:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:49:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:50:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:51:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:52:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.258 DEBG ==> QTime("08:53:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("08:54:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("08:55:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("08:56:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("08:57:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("08:58:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("08:59:00.000") QDateTime(2023-01-06 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("09:00:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("09:01:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("09:02:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("09:03:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("09:04:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("09:05:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.259 DEBG ==> QTime("09:06:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:07:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:08:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:09:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:10:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:11:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:12:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:13:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:14:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:15:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:16:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:17:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:18:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:19:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:20:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:21:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:22:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.260 DEBG ==> QTime("09:23:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:24:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:25:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:26:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:27:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:28:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:29:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:30:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:31:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:32:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:33:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:34:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:35:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:36:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:37:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:38:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:39:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:40:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:41:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:42:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:43:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:44:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.261 DEBG ==> QTime("09:45:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:46:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:47:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:48:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:49:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:50:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:51:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:52:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:53:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:54:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:55:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:56:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:57:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:58:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("09:59:00.000") QDateTime(2023-01-06 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:00:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:01:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:02:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:03:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:04:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:05:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:06:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.262 DEBG ==> QTime("10:07:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:08:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:09:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:10:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:11:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:12:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:13:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:14:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:15:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:16:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:17:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:18:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:19:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:20:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:21:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:22:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:23:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:24:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:25:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:26:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:27:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:28:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:29:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.263 DEBG ==> QTime("10:30:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:31:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:32:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:33:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:34:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:35:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:36:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:37:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:38:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:39:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:40:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:41:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:42:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:43:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:44:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:45:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:46:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:47:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:48:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:49:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:50:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:51:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.264 DEBG ==> QTime("10:52:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("10:53:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("10:54:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("10:55:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("10:56:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("10:57:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("10:58:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("10:59:00.000") QDateTime(2023-01-06 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:00:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:01:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:02:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:03:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:04:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:05:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:06:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:07:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:08:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:09:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:10:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:11:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:12:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:13:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:14:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.265 DEBG ==> QTime("11:15:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:16:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:17:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:18:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:19:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:20:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:21:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:22:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:23:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:24:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:25:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:26:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:27:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:28:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:29:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:30:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:31:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:32:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:33:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:34:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:35:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:36:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.266 DEBG ==> QTime("11:37:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:38:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:39:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:40:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:41:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:42:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:43:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:44:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:45:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:46:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:47:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:48:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:49:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:50:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:51:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:52:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:53:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:54:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:55:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:56:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.267 DEBG ==> QTime("11:57:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("11:58:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("11:59:00.000") QDateTime(2023-01-06 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:00:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:01:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:02:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:03:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:04:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:05:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:06:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:07:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:08:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:09:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:10:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:11:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:12:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:13:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:14:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:15:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:16:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.268 DEBG ==> QTime("12:17:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:18:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:19:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:20:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:21:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:22:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:23:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:24:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:25:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:26:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:27:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:28:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:29:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:30:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:31:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:32:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:33:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:34:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:35:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:36:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:37:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:38:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.269 DEBG ==> QTime("12:39:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:40:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:41:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:42:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:43:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:44:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:45:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:46:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:47:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:48:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:49:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:50:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:51:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:52:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:53:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:54:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:55:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:56:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:57:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:58:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("12:59:00.000") QDateTime(2023-01-06 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.270 DEBG ==> QTime("13:00:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:01:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:02:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:03:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:04:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:05:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:06:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:07:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:08:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:09:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:10:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:11:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:12:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:13:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:14:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:15:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:16:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:17:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:18:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:19:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:20:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.271 DEBG ==> QTime("13:21:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:22:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:23:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:24:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:25:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:26:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:27:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:28:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:29:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:30:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:31:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:32:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:33:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:34:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:35:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:36:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:37:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:38:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:39:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:40:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:41:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:42:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.272 DEBG ==> QTime("13:43:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:44:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:45:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:46:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:47:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:48:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:49:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:50:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:51:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:52:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:53:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:54:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:55:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:56:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:57:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:58:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("13:59:00.000") QDateTime(2023-01-06 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("14:00:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("14:01:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("14:02:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("14:03:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("14:04:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.273 DEBG ==> QTime("14:05:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:06:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:07:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:08:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:09:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:10:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:11:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:12:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:13:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:14:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:15:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:16:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:17:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:18:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:19:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:20:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:21:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:22:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:23:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:24:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.274 DEBG ==> QTime("14:25:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:26:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:27:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:28:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:29:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:30:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:31:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:32:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:33:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:34:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:35:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:36:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:37:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:38:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:39:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:40:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:41:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:42:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:43:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:44:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:45:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.275 DEBG ==> QTime("14:46:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:47:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:48:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:49:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:50:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:51:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:52:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:53:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:54:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:55:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:56:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:57:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:58:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("14:59:00.000") QDateTime(2023-01-06 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("15:00:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("15:01:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("15:02:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("15:03:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.276 DEBG ==> QTime("15:04:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:05:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:06:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:07:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:08:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:09:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:10:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:11:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:12:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:13:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:14:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:15:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:16:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:17:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:18:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:19:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:20:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:21:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:22:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:23:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:24:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.277 DEBG ==> QTime("15:25:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:26:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:27:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:28:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:29:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:30:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:31:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:32:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:33:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:34:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:35:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:36:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:37:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:38:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:39:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:40:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:41:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:42:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:43:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:44:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:45:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.278 DEBG ==> QTime("15:46:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:47:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:48:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:49:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:50:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:51:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:52:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:53:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:54:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:55:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:56:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:57:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:58:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("15:59:00.000") QDateTime(2023-01-06 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:00:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:01:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:02:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:03:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:04:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:05:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:06:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.279 DEBG ==> QTime("16:07:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:08:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:09:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:10:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:11:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:12:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:13:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:14:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:15:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:16:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:17:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:18:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:19:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:20:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:21:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:22:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:23:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:24:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:25:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:26:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:27:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:28:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.280 DEBG ==> QTime("16:29:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:30:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:31:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:32:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:33:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:34:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:35:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:36:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:37:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:38:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:39:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:40:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:41:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:42:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:43:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:44:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:45:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:46:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:47:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:48:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:49:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:50:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.281 DEBG ==> QTime("16:51:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:52:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:53:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:54:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:55:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:56:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:57:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:58:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("16:59:00.000") QDateTime(2023-01-06 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:00:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:01:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:02:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:03:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:04:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:05:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:06:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:07:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:08:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:09:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:10:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:11:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.282 DEBG ==> QTime("17:12:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:13:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:14:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:15:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:16:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:17:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:18:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:19:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:20:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:21:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:22:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:23:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:24:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:25:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:26:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:27:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:28:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:29:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:30:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:31:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:32:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.283 DEBG ==> QTime("17:33:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:34:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:35:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:36:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:37:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:38:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:39:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:40:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:41:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:42:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:43:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:44:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:45:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:46:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:47:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:48:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:49:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:50:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:51:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:52:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:53:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:54:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.284 DEBG ==> QTime("17:55:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("17:56:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("17:57:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("17:58:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("17:59:00.000") QDateTime(2023-01-06 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:00:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:01:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:02:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:03:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:04:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:05:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:06:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:07:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:08:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:09:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:10:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:11:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:12:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:13:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:14:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:15:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:16:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.285 DEBG ==> QTime("18:17:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:18:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:19:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:20:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:21:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:22:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:23:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:24:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:25:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:26:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:27:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:28:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:29:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:30:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:31:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:32:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:33:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:34:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:35:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:36:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:37:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:38:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.286 DEBG ==> QTime("18:39:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:40:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:41:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:42:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:43:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:44:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:45:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:46:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:47:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:48:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:49:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:50:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:51:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:52:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:53:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:54:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:55:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:56:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:57:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:58:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("18:59:00.000") QDateTime(2023-01-06 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("19:00:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.287 DEBG ==> QTime("19:01:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:02:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:03:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:04:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:05:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:06:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:07:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:08:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:09:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:10:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:11:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:12:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:13:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:14:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:15:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:16:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:17:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:18:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:19:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:20:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:21:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:22:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.288 DEBG ==> QTime("19:23:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:24:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:25:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:26:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:27:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:28:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:29:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:30:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:31:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:32:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:33:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:34:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:35:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:36:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:37:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:38:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:39:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:40:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:41:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:42:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:43:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:44:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.289 DEBG ==> QTime("19:45:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:46:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:47:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:48:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:49:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:50:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:51:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:52:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:53:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:54:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:55:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:56:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:57:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:58:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("19:59:00.000") QDateTime(2023-01-06 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:00:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:01:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:02:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:03:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:04:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:05:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:06:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:07:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.290 DEBG ==> QTime("20:08:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:09:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:10:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:11:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:12:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:13:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:14:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:15:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:16:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:17:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:18:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:19:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:20:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:21:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:22:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:23:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:24:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:25:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:26:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:27:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.291 DEBG ==> QTime("20:28:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:29:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:30:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:31:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:32:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:33:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:34:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:35:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:36:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:37:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:38:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:39:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:40:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:41:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:42:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:43:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:44:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:45:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:46:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:47:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.292 DEBG ==> QTime("20:48:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:49:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:50:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:51:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:52:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:53:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:54:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:55:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:56:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:57:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:58:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("20:59:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("21:00:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("21:01:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("21:02:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("21:03:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("21:04:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.293 DEBG ==> QTime("21:05:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:06:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:07:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:08:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:09:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:10:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:11:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:12:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:13:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:14:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:15:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:16:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:17:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:18:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:19:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:20:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:21:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:22:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:23:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:24:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:25:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.294 DEBG ==> QTime("21:26:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:27:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:28:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:29:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:30:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:31:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:32:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:33:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:34:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:35:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:36:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:37:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:38:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:39:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:40:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:41:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:42:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:43:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:44:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:45:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.295 DEBG ==> QTime("21:46:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:47:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:48:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:49:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:50:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:51:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:52:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:53:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:54:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:55:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:56:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:57:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:58:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("21:59:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:00:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:01:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:02:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:03:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:04:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:05:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:06:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:07:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.296 DEBG ==> QTime("22:08:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:09:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:10:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:11:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:12:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:13:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:14:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:15:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:16:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:17:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:18:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:19:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:20:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:21:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:22:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:23:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:24:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:25:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:26:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:27:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:28:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.297 DEBG ==> QTime("22:29:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:30:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:31:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:32:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:33:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:34:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:35:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:36:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:37:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:38:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:39:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:40:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:41:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:42:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:43:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:44:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:45:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:46:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:47:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:48:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:49:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.298 DEBG ==> QTime("22:50:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:51:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:52:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:53:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:54:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:55:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:56:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:57:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:58:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("22:59:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:00:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:01:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:02:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:03:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:04:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:05:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:06:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:07:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:08:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.299 DEBG ==> QTime("23:09:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:10:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:11:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:12:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:13:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:14:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:15:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:16:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:17:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:18:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:19:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:20:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:21:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:22:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:23:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:24:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:25:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:26:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:27:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:28:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:29:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:30:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.300 DEBG ==> QTime("23:31:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:32:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:33:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:34:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:35:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:36:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:37:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:38:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:39:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:40:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:41:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:42:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:43:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:44:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:45:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:46:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:47:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:48:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:49:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:50:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:51:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:52:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.301 DEBG ==> QTime("23:53:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("23:54:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("23:55:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("23:56:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("23:57:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("23:58:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("23:59:00.000") QDateTime(2023-01-06 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG 3 6 *** + (main.cpp:123) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:00:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:01:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:02:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:03:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:04:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:05:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:06:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:07:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:08:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:09:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:10:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:11:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:12:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:13:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:14:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:15:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.302 DEBG ==> QTime("00:16:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:17:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:18:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:19:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:20:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:21:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:22:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:23:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:24:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:25:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:26:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:27:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:28:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:29:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:30:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:31:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:32:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:33:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:34:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:35:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:36:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:37:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:38:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:39:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.303 DEBG ==> QTime("00:40:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:41:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:42:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:43:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:44:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:45:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:46:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:47:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:48:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:49:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:50:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:51:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:52:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:53:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:54:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:55:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:56:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:57:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:58:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("00:59:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("01:00:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("01:01:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("01:02:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("01:03:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.304 DEBG ==> QTime("01:04:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:05:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:06:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:07:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:08:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:09:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:10:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:11:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:12:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:13:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:14:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:15:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:16:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:17:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:18:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:19:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:20:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:21:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:22:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:23:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:24:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:25:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:26:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:27:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.305 DEBG ==> QTime("01:28:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:29:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:30:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:31:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:32:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:33:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:34:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:35:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:36:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:37:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:38:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:39:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:40:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:41:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:42:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:43:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:44:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:45:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:46:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:47:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:48:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:49:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:50:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:51:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.306 DEBG ==> QTime("01:52:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("01:53:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("01:54:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("01:55:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("01:56:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("01:57:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("01:58:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("01:59:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:00:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:01:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:02:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:03:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:04:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:05:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:06:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:07:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:08:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:09:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:10:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:11:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:12:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:13:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:14:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:15:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.307 DEBG ==> QTime("02:16:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:17:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:18:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:19:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:20:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:21:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:22:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:23:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:24:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:25:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:26:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:27:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:28:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:29:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:30:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:31:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:32:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:33:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:34:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:35:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:36:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:37:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:38:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.308 DEBG ==> QTime("02:39:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:40:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:41:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:42:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:43:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:44:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:45:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:46:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:47:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:48:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:49:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:50:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:51:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:52:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:53:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:54:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:55:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:56:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:57:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.309 DEBG ==> QTime("02:58:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("02:59:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:00:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:01:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:02:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:03:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:04:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:05:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:06:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:07:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:08:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:09:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:10:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:11:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:12:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:13:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:14:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:15:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:16:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:17:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:18:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:19:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.310 DEBG ==> QTime("03:20:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:21:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:22:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:23:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:24:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:25:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:26:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:27:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:28:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:29:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:30:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:31:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:32:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:33:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:34:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:35:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:36:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:37:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:38:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:39:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:40:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:41:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:42:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.311 DEBG ==> QTime("03:43:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:44:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:45:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:46:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:47:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:48:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:49:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:50:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:51:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:52:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:53:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:54:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:55:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:56:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:57:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:58:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("03:59:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("04:00:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("04:01:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("04:02:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("04:03:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("04:04:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("04:05:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.312 DEBG ==> QTime("04:06:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:07:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:08:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:09:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:10:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:11:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:12:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:13:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:14:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:15:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:16:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:17:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:18:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:19:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:20:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:21:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:22:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:23:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:24:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:25:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:26:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:27:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:28:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.313 DEBG ==> QTime("04:29:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:30:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:31:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:32:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:33:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:34:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:35:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:36:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:37:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:38:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:39:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:40:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:41:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:42:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:43:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:44:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:45:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:46:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:47:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:48:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:49:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:50:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:51:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.314 DEBG ==> QTime("04:52:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("04:53:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("04:54:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("04:55:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("04:56:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("04:57:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("04:58:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("04:59:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:00:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:01:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:02:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:03:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:04:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:05:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:06:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:07:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:08:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:09:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:10:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:11:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:12:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:13:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:14:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.315 DEBG ==> QTime("05:15:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:16:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:17:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:18:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:19:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:20:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:21:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:22:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:23:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:24:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:25:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:26:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:27:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:28:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:29:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:30:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:31:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:32:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:33:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:34:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:35:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:36:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:37:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.316 DEBG ==> QTime("05:38:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:39:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:40:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:41:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:42:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:43:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:44:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:45:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:46:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:47:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:48:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:49:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:50:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:51:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:52:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:53:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:54:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:55:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:56:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:57:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:58:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("05:59:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("06:00:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("06:01:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.317 DEBG ==> QTime("06:02:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:03:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:04:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:05:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:06:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:07:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:08:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:09:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:10:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:11:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:12:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:13:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:14:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:15:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:16:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:17:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:18:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:19:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:20:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:21:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:22:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:23:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:24:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.318 DEBG ==> QTime("06:25:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:26:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:27:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:28:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:29:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:30:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:31:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:32:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:33:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:34:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:35:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:36:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:37:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:38:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:39:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:40:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:41:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:42:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:43:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:44:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:45:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:46:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.319 DEBG ==> QTime("06:47:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:48:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:49:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:50:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:51:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:52:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:53:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:54:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:55:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:56:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:57:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:58:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("06:59:00.000") QDateTime(2023-01-07 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:00:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:01:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:02:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:03:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:04:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:05:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:06:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:07:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:08:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.320 DEBG ==> QTime("07:09:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:10:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:11:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:12:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:13:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:14:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:15:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:16:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:17:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:18:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:19:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:20:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:21:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:22:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:23:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:24:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:25:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:26:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:27:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:28:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:29:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:30:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.321 DEBG ==> QTime("07:31:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:32:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:33:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:34:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:35:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:36:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:37:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:38:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:39:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:40:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:41:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:42:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:43:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:44:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:45:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:46:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:47:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:48:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:49:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:50:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:51:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:52:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.322 DEBG ==> QTime("07:53:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("07:54:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("07:55:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("07:56:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("07:57:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("07:58:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("07:59:00.000") QDateTime(2023-01-07 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:00:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:01:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:02:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:03:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:04:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:05:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:06:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:07:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:08:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:09:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:10:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:11:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:12:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:13:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.323 DEBG ==> QTime("08:14:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:15:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:16:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:17:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:18:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:19:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:20:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:21:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:22:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:23:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:24:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:25:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:26:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:27:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:28:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:29:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:30:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:31:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:32:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:33:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:34:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.324 DEBG ==> QTime("08:35:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:36:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:37:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:38:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:39:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:40:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:41:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:42:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:43:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:44:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:45:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:46:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:47:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:48:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:49:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:50:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:51:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:52:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:53:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:54:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:55:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.325 DEBG ==> QTime("08:56:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("08:57:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("08:58:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("08:59:00.000") QDateTime(2023-01-07 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:00:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:01:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:02:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:03:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:04:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:05:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:06:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:07:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:08:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:09:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:10:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:11:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:12:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.326 DEBG ==> QTime("09:13:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:14:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:15:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:16:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:17:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:18:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:19:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:20:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:21:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:22:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:23:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:24:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:25:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:26:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.327 DEBG ==> QTime("09:27:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:28:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:29:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:30:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:31:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:32:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:33:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:34:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:35:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:36:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:37:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:38:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:39:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:40:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.328 DEBG ==> QTime("09:41:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:42:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:43:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:44:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:45:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:46:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:47:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:48:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:49:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:50:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:51:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:52:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:53:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:54:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.329 DEBG ==> QTime("09:55:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("09:56:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("09:57:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("09:58:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("09:59:00.000") QDateTime(2023-01-07 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:00:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:01:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:02:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:03:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:04:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:05:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:06:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:07:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:08:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.330 DEBG ==> QTime("10:09:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:10:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:11:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:12:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:13:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:14:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:15:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:16:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:17:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:18:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:19:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:20:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:21:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:22:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.331 DEBG ==> QTime("10:23:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:24:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:25:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:26:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:27:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:28:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:29:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:30:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:31:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:32:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:33:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:34:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:35:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:36:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.332 DEBG ==> QTime("10:37:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:38:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:39:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:40:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:41:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:42:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:43:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:44:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:45:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:46:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:47:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:48:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:49:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:50:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:51:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.333 DEBG ==> QTime("10:52:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("10:53:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("10:54:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("10:55:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("10:56:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("10:57:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("10:58:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("10:59:00.000") QDateTime(2023-01-07 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("11:00:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("11:01:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("11:02:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("11:03:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("11:04:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("11:05:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.334 DEBG ==> QTime("11:06:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:07:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:08:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:09:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:10:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:11:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:12:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:13:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:14:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:15:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:16:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:17:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:18:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:19:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.335 DEBG ==> QTime("11:20:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:21:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:22:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:23:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:24:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:25:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:26:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:27:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:28:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:29:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:30:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:31:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:32:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:33:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.336 DEBG ==> QTime("11:34:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:35:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:36:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:37:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:38:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:39:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:40:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:41:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:42:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:43:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:44:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:45:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:46:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:47:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.337 DEBG ==> QTime("11:48:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:49:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:50:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:51:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:52:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:53:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:54:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:55:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:56:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:57:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:58:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("11:59:00.000") QDateTime(2023-01-07 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("12:00:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("12:01:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.338 DEBG ==> QTime("12:02:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:03:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:04:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:05:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:06:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:07:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:08:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:09:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:10:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:11:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:12:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:13:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:14:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:15:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.339 DEBG ==> QTime("12:16:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:17:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:18:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:19:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:20:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:21:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:22:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:23:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:24:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:25:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:26:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:27:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:28:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:29:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.340 DEBG ==> QTime("12:30:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:31:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:32:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:33:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:34:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:35:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:36:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:37:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:38:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:39:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:40:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:41:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:42:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:43:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.341 DEBG ==> QTime("12:44:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:45:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:46:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:47:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:48:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:49:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:50:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:51:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:52:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:53:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:54:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:55:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:56:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:57:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.342 DEBG ==> QTime("12:58:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("12:59:00.000") QDateTime(2023-01-07 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:00:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:01:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:02:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:03:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:04:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:05:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:06:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:07:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:08:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:09:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:10:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:11:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.343 DEBG ==> QTime("13:12:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:13:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:14:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:15:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:16:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:17:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:18:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:19:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:20:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:21:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:22:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:23:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:24:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:25:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:26:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:27:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:28:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:29:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:30:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:31:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:32:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.344 DEBG ==> QTime("13:33:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:34:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:35:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:36:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:37:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:38:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:39:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:40:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:41:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:42:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:43:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:44:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:45:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:46:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:47:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:48:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:49:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:50:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:51:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:52:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:53:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:54:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.345 DEBG ==> QTime("13:55:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("13:56:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("13:57:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("13:58:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("13:59:00.000") QDateTime(2023-01-07 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:00:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:01:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:02:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:03:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:04:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:05:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:06:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:07:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:08:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:09:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:10:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:11:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:12:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:13:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:14:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:15:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:16:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:17:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.346 DEBG ==> QTime("14:18:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:19:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:20:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:21:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:22:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:23:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:24:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:25:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:26:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:27:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:28:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:29:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:30:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:31:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:32:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:33:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:34:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:35:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:36:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:37:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:38:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:39:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.347 DEBG ==> QTime("14:40:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:41:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:42:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:43:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:44:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:45:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:46:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:47:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:48:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:49:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:50:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:51:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:52:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:53:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:54:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:55:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:56:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:57:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:58:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("14:59:00.000") QDateTime(2023-01-07 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("15:00:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("15:01:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.348 DEBG ==> QTime("15:02:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:03:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:04:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:05:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:06:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:07:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:08:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:09:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:10:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:11:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:12:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:13:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:14:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:15:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:16:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:17:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:18:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:19:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:20:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:21:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:22:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:23:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.349 DEBG ==> QTime("15:24:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:25:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:26:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:27:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:28:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:29:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:30:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:31:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:32:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:33:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:34:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:35:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:36:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:37:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:38:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:39:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:40:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:41:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:42:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:43:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:44:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:45:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:46:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.350 DEBG ==> QTime("15:47:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:48:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:49:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:50:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:51:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:52:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:53:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:54:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:55:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:56:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:57:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:58:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("15:59:00.000") QDateTime(2023-01-07 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("16:00:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("16:01:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("16:02:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("16:03:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("16:04:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("16:05:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.351 DEBG ==> QTime("16:06:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:07:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:08:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:09:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:10:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:11:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:12:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:13:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:14:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:15:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:16:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:17:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:18:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:19:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:20:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:21:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:22:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:23:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:24:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:25:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:26:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:27:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.352 DEBG ==> QTime("16:28:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:29:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:30:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:31:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:32:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:33:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:34:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:35:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:36:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:37:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:38:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:39:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:40:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:41:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:42:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:43:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:44:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:45:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:46:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:47:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:48:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:49:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.353 DEBG ==> QTime("16:50:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:51:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:52:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:53:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:54:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:55:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:56:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:57:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:58:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("16:59:00.000") QDateTime(2023-01-07 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:00:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:01:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:02:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:03:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:04:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:05:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:06:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:07:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:08:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:09:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:10:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:11:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:12:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.354 DEBG ==> QTime("17:13:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:14:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:15:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:16:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:17:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:18:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:19:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:20:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:21:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:22:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:23:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:24:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:25:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:26:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:27:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:28:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:29:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:30:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:31:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:32:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:33:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:34:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.355 DEBG ==> QTime("17:35:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:36:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:37:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:38:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:39:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:40:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:41:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:42:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:43:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:44:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:45:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:46:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:47:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:48:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:49:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:50:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:51:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:52:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:53:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:54:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:55:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:56:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.356 DEBG ==> QTime("17:57:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("17:58:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("17:59:00.000") QDateTime(2023-01-07 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:00:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:01:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:02:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:03:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:04:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:05:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:06:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:07:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:08:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:09:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:10:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:11:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:12:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:13:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:14:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:15:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:16:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:17:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.357 DEBG ==> QTime("18:18:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:19:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:20:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:21:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:22:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:23:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:24:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:25:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:26:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:27:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:28:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:29:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:30:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:31:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:32:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:33:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:34:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:35:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:36:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:37:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:38:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.358 DEBG ==> QTime("18:39:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:40:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:41:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:42:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:43:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:44:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:45:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:46:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:47:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:48:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:49:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:50:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:51:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:52:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:53:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:54:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:55:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:56:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:57:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.359 DEBG ==> QTime("18:58:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("18:59:00.000") QDateTime(2023-01-07 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:00:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:01:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:02:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:03:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:04:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:05:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:06:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:07:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:08:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:09:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:10:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:11:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:12:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:13:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:14:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:15:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:16:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.360 DEBG ==> QTime("19:17:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:18:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:19:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:20:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:21:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:22:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:23:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:24:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:25:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:26:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:27:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:28:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:29:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:30:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:31:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:32:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:33:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:34:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:35:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:36:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:37:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.361 DEBG ==> QTime("19:38:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:39:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:40:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:41:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:42:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:43:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:44:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:45:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:46:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:47:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:48:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:49:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:50:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:51:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:52:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:53:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:54:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:55:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:56:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:57:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:58:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.362 DEBG ==> QTime("19:59:00.000") QDateTime(2023-01-07 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:00:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:01:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:02:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:03:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:04:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:05:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:06:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:07:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:08:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:09:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:10:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:11:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:12:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:13:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:14:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:15:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:16:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:17:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:18:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:19:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:20:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.363 DEBG ==> QTime("20:21:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:22:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:23:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:24:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:25:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:26:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:27:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:28:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:29:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:30:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:31:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:32:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:33:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:34:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:35:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:36:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:37:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:38:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:39:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:40:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:41:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.364 DEBG ==> QTime("20:42:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:43:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:44:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:45:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:46:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:47:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:48:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:49:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:50:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:51:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:52:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:53:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:54:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:55:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:56:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:57:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:58:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("20:59:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("21:00:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("21:01:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("21:02:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.365 DEBG ==> QTime("21:03:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:04:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:05:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:06:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:07:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:08:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:09:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:10:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:11:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:12:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:13:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:14:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:15:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:16:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:17:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:18:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:19:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:20:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:21:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:22:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:23:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.366 DEBG ==> QTime("21:24:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:25:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:26:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:27:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:28:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:29:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:30:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:31:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:32:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:33:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:34:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:35:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:36:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:37:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:38:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:39:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:40:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:41:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:42:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.367 DEBG ==> QTime("21:43:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:44:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:45:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:46:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:47:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:48:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:49:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:50:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:51:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:52:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:53:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:54:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:55:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:56:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:57:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:58:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("21:59:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("22:00:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("22:01:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("22:02:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("22:03:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("22:04:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.368 DEBG ==> QTime("22:05:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:06:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:07:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:08:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:09:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:10:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:11:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:12:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:13:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:14:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:15:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:16:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:17:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:18:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:19:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:20:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:21:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:22:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:23:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:24:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:25:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:26:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.369 DEBG ==> QTime("22:27:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:28:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:29:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:30:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:31:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:32:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:33:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:34:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:35:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:36:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:37:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:38:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:39:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:40:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:41:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:42:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:43:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:44:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:45:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:46:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:47:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:48:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.370 DEBG ==> QTime("22:49:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:50:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:51:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:52:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:53:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:54:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:55:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:56:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:57:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:58:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("22:59:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:00:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:01:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:02:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:03:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:04:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:05:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:06:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:07:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:08:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:09:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:10:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.371 DEBG ==> QTime("23:11:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:12:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:13:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:14:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:15:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:16:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:17:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:18:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:19:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:20:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:21:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:22:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:23:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:24:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:25:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:26:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:27:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:28:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:29:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:30:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:31:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:32:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.372 DEBG ==> QTime("23:33:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:34:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:35:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:36:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:37:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:38:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:39:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:40:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:41:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:42:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:43:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:44:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:45:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:46:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:47:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:48:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:49:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:50:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:51:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:52:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:53:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:54:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:55:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.373 DEBG ==> QTime("23:56:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("23:57:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("23:58:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("23:59:00.000") QDateTime(2023-01-07 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG 4 7 *** + (main.cpp:123) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:00:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:01:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:02:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:03:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:04:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:05:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:06:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:07:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:08:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:09:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:10:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:11:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:12:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.374 DEBG ==> QTime("00:13:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:14:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:15:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:16:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:17:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:18:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:19:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:20:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:21:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:22:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:23:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:24:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:25:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:26:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.375 DEBG ==> QTime("00:27:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:28:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:29:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:30:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:31:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:32:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:33:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:34:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:35:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:36:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:37:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:38:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:39:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:40:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:41:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:42:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:43:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:44:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:45:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:46:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:47:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:48:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:49:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.376 DEBG ==> QTime("00:50:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:51:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:52:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:53:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:54:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:55:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:56:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:57:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:58:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("00:59:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:00:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:01:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:02:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:03:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:04:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:05:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:06:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:07:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:08:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:09:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:10:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:11:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.377 DEBG ==> QTime("01:12:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:13:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:14:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:15:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:16:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:17:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:18:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:19:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:20:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:21:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:22:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:23:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:24:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:25:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:26:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:27:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:28:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:29:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:30:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:31:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:32:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:33:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:34:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:35:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.378 DEBG ==> QTime("01:36:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:37:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:38:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:39:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:40:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:41:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:42:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:43:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:44:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:45:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:46:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:47:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:48:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:49:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:50:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:51:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:52:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:53:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:54:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:55:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:56:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:57:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:58:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("01:59:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.379 DEBG ==> QTime("02:00:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:01:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:02:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:03:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:04:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:05:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:06:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:07:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:08:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:09:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:10:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:11:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:12:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:13:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:14:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:15:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:16:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:17:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:18:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:19:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:20:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:21:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:22:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:23:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.380 DEBG ==> QTime("02:24:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:25:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:26:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:27:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:28:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:29:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:30:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:31:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:32:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:33:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:34:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:35:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:36:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:37:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:38:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:39:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:40:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:41:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:42:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:43:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:44:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:45:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:46:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:47:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.381 DEBG ==> QTime("02:48:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:49:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:50:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:51:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:52:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:53:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:54:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:55:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:56:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:57:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:58:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("02:59:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:00:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:01:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:02:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:03:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:04:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:05:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:06:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:07:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:08:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:09:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:10:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:11:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:12:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.382 DEBG ==> QTime("03:13:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:14:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:15:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:16:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:17:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:18:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:19:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:20:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:21:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:22:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:23:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:24:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:25:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:26:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:27:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:28:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:29:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:30:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:31:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:32:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:33:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:34:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:35:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.383 DEBG ==> QTime("03:36:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:37:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:38:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:39:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:40:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:41:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:42:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:43:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:44:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:45:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:46:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:47:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:48:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:49:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:50:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:51:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:52:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:53:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:54:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:55:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:56:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:57:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:58:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("03:59:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.384 DEBG ==> QTime("04:00:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:01:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:02:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:03:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:04:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:05:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:06:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:07:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:08:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:09:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:10:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:11:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:12:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:13:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:14:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:15:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:16:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:17:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:18:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:19:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:20:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:21:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:22:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:23:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.385 DEBG ==> QTime("04:24:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:25:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:26:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:27:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:28:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:29:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:30:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:31:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:32:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:33:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:34:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:35:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:36:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:37:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:38:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:39:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:40:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:41:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:42:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:43:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:44:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:45:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:46:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:47:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.386 DEBG ==> QTime("04:48:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:49:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:50:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:51:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:52:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:53:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:54:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:55:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:56:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:57:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:58:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("04:59:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:00:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:01:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:02:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:03:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:04:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:05:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:06:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:07:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:08:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:09:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:10:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:11:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.387 DEBG ==> QTime("05:12:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:13:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:14:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:15:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:16:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:17:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:18:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:19:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:20:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:21:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:22:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:23:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:24:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:25:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:26:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:27:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:28:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:29:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:30:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:31:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:32:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:33:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:34:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:35:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.388 DEBG ==> QTime("05:36:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:37:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:38:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:39:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:40:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:41:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:42:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:43:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:44:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:45:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:46:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:47:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:48:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:49:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:50:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:51:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:52:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:53:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:54:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:55:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:56:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:57:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:58:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("05:59:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.389 DEBG ==> QTime("06:00:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:01:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:02:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:03:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:04:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:05:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:06:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:07:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:08:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:09:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:10:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:11:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:12:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:13:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:14:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:15:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:16:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:17:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:18:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:19:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:20:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:21:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:22:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:23:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:24:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.390 DEBG ==> QTime("06:25:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:26:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:27:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:28:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:29:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:30:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:31:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:32:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:33:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:34:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:35:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:36:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:37:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:38:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:39:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:40:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:41:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:42:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:43:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:44:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:45:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:46:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.391 DEBG ==> QTime("06:47:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:48:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:49:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:50:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:51:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:52:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:53:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:54:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:55:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:56:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:57:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:58:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("06:59:00.000") QDateTime(2023-01-08 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("07:00:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("07:01:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("07:02:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("07:03:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("07:04:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.392 DEBG ==> QTime("07:05:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:06:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:07:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:08:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:09:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:10:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:11:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:12:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:13:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:14:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:15:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:16:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:17:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:18:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:19:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:20:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:21:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:22:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:23:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:24:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:25:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.393 DEBG ==> QTime("07:26:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:27:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:28:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:29:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:30:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:31:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:32:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:33:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:34:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:35:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:36:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:37:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:38:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:39:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:40:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:41:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:42:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:43:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:44:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:45:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:46:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:47:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.394 DEBG ==> QTime("07:48:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:49:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:50:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:51:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:52:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:53:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:54:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:55:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:56:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:57:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:58:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("07:59:00.000") QDateTime(2023-01-08 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:00:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:01:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:02:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:03:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:04:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:05:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:06:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:07:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:08:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:09:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.395 DEBG ==> QTime("08:10:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:11:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:12:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:13:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:14:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:15:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:16:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:17:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:18:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:19:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:20:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:21:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:22:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:23:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:24:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:25:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:26:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:27:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:28:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:29:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:30:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:31:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:32:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.396 DEBG ==> QTime("08:33:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:34:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:35:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:36:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:37:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:38:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:39:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:40:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:41:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:42:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:43:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:44:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:45:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:46:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:47:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:48:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:49:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:50:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:51:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:52:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:53:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:54:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.397 DEBG ==> QTime("08:55:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("08:56:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("08:57:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("08:58:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("08:59:00.000") QDateTime(2023-01-08 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:00:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:01:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:02:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:03:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:04:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:05:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:06:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:07:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:08:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:09:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:10:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:11:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:12:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:13:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:14:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:15:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:16:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:17:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.398 DEBG ==> QTime("09:18:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:19:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:20:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:21:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:22:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:23:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:24:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:25:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:26:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:27:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:28:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:29:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:30:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:31:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:32:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:33:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:34:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:35:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:36:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.399 DEBG ==> QTime("09:37:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:38:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:39:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:40:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:41:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:42:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:43:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:44:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:45:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:46:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:47:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:48:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:49:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:50:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:51:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:52:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:53:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:54:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:55:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:56:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:57:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:58:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.400 DEBG ==> QTime("09:59:00.000") QDateTime(2023-01-08 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:00:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:01:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:02:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:03:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:04:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:05:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:06:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:07:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:08:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:09:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:10:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:11:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:12:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:13:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:14:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:15:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:16:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:17:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:18:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:19:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:20:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.401 DEBG ==> QTime("10:21:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:22:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:23:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:24:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:25:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:26:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:27:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:28:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:29:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:30:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:31:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:32:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:33:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.402 DEBG ==> QTime("10:34:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:35:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:36:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:37:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:38:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:39:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:40:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:41:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:42:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:43:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:44:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:45:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:46:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:47:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.403 DEBG ==> QTime("10:48:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:49:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:50:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:51:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:52:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:53:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:54:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:55:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:56:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:57:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:58:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("10:59:00.000") QDateTime(2023-01-08 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("11:00:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("11:01:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.404 DEBG ==> QTime("11:02:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:03:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:04:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:05:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:06:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:07:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:08:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:09:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:10:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:11:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:12:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:13:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:14:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:15:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:16:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.405 DEBG ==> QTime("11:17:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:18:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:19:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:20:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:21:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:22:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:23:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:24:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:25:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:26:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:27:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:28:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:29:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:30:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.406 DEBG ==> QTime("11:31:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:32:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:33:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:34:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:35:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:36:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:37:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:38:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:39:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:40:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:41:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:42:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:43:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:44:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.407 DEBG ==> QTime("11:45:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:46:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:47:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:48:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:49:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:50:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:51:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:52:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:53:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:54:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:55:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:56:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:57:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:58:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.408 DEBG ==> QTime("11:59:00.000") QDateTime(2023-01-08 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:00:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:01:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:02:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:03:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:04:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:05:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:06:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:07:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:08:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:09:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:10:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:11:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:12:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.409 DEBG ==> QTime("12:13:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:14:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:15:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:16:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:17:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:18:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:19:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:20:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:21:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:22:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:23:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:24:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:25:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:26:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.410 DEBG ==> QTime("12:27:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:28:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:29:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:30:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:31:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:32:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:33:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:34:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:35:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:36:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:37:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:38:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:39:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:40:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.411 DEBG ==> QTime("12:41:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:42:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:43:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:44:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:45:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:46:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:47:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:48:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:49:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:50:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:51:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:52:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:53:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:54:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:55:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.412 DEBG ==> QTime("12:56:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("12:57:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("12:58:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("12:59:00.000") QDateTime(2023-01-08 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:00:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:01:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:02:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:03:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:04:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:05:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:06:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:07:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:08:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.413 DEBG ==> QTime("13:09:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:10:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:11:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:12:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:13:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:14:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:15:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:16:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:17:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:18:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:19:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:20:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:21:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:22:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:23:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.414 DEBG ==> QTime("13:24:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:25:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:26:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:27:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:28:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:29:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:30:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:31:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:32:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:33:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:34:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:35:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:36:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:37:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:38:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.415 DEBG ==> QTime("13:39:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:40:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:41:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:42:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:43:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:44:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:45:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:46:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:47:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:48:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:49:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:50:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:51:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:52:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.416 DEBG ==> QTime("13:53:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("13:54:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("13:55:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("13:56:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("13:57:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("13:58:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("13:59:00.000") QDateTime(2023-01-08 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:00:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:01:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:02:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:03:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:04:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:05:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:06:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.417 DEBG ==> QTime("14:07:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:08:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:09:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:10:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:11:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:12:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:13:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:14:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:15:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:16:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:17:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:18:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:19:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:20:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.418 DEBG ==> QTime("14:21:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:22:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:23:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:24:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:25:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:26:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:27:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:28:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:29:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:30:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:31:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:32:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:33:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:34:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.419 DEBG ==> QTime("14:35:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:36:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:37:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:38:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:39:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:40:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:41:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:42:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:43:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:44:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:45:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:46:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:47:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:48:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.420 DEBG ==> QTime("14:49:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:50:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:51:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:52:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:53:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:54:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:55:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:56:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:57:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:58:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("14:59:00.000") QDateTime(2023-01-08 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("15:00:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("15:01:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("15:02:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.421 DEBG ==> QTime("15:03:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:04:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:05:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:06:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:07:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:08:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:09:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:10:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:11:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:12:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:13:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:14:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:15:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:16:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.422 DEBG ==> QTime("15:17:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:18:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:19:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:20:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:21:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:22:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:23:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:24:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:25:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:26:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:27:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:28:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:29:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:30:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.423 DEBG ==> QTime("15:31:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:32:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:33:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:34:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:35:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:36:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:37:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:38:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:39:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:40:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:41:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:42:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:43:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:44:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.424 DEBG ==> QTime("15:45:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:46:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:47:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:48:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:49:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:50:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:51:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:52:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:53:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:54:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:55:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:56:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:57:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:58:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.425 DEBG ==> QTime("15:59:00.000") QDateTime(2023-01-08 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:00:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:01:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:02:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:03:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:04:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:05:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:06:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:07:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:08:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:09:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:10:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:11:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:12:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.426 DEBG ==> QTime("16:13:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:14:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:15:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:16:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:17:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:18:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:19:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:20:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:21:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:22:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:23:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:24:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:25:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.427 DEBG ==> QTime("16:26:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:27:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:28:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:29:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:30:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:31:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:32:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:33:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:34:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:35:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:36:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:37:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:38:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:39:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:40:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.428 DEBG ==> QTime("16:41:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:42:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:43:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:44:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:45:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:46:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:47:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:48:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:49:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:50:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:51:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:52:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:53:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.429 DEBG ==> QTime("16:54:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("16:55:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("16:56:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("16:57:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("16:58:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("16:59:00.000") QDateTime(2023-01-08 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:00:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:01:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:02:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:03:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:04:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:05:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:06:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:07:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:08:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.430 DEBG ==> QTime("17:09:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:10:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:11:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:12:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:13:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:14:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:15:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:16:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:17:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:18:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:19:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:20:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:21:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:22:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.431 DEBG ==> QTime("17:23:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:24:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:25:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:26:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:27:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:28:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:29:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:30:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:31:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:32:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:33:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:34:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:35:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.432 DEBG ==> QTime("17:36:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:37:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:38:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:39:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:40:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:41:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:42:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:43:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:44:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:45:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:46:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:47:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:48:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:49:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:50:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.433 DEBG ==> QTime("17:51:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:52:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:53:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:54:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:55:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:56:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:57:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:58:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("17:59:00.000") QDateTime(2023-01-08 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("18:00:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("18:01:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("18:02:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("18:03:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.434 DEBG ==> QTime("18:04:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:05:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:06:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:07:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:08:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:09:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:10:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:11:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:12:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:13:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:14:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:15:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:16:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:17:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.435 DEBG ==> QTime("18:18:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:19:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:20:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:21:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:22:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:23:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:24:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:25:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:26:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:27:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:28:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:29:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:30:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:31:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.436 DEBG ==> QTime("18:32:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:33:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:34:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:35:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:36:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:37:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:38:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:39:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:40:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:41:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:42:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:43:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:44:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:45:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.437 DEBG ==> QTime("18:46:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:47:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:48:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:49:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:50:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:51:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:52:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:53:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:54:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:55:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:56:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:57:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:58:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("18:59:00.000") QDateTime(2023-01-08 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.438 DEBG ==> QTime("19:00:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:01:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:02:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:03:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:04:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:05:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:06:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:07:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:08:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:09:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:10:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:11:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:12:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:13:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.439 DEBG ==> QTime("19:14:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:15:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:16:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:17:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:18:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:19:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:20:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:21:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:22:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:23:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:24:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:25:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:26:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:27:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.440 DEBG ==> QTime("19:28:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:29:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:30:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:31:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:32:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:33:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:34:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:35:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:36:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:37:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:38:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:39:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:40:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:41:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.441 DEBG ==> QTime("19:42:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:43:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:44:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:45:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:46:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:47:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:48:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:49:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:50:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:51:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:52:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:53:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:54:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:55:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.442 DEBG ==> QTime("19:56:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("19:57:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("19:58:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("19:59:00.000") QDateTime(2023-01-08 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + + XXX fehler beim umschalten von sonntag auf montag!!! + + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:00:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:01:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:02:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:03:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:04:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:05:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:06:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:07:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:08:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:09:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.443 DEBG ==> QTime("20:10:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:11:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:12:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:13:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:14:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:15:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:16:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:17:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:18:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:19:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:20:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:21:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:22:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:23:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.444 DEBG ==> QTime("20:24:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:25:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:26:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:27:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:28:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:29:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:30:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:31:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:32:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:33:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:34:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:35:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:36:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:37:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.445 DEBG ==> QTime("20:38:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:39:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:40:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:41:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:42:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:43:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:44:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:45:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:46:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:47:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:48:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:49:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:50:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.446 DEBG ==> QTime("20:51:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:52:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:53:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:54:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:55:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:56:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:57:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:58:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("20:59:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("21:00:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("21:01:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("21:02:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("21:03:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("21:04:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.447 DEBG ==> QTime("21:05:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:06:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:07:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:08:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:09:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:10:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:11:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:12:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:13:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:14:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:15:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:16:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:17:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:18:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.448 DEBG ==> QTime("21:19:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:20:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:21:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:22:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:23:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:24:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:25:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:26:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:27:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:28:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:29:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:30:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:31:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:32:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.449 DEBG ==> QTime("21:33:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:34:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:35:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:36:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:37:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:38:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:39:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:40:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:41:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:42:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:43:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:44:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:45:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:46:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.450 DEBG ==> QTime("21:47:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:48:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:49:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:50:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:51:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:52:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:53:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:54:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:55:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:56:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:57:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:58:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("21:59:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("22:00:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("22:01:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.451 DEBG ==> QTime("22:02:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:03:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:04:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:05:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:06:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:07:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:08:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:09:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:10:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:11:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:12:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:13:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:14:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:15:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.452 DEBG ==> QTime("22:16:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:17:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:18:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:19:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:20:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:21:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:22:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:23:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:24:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:25:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:26:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:27:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:28:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:29:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.453 DEBG ==> QTime("22:30:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:31:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:32:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:33:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:34:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:35:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:36:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:37:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:38:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:39:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:40:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:41:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:42:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:43:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.454 DEBG ==> QTime("22:44:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:45:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:46:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:47:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:48:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:49:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:50:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:51:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:52:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:53:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:54:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:55:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:56:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.455 DEBG ==> QTime("22:57:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("22:58:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("22:59:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:00:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:01:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:02:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:03:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:04:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:05:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:06:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:07:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:08:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:09:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:10:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.456 DEBG ==> QTime("23:11:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:12:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:13:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:14:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:15:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:16:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:17:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:18:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:19:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:20:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:21:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:22:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:23:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.457 DEBG ==> QTime("23:24:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:25:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:26:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:27:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:28:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:29:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:30:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:31:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:32:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:33:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:34:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:35:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:36:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:37:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:38:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.458 DEBG ==> QTime("23:39:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:40:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:41:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:42:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:43:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:44:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:45:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:46:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:47:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:48:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:49:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:50:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:51:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.459 DEBG ==> QTime("23:52:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("23:53:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("23:54:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("23:55:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("23:56:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("23:57:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("23:58:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("23:59:00.000") QDateTime(2023-01-08 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG 5 1 *** + (main.cpp:123) + 04.01.2023 08:22:03.460 DEBG ==> QTime("00:00:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("00:01:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("00:02:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("00:03:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("00:04:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("00:05:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.460 DEBG ==> QTime("00:06:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:07:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:08:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:09:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:10:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:11:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:12:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:13:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:14:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:15:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:16:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:17:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:18:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:19:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:20:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:21:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.461 DEBG ==> QTime("00:22:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:23:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:24:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:25:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:26:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:27:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:28:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:29:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:30:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:31:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:32:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:33:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:34:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:35:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:36:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:37:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:38:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:39:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:40:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:41:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:42:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:43:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:44:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:45:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.462 DEBG ==> QTime("00:46:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:47:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:48:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:49:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:50:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:51:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:52:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:53:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:54:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:55:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:56:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:57:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:58:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("00:59:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:00:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:01:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:02:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:03:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:04:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:05:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:06:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:07:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:08:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:09:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.463 DEBG ==> QTime("01:10:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:11:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:12:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:13:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:14:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:15:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:16:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:17:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:18:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:19:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:20:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:21:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:22:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:23:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:24:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:25:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:26:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:27:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:28:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:29:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:30:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:31:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:32:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:33:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.464 DEBG ==> QTime("01:34:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:35:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:36:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:37:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:38:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:39:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:40:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:41:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:42:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:43:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:44:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:45:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:46:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:47:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:48:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:49:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:50:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:51:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:52:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:53:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:54:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:55:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:56:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:57:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.465 DEBG ==> QTime("01:58:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("01:59:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:00:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:01:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:02:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:03:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:04:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:05:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:06:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:07:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:08:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:09:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:10:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:11:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:12:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:13:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:14:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:15:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:16:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:17:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:18:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:19:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:20:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:21:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.466 DEBG ==> QTime("02:22:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:23:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:24:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:25:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:26:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:27:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:28:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:29:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:30:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:31:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:32:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:33:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:34:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:35:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:36:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:37:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:38:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:39:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:40:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:41:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:42:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:43:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:44:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:45:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.467 DEBG ==> QTime("02:46:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:47:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:48:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:49:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:50:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:51:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:52:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:53:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:54:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:55:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:56:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:57:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:58:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("02:59:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:00:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:01:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:02:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:03:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:04:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:05:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:06:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:07:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:08:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:09:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.468 DEBG ==> QTime("03:10:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:11:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:12:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:13:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:14:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:15:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:16:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:17:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:18:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:19:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:20:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:21:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:22:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:23:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:24:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:25:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:26:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:27:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:28:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:29:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:30:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:31:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:32:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:33:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.469 DEBG ==> QTime("03:34:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:35:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:36:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:37:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:38:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:39:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:40:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:41:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:42:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:43:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:44:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:45:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:46:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:47:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:48:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:49:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:50:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:51:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:52:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:53:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:54:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:55:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:56:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:57:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.470 DEBG ==> QTime("03:58:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("03:59:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:00:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:01:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:02:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:03:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:04:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:05:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:06:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:07:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:08:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:09:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:10:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:11:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:12:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:13:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:14:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:15:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:16:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:17:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:18:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:19:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:20:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:21:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.471 DEBG ==> QTime("04:22:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:23:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:24:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:25:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:26:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:27:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:28:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:29:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:30:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:31:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:32:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:33:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:34:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:35:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:36:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:37:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:38:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:39:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:40:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:41:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:42:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:43:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:44:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:45:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.472 DEBG ==> QTime("04:46:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:47:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:48:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:49:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:50:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:51:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:52:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:53:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:54:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:55:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:56:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:57:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:58:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("04:59:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:00:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:01:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:02:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:03:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:04:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:05:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:06:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:07:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:08:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:09:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.473 DEBG ==> QTime("05:10:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:11:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:12:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:13:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:14:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:15:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:16:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:17:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:18:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:19:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:20:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:21:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:22:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:23:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:24:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:25:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:26:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:27:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:28:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:29:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:30:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:31:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:32:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.474 DEBG ==> QTime("05:33:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:34:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:35:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:36:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:37:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:38:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:39:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:40:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:41:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:42:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:43:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:44:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:45:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:46:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:47:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:48:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:49:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:50:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:51:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:52:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:53:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:54:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.475 DEBG ==> QTime("05:55:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("05:56:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("05:57:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("05:58:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("05:59:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:00:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:01:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:02:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:03:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:04:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:05:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:06:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:07:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:08:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:09:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:10:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:11:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:12:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:13:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:14:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:15:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.476 DEBG ==> QTime("06:16:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:17:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:18:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:19:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:20:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:21:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:22:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:23:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:24:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:25:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:26:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:27:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:28:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:29:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:30:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:31:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:32:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:33:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:34:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:35:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:36:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:37:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.477 DEBG ==> QTime("06:38:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:39:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:40:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:41:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:42:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:43:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:44:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:45:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:46:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:47:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:48:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:49:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:50:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:51:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:52:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:53:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:54:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:55:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:56:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:57:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:58:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("06:59:00.000") QDateTime(2023-01-02 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("07:00:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.478 DEBG ==> QTime("07:01:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:02:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:03:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:04:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:05:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:06:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:07:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:08:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:09:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:10:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:11:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:12:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:13:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:14:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:15:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:16:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:17:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:18:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:19:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:20:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:21:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:22:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.479 DEBG ==> QTime("07:23:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:24:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:25:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:26:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:27:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:28:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:29:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:30:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:31:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:32:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:33:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:34:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:35:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:36:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:37:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:38:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:39:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:40:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:41:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:42:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:43:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.480 DEBG ==> QTime("07:44:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:45:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:46:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:47:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:48:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:49:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:50:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:51:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:52:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:53:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:54:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:55:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:56:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:57:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:58:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("07:59:00.000") QDateTime(2023-01-02 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("08:00:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("08:01:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("08:02:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("08:03:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("08:04:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("08:05:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.481 DEBG ==> QTime("08:06:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:07:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:08:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:09:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:10:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:11:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:12:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:13:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:14:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:15:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:16:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:17:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:18:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:19:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:20:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:21:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:22:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:23:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:24:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:25:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:26:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:27:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.482 DEBG ==> QTime("08:28:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:29:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:30:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:31:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:32:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:33:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:34:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:35:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:36:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:37:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:38:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:39:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:40:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:41:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:42:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:43:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:44:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:45:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:46:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:47:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:48:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.483 DEBG ==> QTime("08:49:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:50:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:51:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:52:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:53:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:54:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:55:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:56:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:57:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:58:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("08:59:00.000") QDateTime(2023-01-02 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:00:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:01:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:02:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:03:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:04:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:05:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:06:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:07:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:08:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:09:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.484 DEBG ==> QTime("09:10:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:11:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:12:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:13:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:14:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:15:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:16:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:17:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:18:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:19:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:20:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:21:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:22:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:23:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:24:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:25:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:26:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:27:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:28:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:29:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:30:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:31:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.485 DEBG ==> QTime("09:32:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:33:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:34:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:35:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:36:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:37:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:38:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:39:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:40:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:41:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:42:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:43:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:44:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:45:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:46:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:47:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:48:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:49:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:50:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:51:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:52:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.486 DEBG ==> QTime("09:53:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("09:54:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("09:55:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("09:56:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("09:57:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("09:58:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("09:59:00.000") QDateTime(2023-01-02 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:00:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:01:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:02:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:03:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:04:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:05:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:06:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:07:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:08:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:09:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:10:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:11:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:12:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:13:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.487 DEBG ==> QTime("10:14:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:15:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:16:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:17:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:18:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:19:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:20:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:21:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:22:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:23:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:24:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:25:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:26:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:27:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:28:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:29:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:30:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:31:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:32:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:33:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:34:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:35:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.488 DEBG ==> QTime("10:36:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:37:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:38:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:39:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:40:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:41:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:42:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:43:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:44:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:45:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:46:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:47:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:48:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:49:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:50:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:51:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:52:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:53:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:54:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:55:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:56:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:57:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.489 DEBG ==> QTime("10:58:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("10:59:00.000") QDateTime(2023-01-02 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:00:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:01:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:02:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:03:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:04:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:05:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:06:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:07:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:08:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:09:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:10:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:11:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:12:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:13:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:14:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:15:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:16:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:17:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:18:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.490 DEBG ==> QTime("11:19:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:20:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:21:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:22:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:23:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:24:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:25:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:26:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:27:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:28:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:29:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:30:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:31:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:32:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:33:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:34:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:35:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:36:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:37:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:38:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:39:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.491 DEBG ==> QTime("11:40:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:41:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:42:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:43:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:44:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:45:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:46:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:47:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:48:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:49:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:50:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:51:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:52:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:53:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:54:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:55:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:56:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:57:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:58:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.492 DEBG ==> QTime("11:59:00.000") QDateTime(2023-01-02 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:00:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:01:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:02:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:03:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:04:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:05:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:06:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:07:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:08:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:09:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:10:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:11:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:12:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.493 DEBG ==> QTime("12:13:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:14:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:15:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:16:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:17:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:18:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:19:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:20:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:21:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:22:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:23:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:24:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:25:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:26:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.494 DEBG ==> QTime("12:27:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:28:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:29:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:30:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:31:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:32:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:33:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:34:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:35:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:36:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:37:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:38:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:39:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:40:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.495 DEBG ==> QTime("12:41:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:42:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:43:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:44:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:45:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:46:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:47:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:48:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:49:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:50:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:51:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:52:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:53:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:54:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.496 DEBG ==> QTime("12:55:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("12:56:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("12:57:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("12:58:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("12:59:00.000") QDateTime(2023-01-02 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:00:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:01:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:02:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:03:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:04:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:05:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:06:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:07:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:08:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.497 DEBG ==> QTime("13:09:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:10:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:11:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:12:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:13:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:14:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:15:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:16:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:17:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:18:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:19:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:20:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:21:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:22:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.498 DEBG ==> QTime("13:23:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:24:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:25:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:26:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:27:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:28:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:29:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:30:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:31:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:32:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:33:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:34:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:35:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:36:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:37:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.499 DEBG ==> QTime("13:38:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:39:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:40:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:41:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:42:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:43:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:44:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:45:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:46:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:47:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:48:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:49:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:50:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:51:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:52:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.500 DEBG ==> QTime("13:53:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("13:54:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("13:55:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("13:56:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("13:57:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("13:58:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("13:59:00.000") QDateTime(2023-01-02 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:00:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:01:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:02:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:03:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:04:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:05:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:06:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.501 DEBG ==> QTime("14:07:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:08:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:09:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:10:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:11:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:12:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:13:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:14:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:15:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:16:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:17:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:18:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:19:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:20:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.502 DEBG ==> QTime("14:21:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:22:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:23:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:24:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:25:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:26:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:27:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:28:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:29:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:30:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:31:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:32:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:33:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.503 DEBG ==> QTime("14:34:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:35:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:36:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:37:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:38:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:39:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:40:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:41:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:42:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:43:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:44:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:45:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:46:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:47:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:48:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.504 DEBG ==> QTime("14:49:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:50:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:51:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:52:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:53:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:54:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:55:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:56:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:57:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:58:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("14:59:00.000") QDateTime(2023-01-02 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("15:00:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("15:01:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("15:02:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.505 DEBG ==> QTime("15:03:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:04:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:05:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:06:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:07:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:08:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:09:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:10:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:11:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:12:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:13:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:14:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:15:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:16:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.506 DEBG ==> QTime("15:17:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:18:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:19:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:20:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:21:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:22:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:23:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:24:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:25:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:26:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:27:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:28:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:29:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:30:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.507 DEBG ==> QTime("15:31:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:32:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:33:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:34:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:35:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:36:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:37:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:38:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:39:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:40:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:41:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:42:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:43:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.508 DEBG ==> QTime("15:44:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:45:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:46:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:47:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:48:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:49:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:50:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:51:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:52:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:53:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:54:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:55:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:56:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:57:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:58:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("15:59:00.000") QDateTime(2023-01-02 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("16:00:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("16:01:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("16:02:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("16:03:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.509 DEBG ==> QTime("16:04:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:05:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:06:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:07:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:08:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:09:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:10:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:11:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:12:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:13:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:14:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:15:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:16:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:17:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:18:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:19:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:20:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:21:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:22:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:23:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:24:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.510 DEBG ==> QTime("16:25:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:26:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:27:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:28:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:29:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:30:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:31:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:32:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:33:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:34:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:35:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:36:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:37:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:38:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:39:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:40:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:41:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:42:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:43:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:44:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.511 DEBG ==> QTime("16:45:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:46:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:47:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:48:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:49:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:50:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:51:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:52:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:53:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:54:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:55:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:56:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:57:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:58:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("16:59:00.000") QDateTime(2023-01-02 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:00:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:01:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:02:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:03:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:04:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:05:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:06:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.512 DEBG ==> QTime("17:07:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:08:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:09:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:10:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:11:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:12:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:13:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:14:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:15:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:16:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:17:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:18:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:19:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:20:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:21:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:22:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:23:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:24:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:25:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:26:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:27:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:28:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.513 DEBG ==> QTime("17:29:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:30:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:31:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:32:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:33:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:34:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:35:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:36:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:37:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:38:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:39:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:40:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:41:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:42:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:43:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:44:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:45:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:46:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:47:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:48:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:49:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:50:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.514 DEBG ==> QTime("17:51:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:52:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:53:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:54:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:55:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:56:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:57:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:58:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("17:59:00.000") QDateTime(2023-01-02 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:00:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:01:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:02:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:03:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:04:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:05:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:06:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:07:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:08:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:09:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:10:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:11:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:12:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.515 DEBG ==> QTime("18:13:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:14:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:15:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:16:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:17:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:18:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:19:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:20:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:21:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:22:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:23:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:24:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:25:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:26:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:27:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:28:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:29:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:30:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:31:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:32:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:33:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:34:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.516 DEBG ==> QTime("18:35:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:36:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:37:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:38:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:39:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:40:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:41:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:42:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:43:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:44:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:45:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:46:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:47:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:48:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:49:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:50:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:51:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:52:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:53:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:54:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:55:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:56:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:57:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.517 DEBG ==> QTime("18:58:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("18:59:00.000") QDateTime(2023-01-02 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:00:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:01:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:02:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:03:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:04:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:05:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:06:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:07:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:08:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:09:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:10:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:11:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:12:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:13:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:14:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:15:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:16:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:17:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:18:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:19:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.518 DEBG ==> QTime("19:20:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:21:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:22:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:23:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:24:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:25:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:26:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:27:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:28:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:29:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:30:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:31:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:32:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:33:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:34:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:35:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:36:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:37:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:38:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:39:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:40:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:41:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.519 DEBG ==> QTime("19:42:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:43:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:44:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:45:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:46:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:47:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:48:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:49:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:50:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:51:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:52:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:53:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:54:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:55:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:56:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:57:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:58:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("19:59:00.000") QDateTime(2023-01-02 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("20:00:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("20:01:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("20:02:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("20:03:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.520 DEBG ==> QTime("20:04:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:05:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:06:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:07:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:08:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:09:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:10:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:11:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:12:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:13:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:14:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:15:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:16:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:17:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:18:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:19:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:20:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:21:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:22:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:23:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:24:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:25:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:26:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.521 DEBG ==> QTime("20:27:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:28:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:29:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:30:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:31:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:32:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:33:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:34:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:35:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:36:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:37:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:38:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:39:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:40:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:41:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:42:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:43:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:44:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:45:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:46:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:47:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:48:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.522 DEBG ==> QTime("20:49:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:50:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:51:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:52:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:53:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:54:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:55:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:56:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:57:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:58:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("20:59:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:00:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:01:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:02:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:03:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:04:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:05:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:06:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:07:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:08:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:09:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:10:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.523 DEBG ==> QTime("21:11:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:12:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:13:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:14:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:15:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:16:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:17:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:18:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:19:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:20:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:21:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:22:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:23:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:24:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:25:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:26:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:27:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:28:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:29:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:30:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:31:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.524 DEBG ==> QTime("21:32:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:33:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:34:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:35:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:36:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:37:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:38:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:39:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:40:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:41:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:42:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:43:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:44:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:45:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:46:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:47:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:48:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:49:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:50:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:51:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.525 DEBG ==> QTime("21:52:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("21:53:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("21:54:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("21:55:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("21:56:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("21:57:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("21:58:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("21:59:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:00:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:01:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:02:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:03:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:04:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:05:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:06:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:07:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:08:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.526 DEBG ==> QTime("22:09:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:10:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:11:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:12:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:13:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:14:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:15:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:16:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:17:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:18:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:19:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:20:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:21:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:22:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:23:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:24:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:25:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:26:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:27:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:28:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:29:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.527 DEBG ==> QTime("22:30:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:31:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:32:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:33:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:34:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:35:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:36:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:37:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:38:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:39:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:40:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:41:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:42:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:43:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:44:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:45:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:46:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:47:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:48:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:49:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:50:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:51:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.528 DEBG ==> QTime("22:52:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("22:53:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("22:54:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("22:55:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("22:56:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("22:57:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("22:58:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("22:59:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:00:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:01:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:02:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:03:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:04:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:05:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:06:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:07:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:08:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:09:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:10:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:11:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:12:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:13:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.529 DEBG ==> QTime("23:14:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:15:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:16:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:17:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:18:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:19:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:20:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:21:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:22:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:23:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:24:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:25:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:26:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:27:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.530 DEBG ==> QTime("23:28:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:29:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:30:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:31:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:32:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:33:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:34:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:35:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:36:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:37:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:38:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:39:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:40:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:41:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:42:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.531 DEBG ==> QTime("23:43:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:44:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:45:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:46:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:47:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:48:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:49:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:50:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:51:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:52:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:53:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:54:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:55:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:56:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.532 DEBG ==> QTime("23:57:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("23:58:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("23:59:00.000") QDateTime(2023-01-02 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG 6 2 *** + (main.cpp:123) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:00:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:01:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:02:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:03:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:04:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:05:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:06:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:07:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:08:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:09:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:10:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:11:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.533 DEBG ==> QTime("00:12:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:13:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:14:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:15:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:16:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:17:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:18:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:19:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:20:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:21:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:22:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:23:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:24:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:25:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:26:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.534 DEBG ==> QTime("00:27:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:28:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:29:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:30:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:31:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:32:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:33:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:34:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:35:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:36:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:37:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:38:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:39:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:40:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:41:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:42:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.535 DEBG ==> QTime("00:43:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:44:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:45:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:46:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:47:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:48:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:49:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:50:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:51:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:52:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:53:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:54:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:55:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:56:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.536 DEBG ==> QTime("00:57:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("00:58:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("00:59:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:00:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:01:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:02:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:03:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:04:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:05:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:06:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:07:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:08:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:09:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:10:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:11:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:12:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.537 DEBG ==> QTime("01:13:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:14:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:15:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:16:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:17:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:18:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:19:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:20:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:21:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:22:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:23:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:24:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:25:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:26:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.538 DEBG ==> QTime("01:27:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:28:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:29:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:30:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:31:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:32:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:33:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:34:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:35:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:36:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:37:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:38:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:39:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:40:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:41:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:42:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.539 DEBG ==> QTime("01:43:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:44:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:45:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:46:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:47:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:48:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:49:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:50:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:51:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:52:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:53:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:54:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:55:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:56:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:57:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.540 DEBG ==> QTime("01:58:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("01:59:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:00:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:01:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:02:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:03:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:04:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:05:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:06:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:07:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:08:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:09:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:10:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:11:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:12:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:13:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:14:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:15:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:16:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:17:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:18:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:19:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:20:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:21:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.541 DEBG ==> QTime("02:22:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:23:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:24:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:25:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:26:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:27:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:28:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:29:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:30:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:31:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:32:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:33:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:34:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:35:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:36:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:37:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:38:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:39:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:40:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:41:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:42:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.542 DEBG ==> QTime("02:43:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:44:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:45:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:46:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:47:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:48:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:49:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:50:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:51:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:52:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:53:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:54:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:55:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:56:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:57:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:58:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("02:59:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("03:00:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("03:01:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.543 DEBG ==> QTime("03:02:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:03:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:04:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:05:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:06:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:07:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:08:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:09:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:10:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:11:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:12:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:13:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:14:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:15:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:16:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:17:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:18:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:19:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:20:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:21:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:22:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:23:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.544 DEBG ==> QTime("03:24:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:25:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:26:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:27:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:28:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:29:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:30:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:31:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:32:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:33:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:34:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:35:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:36:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:37:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:38:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:39:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:40:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:41:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:42:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:43:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:44:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:45:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:46:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.545 DEBG ==> QTime("03:47:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:48:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:49:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:50:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:51:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:52:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:53:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:54:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:55:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:56:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:57:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:58:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("03:59:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:00:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:01:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:02:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:03:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:04:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:05:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:06:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:07:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:08:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:09:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.546 DEBG ==> QTime("04:10:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:11:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:12:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:13:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:14:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:15:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:16:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:17:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:18:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:19:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:20:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:21:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:22:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:23:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:24:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:25:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:26:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:27:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:28:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:29:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:30:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:31:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:32:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.547 DEBG ==> QTime("04:33:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:34:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:35:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:36:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:37:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:38:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:39:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:40:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:41:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:42:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:43:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:44:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:45:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:46:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:47:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:48:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:49:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:50:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:51:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:52:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:53:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:54:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:55:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:56:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.548 DEBG ==> QTime("04:57:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("04:58:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("04:59:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:00:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:01:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:02:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:03:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:04:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:05:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:06:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:07:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:08:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:09:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:10:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:11:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:12:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:13:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:14:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:15:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:16:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:17:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:18:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:19:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.549 DEBG ==> QTime("05:20:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:21:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:22:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:23:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:24:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:25:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:26:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:27:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:28:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:29:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:30:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:31:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:32:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:33:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:34:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:35:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:36:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:37:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:38:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:39:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:40:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:41:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:42:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.550 DEBG ==> QTime("05:43:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:44:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:45:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:46:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:47:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:48:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:49:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:50:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:51:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:52:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:53:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:54:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:55:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:56:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:57:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:58:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("05:59:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("06:00:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("06:01:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("06:02:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.551 DEBG ==> QTime("06:03:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:04:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:05:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:06:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:07:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:08:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:09:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:10:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:11:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:12:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:13:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:14:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:15:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:16:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:17:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:18:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:19:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:20:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:21:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:22:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:23:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:24:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:25:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:26:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.552 DEBG ==> QTime("06:27:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:28:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:29:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:30:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:31:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:32:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:33:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:34:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:35:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:36:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:37:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:38:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:39:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:40:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:41:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:42:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:43:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:44:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:45:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:46:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:47:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:48:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:49:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:50:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.553 DEBG ==> QTime("06:51:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:52:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:53:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:54:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:55:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:56:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:57:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:58:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("06:59:00.000") QDateTime(2023-01-03 00:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:00:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:01:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:02:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:03:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:04:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:05:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:06:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:07:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:08:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:09:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.554 DEBG ==> QTime("07:10:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:11:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:12:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:13:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:14:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:15:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:16:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:17:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:18:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:19:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:20:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:21:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:22:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:23:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.555 DEBG ==> QTime("07:24:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:25:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:26:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:27:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:28:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:29:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:30:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:31:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:32:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:33:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:34:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:35:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:36:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:37:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.556 DEBG ==> QTime("07:38:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:39:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:40:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:41:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:42:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:43:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:44:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:45:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:46:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:47:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:48:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:49:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:50:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:51:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.557 DEBG ==> QTime("07:52:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("07:53:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("07:54:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("07:55:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("07:56:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("07:57:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("07:58:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("07:59:00.000") QDateTime(2023-01-03 07:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("08:00:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("08:01:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("08:02:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("08:03:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("08:04:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("08:05:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.558 DEBG ==> QTime("08:06:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:07:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:08:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:09:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:10:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:11:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:12:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:13:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:14:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:15:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:16:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:17:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:18:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:19:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:20:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:21:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:22:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.559 DEBG ==> QTime("08:23:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:24:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:25:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:26:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:27:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:28:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:29:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:30:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:31:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:32:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:33:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:34:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:35:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:36:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:37:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:38:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:39:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:40:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:41:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:42:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:43:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:44:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.560 DEBG ==> QTime("08:45:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:46:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:47:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:48:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:49:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:50:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:51:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:52:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:53:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:54:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:55:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:56:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:57:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:58:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("08:59:00.000") QDateTime(2023-01-03 08:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:00:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:01:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:02:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:03:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:04:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:05:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:06:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.561 DEBG ==> QTime("09:07:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:08:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:09:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:10:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:11:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:12:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:13:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:14:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:15:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:16:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:17:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:18:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:19:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:20:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:21:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:22:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:23:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:24:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:25:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:26:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:27:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:28:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:29:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.562 DEBG ==> QTime("09:30:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:31:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:32:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:33:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:34:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:35:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:36:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:37:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:38:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:39:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:40:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:41:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:42:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:43:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:44:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:45:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:46:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:47:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:48:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:49:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:50:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:51:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.563 DEBG ==> QTime("09:52:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("09:53:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("09:54:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("09:55:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("09:56:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("09:57:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("09:58:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("09:59:00.000") QDateTime(2023-01-03 09:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:00:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:01:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:02:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:03:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:04:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:05:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:06:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:07:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:08:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:09:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:10:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:11:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:12:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:13:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:14:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.564 DEBG ==> QTime("10:15:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:16:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:17:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:18:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:19:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:20:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:21:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:22:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:23:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:24:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:25:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:26:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:27:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:28:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:29:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:30:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:31:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:32:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:33:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:34:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:35:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:36:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.565 DEBG ==> QTime("10:37:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:38:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:39:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:40:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:41:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:42:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:43:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:44:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:45:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:46:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:47:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:48:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:49:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:50:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:51:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:52:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:53:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:54:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:55:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:56:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:57:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:58:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("10:59:00.000") QDateTime(2023-01-03 10:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.566 DEBG ==> QTime("11:00:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:01:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:02:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:03:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:04:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:05:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:06:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:07:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:08:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:09:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:10:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:11:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:12:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:13:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:14:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:15:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:16:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:17:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:18:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:19:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:20:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:21:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.567 DEBG ==> QTime("11:22:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:23:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:24:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:25:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:26:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:27:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:28:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:29:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:30:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:31:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:32:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:33:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:34:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:35:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:36:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:37:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:38:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:39:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:40:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:41:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:42:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:43:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.568 DEBG ==> QTime("11:44:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:45:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:46:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:47:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:48:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:49:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:50:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:51:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:52:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:53:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:54:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:55:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:56:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:57:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:58:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("11:59:00.000") QDateTime(2023-01-03 11:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("12:00:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("12:01:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("12:02:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("12:03:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("12:04:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("12:05:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.569 DEBG ==> QTime("12:06:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:07:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:08:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:09:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:10:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:11:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:12:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:13:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:14:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:15:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:16:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:17:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:18:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:19:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:20:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:21:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:22:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:23:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:24:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:25:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:26:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:27:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:28:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.570 DEBG ==> QTime("12:29:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:30:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:31:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:32:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:33:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:34:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:35:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:36:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:37:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:38:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:39:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:40:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:41:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:42:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:43:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:44:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:45:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:46:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:47:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:48:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:49:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:50:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.571 DEBG ==> QTime("12:51:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:52:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:53:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:54:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:55:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:56:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:57:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:58:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("12:59:00.000") QDateTime(2023-01-03 12:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:00:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:01:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:02:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:03:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:04:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:05:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:06:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:07:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:08:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:09:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:10:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:11:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:12:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.572 DEBG ==> QTime("13:13:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:14:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:15:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:16:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:17:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:18:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:19:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:20:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:21:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:22:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:23:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:24:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:25:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:26:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:27:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:28:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:29:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:30:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:31:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:32:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:33:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:34:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:35:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.573 DEBG ==> QTime("13:36:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:37:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:38:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:39:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:40:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:41:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:42:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:43:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:44:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:45:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:46:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:47:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:48:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:49:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:50:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:51:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:52:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:53:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:54:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:55:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:56:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.574 DEBG ==> QTime("13:57:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("13:58:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("13:59:00.000") QDateTime(2023-01-03 13:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:00:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:01:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:02:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:03:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:04:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:05:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:06:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:07:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:08:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:09:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:10:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:11:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:12:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:13:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:14:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:15:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:16:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.575 DEBG ==> QTime("14:17:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:18:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:19:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:20:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:21:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:22:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:23:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:24:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:25:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:26:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:27:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:28:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:29:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:30:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:31:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:32:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:33:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.576 DEBG ==> QTime("14:34:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:35:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:36:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:37:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:38:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:39:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:40:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:41:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:42:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:43:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:44:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:45:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:46:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:47:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:48:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:49:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:50:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:51:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:52:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:53:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.577 DEBG ==> QTime("14:54:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("14:55:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("14:56:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("14:57:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("14:58:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("14:59:00.000") QDateTime(2023-01-03 14:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:00:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:01:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:02:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:03:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:04:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:05:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:06:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:07:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:08:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:09:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:10:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:11:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:12:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:13:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:14:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.578 DEBG ==> QTime("15:15:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:16:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:17:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:18:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:19:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:20:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:21:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:22:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:23:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:24:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:25:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:26:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:27:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:28:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:29:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:30:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:31:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:32:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:33:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:34:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:35:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:36:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.579 DEBG ==> QTime("15:37:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:38:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:39:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:40:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:41:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:42:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:43:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:44:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:45:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:46:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:47:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:48:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:49:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:50:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:51:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:52:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:53:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:54:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:55:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:56:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:57:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.580 DEBG ==> QTime("15:58:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("15:59:00.000") QDateTime(2023-01-03 15:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:00:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:01:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:02:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:03:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:04:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:05:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:06:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:07:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:08:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:09:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:10:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:11:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:12:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:13:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:14:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:15:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:16:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:17:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:18:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:19:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.581 DEBG ==> QTime("16:20:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:21:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:22:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:23:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:24:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:25:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:26:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:27:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:28:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:29:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:30:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:31:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:32:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:33:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:34:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:35:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:36:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:37:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:38:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:39:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:40:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.582 DEBG ==> QTime("16:41:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:42:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:43:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:44:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:45:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:46:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:47:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:48:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:49:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:50:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:51:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:52:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:53:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:54:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:55:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:56:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:57:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:58:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("16:59:00.000") QDateTime(2023-01-03 16:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.583 DEBG ==> QTime("17:00:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:01:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:02:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:03:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:04:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:05:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:06:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:07:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:08:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:09:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:10:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:11:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:12:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:13:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:14:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:15:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:16:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:17:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:18:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:19:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:20:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:21:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.584 DEBG ==> QTime("17:22:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:23:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:24:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:25:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:26:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:27:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:28:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:29:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:30:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:31:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:32:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:33:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:34:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:35:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:36:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:37:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:38:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:39:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:40:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:41:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:42:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:43:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:44:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.585 DEBG ==> QTime("17:45:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:46:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:47:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:48:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:49:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:50:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:51:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:52:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:53:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:54:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:55:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:56:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:57:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:58:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("17:59:00.000") QDateTime(2023-01-03 17:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("18:00:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("18:01:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("18:02:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("18:03:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.586 DEBG ==> QTime("18:04:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:05:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:06:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:07:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:08:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:09:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:10:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:11:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:12:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:13:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:14:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:15:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:16:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.587 DEBG ==> QTime("18:17:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:18:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:19:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:20:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:21:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:22:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:23:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:24:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:25:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:26:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:27:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:28:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:29:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:30:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.588 DEBG ==> QTime("18:31:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:32:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:33:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:34:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:35:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:36:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:37:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:38:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:39:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:40:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:41:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:42:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:43:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:44:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.589 DEBG ==> QTime("18:45:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:46:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:47:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:48:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:49:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:50:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:51:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:52:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:53:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:54:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:55:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:56:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:57:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:58:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.590 DEBG ==> QTime("18:59:00.000") QDateTime(2023-01-03 18:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:00:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:01:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:02:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:03:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:04:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:05:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:06:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:07:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:08:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:09:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:10:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:11:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:12:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.591 DEBG ==> QTime("19:13:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:14:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:15:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:16:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:17:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:18:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:19:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:20:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:21:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:22:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:23:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:24:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:25:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:26:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.592 DEBG ==> QTime("19:27:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:28:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:29:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:30:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:31:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:32:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:33:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:34:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:35:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:36:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:37:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:38:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:39:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:40:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.593 DEBG ==> QTime("19:41:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:42:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:43:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:44:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:45:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:46:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:47:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:48:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:49:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:50:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:51:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:52:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:53:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.594 DEBG ==> QTime("19:54:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("19:55:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("19:56:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("19:57:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("19:58:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("19:59:00.000") QDateTime(2023-01-03 19:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:00:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:01:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:02:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:03:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:04:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:05:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:06:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:07:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:08:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.595 DEBG ==> QTime("20:09:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:10:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:11:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:12:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:13:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:14:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:15:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:16:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:17:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:18:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:19:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:20:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:21:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.596 DEBG ==> QTime("20:22:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:23:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:24:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:25:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:26:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:27:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:28:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:29:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:30:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:31:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:32:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:33:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:34:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:35:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.597 DEBG ==> QTime("20:36:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:37:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:38:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:39:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:40:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:41:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:42:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:43:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:44:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:45:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:46:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:47:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:48:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:49:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:50:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.598 DEBG ==> QTime("20:51:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:52:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:53:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:54:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:55:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:56:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:57:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:58:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("20:59:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("21:00:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("21:01:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("21:02:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("21:03:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("21:04:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("21:05:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.599 DEBG ==> QTime("21:06:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:07:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:08:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:09:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:10:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:11:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:12:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:13:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:14:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:15:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:16:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:17:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:18:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.600 DEBG ==> QTime("21:19:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:20:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:21:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:22:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:23:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:24:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:25:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:26:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:27:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:28:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:29:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:30:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:31:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:32:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:33:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.601 DEBG ==> QTime("21:34:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:35:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:36:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:37:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:38:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:39:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:40:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:41:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:42:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:43:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:44:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:45:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:46:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:47:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.602 DEBG ==> QTime("21:48:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:49:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:50:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:51:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:52:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:53:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:54:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:55:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:56:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:57:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:58:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("21:59:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("22:00:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.603 DEBG ==> QTime("22:01:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:02:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:03:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:04:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:05:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:06:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:07:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:08:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:09:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:10:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:11:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:12:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:13:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:14:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.604 DEBG ==> QTime("22:15:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:16:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:17:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:18:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:19:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:20:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:21:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:22:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:23:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:24:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:25:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:26:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:27:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:28:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.605 DEBG ==> QTime("22:29:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:30:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:31:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:32:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:33:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:34:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:35:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:36:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:37:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:38:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:39:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:40:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:41:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:42:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.606 DEBG ==> QTime("22:43:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:44:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:45:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:46:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:47:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:48:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:49:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:50:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:51:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:52:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:53:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:54:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:55:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:56:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.607 DEBG ==> QTime("22:57:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("22:58:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("22:59:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:00:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:01:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:02:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:03:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:04:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:05:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:06:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:07:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:08:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:09:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:10:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.608 DEBG ==> QTime("23:11:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:12:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:13:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:14:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:15:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:16:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:17:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:18:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:19:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:20:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:21:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:22:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:23:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:24:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:25:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.609 DEBG ==> QTime("23:26:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:27:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:28:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:29:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:30:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:31:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:32:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:33:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:34:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:35:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:36:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:37:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:38:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:39:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.610 DEBG ==> QTime("23:40:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:41:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:42:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:43:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:44:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:45:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:46:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:47:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:48:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:49:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:50:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:51:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.611 DEBG ==> QTime("23:52:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.612 DEBG ==> QTime("23:53:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.612 DEBG ==> QTime("23:54:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.612 DEBG ==> QTime("23:55:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.612 DEBG ==> QTime("23:56:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.612 DEBG ==> QTime("23:57:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.612 DEBG ==> QTime("23:58:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) + 04.01.2023 08:22:03.612 DEBG ==> QTime("23:59:00.000") QDateTime(2023-01-03 20:00:00.000 CET Qt::LocalTime) QDateTime(2023-01-04 07:00:00.000 CET Qt::LocalTime) (calculate_parking_tickets_algorithms.cpp:70) +08:22:03: /home/linux/build-calculate_parking-Desktop-Debug/main/main wurde mit dem Rückgabewert 0 beendet diff --git a/main/main.cpp b/main/main.cpp new file mode 100644 index 0000000..6a1586c --- /dev/null +++ b/main/main.cpp @@ -0,0 +1,70 @@ +#include +#include + +#include + +#include "calculate_parking_tickets.h" +#include "calculate_parking_tickets_global.h" +#include "calculate_parking_tickets_algorithms.h" +#include "calculate_parking_tickets_tariff.h" +#include "calculate_parking_tickets_utils.h" +#include "message_handler.h" + +int main() { + + if (!messageHandlerInstalled()) { // change internal qt-QDebug-handling + atbInstallMessageHandler(atbDebugOutput); + setDebugLevel(QtMsgType::QtDebugMsg); + } + + parking_tariff_t *tariff = + parking_tariff_t::parseTariff("/opt/ptu5/opt/calculate_parking/calculate_parking_tickets/germersheim.conf"); + + if (tariff) { + price_t price; + memset(&price, 0x00, sizeof(price)); + QDateTime start = QDateTime::currentDateTime(); + QDateTime end; + start.setTime(QTime()); + int d1, d2 = 0; + + d1 = start.date().dayOfWeek(); + + int hour[] = { 2, 5, 10, 20, 30, 40}; + + for (int h = 0; h < 6; ++h) { + for (int i = 0; i < MIN_PER_DAY; ++i) { + fprintf(stderr, "\n*** %5d *** (parkdauer:%dh)", i*(h+1), hour[h]); + + if (d1 != d2) { + qDebug() << ((i==0) ? 0: i/MIN_PER_DAY) << d1 << "***\n"; + d2 = d1; + } + + //start = start.addSecs(i*60); + //start = start.addSecs(420*60); + minute_t const s = TUtils::toMinutes(start); + end = start.addSecs(hour[h]*60*60); + minute_t const e = TUtils::toMinutes(end); + //minute_t const e = s + 24*60*3 + 123; + + fprintf(stderr, + "[EINFAHRT: %s:%02d:%02d, %ld Minuten frei, " + "AUSFAHRT: %s:%02d:%02d]\n", + start.date().toString().toStdString().c_str(), + start.time().hour(), start.time().minute(), + tariff->free_of_charge, + end.date().toString().toStdString().c_str(), + end.time().hour(), end.time().minute()); + + if (compute_price_for_parking_ticket(tariff, s, e, &price)) { + + } + start = start.addSecs(60); + d1 = start.date().dayOfWeek(); + } + } + } + + return 0; +} diff --git a/main/main.cpp.bck.1 b/main/main.cpp.bck.1 new file mode 100644 index 0000000..0bac1f3 --- /dev/null +++ b/main/main.cpp.bck.1 @@ -0,0 +1,160 @@ +#include +#include + +#include "calculate_parking_tickets.h" +#include "calculate_parking_tickets_algorithms.h" +#include "calculate_parking_tickets_tariff.h" +#include "calculate_parking_tickets_utils.h" +#include "message_handler.h" + +int main() { + + if (!messageHandlerInstalled()) { // change internal qt-QDebug-handling + atbInstallMessageHandler(atbDebugOutput); + setDebugLevel(QtMsgType::QtDebugMsg); + } + + /* + Germersheim: + Freiparkzeit: 90 min + Stundentarif: 7:00 - 20:00 3,50 Euro/h + Tagesmaximum: 18 Euro, gueltig 24h ab einfahrt + Nacht-Tarif: 20:00 - 7:00: 8 Euro + + Fragen: + 1. Fuer die Abrechnung bleiben mehrere Moeglichkeiten. + a: minutengenau: eine Minute kostet 0.0583 Euro (bzw. 0.012 Euro nachts). + b: im Stunden-Raster ausgerichtet an der tatsaechlichen Uhrzeit + wie angeben: jede angefangene Stunde kostet 3.50 Euro bzw. + 8 Euro Nacht-Tarif. + + Beispiele: + zu b: Einfahrt um 18:24 Uhr. Bis 19:54 Uhr ist dann frei. Die 6 Minuten + bis 20:00 Uhr kosten dann 3.50 Euro. Ausfahrt um 21.00 Uhr: kostet + dann 8 Euro, insgesamt also 11.50 Euro. + zu a: wie vor, nur minutengenaue Abrechnung: 6 Minuten kosten dann + 6*0.0583 = 0.35 Euro, plus 1h nachts: 60*0.012 = 0.72 Euro, + insgesamt also 1.07 Euro. + + Was (logisch) nicht moeglich ist: ein Stunden-Raster, das nicht an der + tatsaechlichen Uhrzeit ausgerichtet ist. + Beispiel: Einfahrt 18:00 Uhr, frei bis 19:30 Uhr. Wie soll nun die + naechste Stunde berechnet werden? Nach Tag- oder Nacht-Tariff? + + 2: Tagesmaximum + a: Es gibt also eine maximale Parkzeit von 24h, und der maximale Preis + ist 18 Euro? Oder gibt es kein Maximum fuer die Parkdauer, aber der + Preis ab 24h Parkdauer betraegt einheitlich 18 Euro. + + Im zweiten Fall waere dann Folgendes moeglich: + Einfahrt 5:30 Uhr, frei bis 7:00 Uhr. + Kosten von 7:00 - 20:00 Uhr: 13*3.50 = 45.50 Euro. + Kosten von 20:00 - 7:00 Uhr: 8 Euro. + Ausfahrt: 8:00 Uhr: 3.50 Euro, insgesamt eigentlich 57 Euro, + nach obiger Regel aber dann nur 18 Euro. + */ + + /* + TODO: + 1: Abrechnungsmodus: + a: minutengenau + b: 15-min-Raster, ausgerichtet an der tatseachlichen Uhrzeit + b: 30-min-Raster, ausgerichtet an der tatseachlichen Uhrzeit + b: 60-min-Raster, ausgerichtet an der tatseachlichen Uhrzeit + c: wie im Tarif angegeben mit einer moeglichst groben Aufloesung. + */ + + parking_tariff_t *tariff = new parking_tariff_t(); + + tariff->unit_scale_factor = 1.0; + tariff->unit_definition = 1000; + tariff->waiting_period = 0; + // tariff->waiting_period = 90; + + int const si = sizeof(TariffStep); + qDebug() << si; + QDate today = QDate::currentDate(); + int todayWeekDay = today.dayOfWeek(); + if (todayWeekDay > Qt::Monday) { + int day = today.day() - todayWeekDay; + if (!today.setDate(today.year(), today.month(), day)) { + qFatal("Setting today failed"); + } + } + QDate sunday = today; + qDebug() << sunday; + for (int i = Qt::Monday; i <= Qt::Sunday; ++i) { + // days start at midnight + QDateTime startMinute(sunday.addDays(i), QTime( 0, 0)); + + //qDebug() << "startMinute=" << startMinute << startMinute.date().dayOfWeek(); + + // first block: 0:00 - 7:00. night-tariff. + TariffStep *current = &tariff->m_tariffSteps[i][0]; + TariffStep *next = &tariff->m_tariffSteps[i][7*60]; + *current = TariffStep(startMinute, 0, next); + + //qDebug() << "current =" << "c=" << current << current->startMinute() << current->price() << "n=" << current->next(); + //qDebug() << "offset =" << ((char *)current->next() - (char *)&tariff->m_tariffSteps[i][0])/sizeof(TariffStep); + + // from 7:00 on, each hour costs 3.50 euros == 350000 units + startMinute = startMinute.addSecs(7*3600); + current = next; + + for (int j = 7; j < 20; ++j) { + next = current + 60; + *current = TariffStep(startMinute, 350000, next); + + //qDebug() << "current =" << "c=" << current << current->startMinute() << current->price() << "n=" << current->next(); + //qDebug() << "offset =" << ((char *)current->next() - (char *)&tariff->m_tariffSteps[i][0])/sizeof(TariffStep); + + startMinute = startMinute.addSecs(3600); + current = next; + } + + if (i != Qt::Sunday) { + next = current + 4*60 + 7*60; + } else { + next = &tariff->m_tariffSteps[Qt::Monday][7*60]; + } + *current = TariffStep(startMinute, 0, next); + + if (i != Qt::Sunday) { + qDebug() << "current =" << "c=" << current << current->startMinute() << current->price() << "n=" << current->next(); + qDebug() << "offset =" << ((char *)current->next() - (char *)&tariff->m_tariffSteps[i][0])/sizeof(TariffStep); + } else { + qDebug() << "current =" << "c=" << current << current->startMinute() << current->price() << "n=" << current->next(); + if (&tariff->m_tariffSteps[1][420] == current->next()) { + qDebug() << "OK"; + qDebug() << "offset =" << ((char *)current->next() - (char *)&tariff->m_tariffSteps[1][0])/sizeof(TariffStep); + } + } + } + + + return 0; + +#if 0 + price_t price; + memset(&price, 0x00, sizeof(price)); + QDateTime start = QDateTime::currentDateTime(); + + minute_t const s = TUtils::toMinutes(start); + minute_t const e = s + 60; + + qDebug() << "start =" << start << "(" << s << ")"; + //start.setTime(QTime()); ruecksetzen des tages auf 0:00 + //QTime t = start.time(); + for (int i=1; i < (e-s); ++i) { + qDebug() << i << start << start.date().dayOfWeek(); + start = start.addSecs(60); + } +#endif + //if (TAlgo::compute_price_for_parking_ticket(tariff, s, e, &price)) { + + //} + + // Calculate_parking_tickets cpt; + + return 0; +} diff --git a/main/main.pro b/main/main.pro new file mode 100644 index 0000000..c969cd2 --- /dev/null +++ b/main/main.pro @@ -0,0 +1,29 @@ +QT += core + +TARGET = main +TEMPLATE = app + +CONFIG += c++17 + +QMAKE_CXXFLAGS += -Wno-deprecated-copy + +INCLUDEPATH += ../calculate_parking_tickets/ +INCLUDEPATH += ../rapidjson/include + +LIBS += -L$$OUT_PWD/../calculate_parking_tickets -lcalculate_parking_tickets + +# You can make your code fail to compile if it uses deprecated APIs. +# In order to do so, uncomment the following line. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + +SOURCES += \ + main.cpp \ + message_handler.cpp + +HEADERS += \ + message_handler.h + +# Default rules for deployment. +qnx: target.path = /tmp/$${TARGET}/bin +else: unix:!android: target.path = /opt/$${TARGET}/bin +!isEmpty(target.path): INSTALLS += target diff --git a/main/message_handler.cpp b/main/message_handler.cpp new file mode 100644 index 0000000..f5493e7 --- /dev/null +++ b/main/message_handler.cpp @@ -0,0 +1,140 @@ +#include "message_handler.h" + +#include +#include + +#define OUTPUT_LEN (20) + + +static bool installedMsgHandler = false; +static QtMsgType debugLevel = QtInfoMsg; + +QtMsgType getDebugLevel() { return debugLevel; } +void setDebugLevel(QtMsgType newDebugLevel) { + debugLevel = newDebugLevel; +} + +bool messageHandlerInstalled() { + return installedMsgHandler; +} + +QtMessageHandler atbInstallMessageHandler(QtMessageHandler handler) { + installedMsgHandler = (handler != 0); + static QtMessageHandler prevHandler = nullptr; + if (handler) { + prevHandler = qInstallMessageHandler(handler); + return prevHandler; + } else { + return qInstallMessageHandler(prevHandler); + } +} + +/// +/// \brief Print message according to given debug level. +/// +/// \note Install this function using qInstallMsgHandler(). +/// +/// int main(int argc, char **argv) { +/// installMsgHandler(atbDebugOutput); +/// QApplication app(argc, argv); +/// ... +/// return app.exec(); +/// } +/// +#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0) +void atbDebugOutput(QtMsgType type, const char *msg) { + switch (type) { + case QtDebugMsg: { + if (debugLevel <= QtDebugMsg) { + fprintf(stderr, "%*.*s Debug: %s\n", OUTPUT_LEN, OUTPUT_LEN, + QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg); + } + } break; + case QtInfoMsg: { + if (debugLevel <= QtInfoMsg) { + fprintf(stderr, "%*.*s Info: %s\n", OUTPUT_LEN, OUTPUT_LEN, + QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg); + } + } break; + case QtWarningMsg: { + if (debugLevel <= QtWarningMsg) { + fprintf(stderr, "%*.*s Warning: %s\n", OUTPUT_LEN, OUTPUT_LEN, + QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg); + } + } break; + case QtCriticalMsg: { + if (debugLevel <= QtCriticalMsg) { + fprintf(stderr, "%*.*s Critical: %s\n", OUTPUT_LEN, OUTPUT_LEN, + QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg); + } + } break; + case QtFatalMsg: { + if (debugLevel <= QtFatalMsg) { + fprintf(stderr, "%*.*s Fatal: %s\n", OUTPUT_LEN, OUTPUT_LEN, + QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg); + } + // abort(); + } break; + default: { + fprintf(stderr, "%*.*s No ErrorLevel defined! %s\n", OUTPUT_LEN, OUTPUT_LEN, + QDateTime::currentDateTime().toString(Qt::ISODate).toStdString().c_str(), msg); + } + } +} +#elif QT_VERSION < QT_VERSION_CHECK(6, 0, 0) +void atbDebugOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg) { + static constexpr const char *format = "dd.MM.yyyy hh:mm:ss"; + QByteArray localMsg = msg.toLocal8Bit(); + const char *file = context.file ? context.file : ""; + char const* output = std::strrchr(file, '/'); + if (output) { + file = output + 1; + } + qint64 const currentMSecsSinceEpoch = QDateTime::currentMSecsSinceEpoch(); + int const fractional_part = currentMSecsSinceEpoch % 1000; + QDateTime const datetime = QDateTime::fromMSecsSinceEpoch(currentMSecsSinceEpoch); + switch (type) { + case QtDebugMsg: { + if (debugLevel <= QtDebugMsg) { + fprintf(stderr, "%*.*s.%03d DEBG %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN, + datetime.toString(format).toStdString().c_str(), fractional_part, + localMsg.constData(), file, context.line); + } + } break; + case QtInfoMsg: { + if (debugLevel <= QtInfoMsg) { + fprintf(stderr, "%*.*s.%03d INFO %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN, + datetime.toString(format).toStdString().c_str(), fractional_part, + localMsg.constData(), file, context.line); + } + } break; + case QtWarningMsg: { + if (debugLevel <= QtWarningMsg) { + fprintf(stderr, "%*.*s.%03d WARN %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN, + datetime.toString(format).toStdString().c_str(), fractional_part, + localMsg.constData(), file, context.line); + } + } break; + case QtCriticalMsg: { + if (debugLevel <= QtCriticalMsg) { + fprintf(stderr, "%*.*s.%03d CRIT %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN, + datetime.toString(format).toStdString().c_str(), fractional_part, + localMsg.constData(), file, context.line); + } + } break; + case QtFatalMsg: { + if (debugLevel <= QtFatalMsg) { + fprintf(stderr, "%*.*s.%03d FATAL %s (%s:%u)\n", OUTPUT_LEN, OUTPUT_LEN, + datetime.toString(format).toStdString().c_str(), fractional_part, + localMsg.constData(), file, context.line); + } + } break; + default: { + fprintf(stderr, "%*.*s.%03d No ErrorLevel defined! %s\n", OUTPUT_LEN, OUTPUT_LEN, + datetime.toString(format).toStdString().c_str(), fractional_part, + msg.toStdString().c_str()); + } + } +} +#endif + diff --git a/main/message_handler.h b/main/message_handler.h new file mode 100644 index 0000000..18e923b --- /dev/null +++ b/main/message_handler.h @@ -0,0 +1,20 @@ +#ifndef MESSAGE_HANDLER_H_INCLUDED +#define MESSAGE_HANDLER_H_INCLUDED + +#include + +QtMsgType getDebugLevel(); +void setDebugLevel(QtMsgType newDebugLevel); + +bool messageHandlerInstalled(); +QtMessageHandler atbInstallMessageHandler(QtMessageHandler handler); + +#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0) +// typedef void (*QtMessageHandler)(QtMsgType, const char *); +void atbDebugOutput(QtMsgType type, const char *msg); +#elif QT_VERSION < QT_VERSION_CHECK(6, 0, 0) +// typedef void (*QtMessageHandler)(QtMsgType, const QMessageLogContext &, const QString &); +void atbDebugOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg); +#endif + +#endif // MESSAGE_HANDLER_H_INCLUDED