From c0c5d803fb86024e47adbd964b56f444f4d3cd99 Mon Sep 17 00:00:00 2001 From: frankyshelloy Date: Mon, 24 Nov 2025 17:40:00 +0700 Subject: [PATCH 01/13] add --- CMakeLists.txt | 33 ++ README.md | 24 ++ include/Bonus.h | 31 ++ include/BrickWall.h | 9 + include/Bullet.h | 26 ++ include/EnemyTank.h | 76 +++++ include/GameModel.h | 34 ++ include/GameScane.h | 89 ++++++ include/GlobalConstants.h | 72 +++++ include/Tank.h | 31 ++ include/Wall.h | 8 + src/Bonus.cpp | 39 +++ src/BrickWall.cpp | 36 +++ src/Bullet.cpp | 50 +++ src/EnemyTank.cpp | 274 ++++++++++++++++ src/GameModel.cpp | 43 +++ src/GameScane.cpp | 644 ++++++++++++++++++++++++++++++++++++++ src/Tank.cpp | 110 +++++++ src/Wall.cpp | 44 +++ src/main.cpp | 19 ++ 20 files changed, 1692 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 include/Bonus.h create mode 100644 include/BrickWall.h create mode 100644 include/Bullet.h create mode 100644 include/EnemyTank.h create mode 100644 include/GameModel.h create mode 100644 include/GameScane.h create mode 100644 include/GlobalConstants.h create mode 100644 include/Tank.h create mode 100644 include/Wall.h create mode 100644 src/Bonus.cpp create mode 100644 src/BrickWall.cpp create mode 100644 src/Bullet.cpp create mode 100644 src/EnemyTank.cpp create mode 100644 src/GameModel.cpp create mode 100644 src/GameScane.cpp create mode 100644 src/Tank.cpp create mode 100644 src/Wall.cpp create mode 100644 src/main.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..3a44dfe --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,33 @@ +cmake_minimum_required(VERSION 3.16) +project(TanksGame LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +set(CMAKE_AUTOMOC ON) +set(CMAKE_AUTORCC ON) +set(CMAKE_AUTOUIC ON) + +find_package(Qt5 REQUIRED COMPONENTS Core Widgets Multimedia) + +add_executable(TanksGame + src/main.cpp + src/GameScane.cpp + src/GameModel.cpp + include/GameScane.h + include/GameModel.h + src/Bonus.cpp + src/Tank.cpp + src/EnemyTank.cpp + src/Wall.cpp + src/BrickWall.cpp + src/Bullet.cpp +) + +target_link_libraries(TanksGame PRIVATE + Qt5::Core + Qt5::Widgets +) + +target_link_libraries(TanksGame PRIVATE Qt5::Multimedia) +target_include_directories(TanksGame PUBLIC ${CMAKE_SOURCE_DIR}/include) \ No newline at end of file diff --git a/README.md b/README.md index 8b13789..496bcac 100644 --- a/README.md +++ b/README.md @@ -1 +1,25 @@ +# Tanks + + игра «ТанкиNSU», написанная с использованием Qt5 + +## Структура проекта +- `include/` — все заголовочные файлы (.h) +- `src/` — реализации (.cpp) +- `CMakeLists.txt` — конфигурация сборки CMake + + +## Краткая инструкция по сборке +Требования: +- C++ компилятор с поддержкой C++20 +- CMake >= 3.16 +- Qt5 + +Сборка из корня проекта : + +```bash +mkdir -p cmake-build-debug +cd cmake-build-debug +cmake .. +cmake --build . --config Debug -- -j 4 +``` diff --git a/include/Bonus.h b/include/Bonus.h new file mode 100644 index 0000000..685674f --- /dev/null +++ b/include/Bonus.h @@ -0,0 +1,31 @@ +#pragma once + +#include + +class GameScane; + +class Bonus : public QGraphicsEllipseItem { + public: + explicit Bonus(qreal x, qreal y, qreal w = 16.0, qreal h = 16.0); + ~Bonus() override = default; + + virtual void Apply(GameScane* scene) = 0; +}; + +class HealthBonus : public Bonus { + public: + explicit HealthBonus(qreal x, qreal y); + void Apply(GameScane* scene) override; +}; + +class MineBonus : public Bonus { + public: + explicit MineBonus(qreal x, qreal y); + void Apply(GameScane* scene) override; +}; + +class ScoreBonus : public Bonus { + public: + explicit ScoreBonus(qreal x, qreal y); + void Apply(GameScane* scene) override; +}; diff --git a/include/BrickWall.h b/include/BrickWall.h new file mode 100644 index 0000000..9b64ea0 --- /dev/null +++ b/include/BrickWall.h @@ -0,0 +1,9 @@ +#pragma once +#include + +class BrickWall : public QGraphicsPixmapItem { +public: + BrickWall(qreal x, qreal y); + QRectF GetRect() const; + static constexpr int kDurability = 3; +}; diff --git a/include/Bullet.h b/include/Bullet.h new file mode 100644 index 0000000..f83719c --- /dev/null +++ b/include/Bullet.h @@ -0,0 +1,26 @@ +#pragma once + +#include + +enum class Direction; +enum class BulletOwner { + Player, + Enemy, +}; + +class Bullet final : public QGraphicsPixmapItem { +public: + explicit Bullet(qreal x, qreal y, Direction direction, BulletOwner owner); + + void Move(); + Direction GetDirection() const; + BulletOwner GetOwner() const; + QRectF GetBoundingRect() const; + +private: + Direction m_direction; + BulletOwner m_owner; + + static constexpr qreal kSpeed = 5.0; + static constexpr qreal kSize = 6.0; +}; diff --git a/include/EnemyTank.h b/include/EnemyTank.h new file mode 100644 index 0000000..ee7dea4 --- /dev/null +++ b/include/EnemyTank.h @@ -0,0 +1,76 @@ +#pragma once +#include +#include +#include "Tank.h" + +class Bullet; + + +class EnemyTank : public QGraphicsPixmapItem { +public: + explicit EnemyTank(qreal x, qreal y); + + virtual void Update(); + virtual QRectF GetFutureRect(Direction direction) const; + Direction GetDirection() const { return m_direction; } + + void SetDirection(Direction dir); + void ResetMoveTimer(int frames) { m_moveCooldown = frames; } + void ResetFireTimer(int frames) { m_fireCooldown = frames; } + int GetMoveCooldown() const { return m_moveCooldown; } + int GetFireCooldown() const { return m_fireCooldown; } + + + static constexpr qreal kSpeed = 30.0; + static constexpr qreal kWidth = 32.0; + static constexpr qreal kHeight = 32.0; + + + virtual qreal GetSpeed() const { return kSpeed; } + virtual qreal GetWidth() const { return kWidth; } + virtual qreal GetHeight() const { return kHeight; } + + + int GetHP() const { return m_hp; } + void TakeDamage(int dmg); + bool IsDead() const { return m_hp <= 0; } + + + virtual QList Fire(Direction dir); + +protected: + virtual void UpdatePixmap(); + + Direction m_direction = Direction::Down; + int m_moveCooldown = 0; + int m_fireCooldown = 0; + int m_hp = 1; +}; + +// Легкий +class LightEnemy : public EnemyTank { +public: + explicit LightEnemy(qreal x, qreal y); + qreal GetSpeed() const override { return 1.5; } +protected: + void UpdatePixmap() override; +}; + +// Тяжелый +class HeavyEnemy : public EnemyTank { +public: + explicit HeavyEnemy(qreal x, qreal y); + qreal GetSpeed() const override { return 1; } +protected: + void UpdatePixmap() override; +}; + +// Двупульный тяжелый +class TwinShooterEnemy : public EnemyTank { +public: + explicit TwinShooterEnemy(qreal x, qreal y); + qreal GetSpeed() const override { return 0.8; } +protected: + void UpdatePixmap() override; + QList Fire(Direction dir) override; +}; diff --git a/include/GameModel.h b/include/GameModel.h new file mode 100644 index 0000000..1dfd8a9 --- /dev/null +++ b/include/GameModel.h @@ -0,0 +1,34 @@ +#pragma once + +#include + +class GameModel : public QObject { + Q_OBJECT +public: + explicit GameModel(QObject* parent = nullptr); + + int GetLives() const { return m_lives; } + int GetKills() const { return m_kills; } + bool IsGameOver() const { return m_gameOver; } + bool IsGameWon() const { return m_gameWon; } + +public slots: + void ModifyPlayerLives(int delta); + void ModifyScore(int delta); + void SetGameOver(bool v = true); + void SetGameWon(bool v = true); + void SetLives(int lives); + void SetKills(int kills); + +signals: + void livesChanged(int); + void scoreChanged(int); + void gameOver(); + void gameWon(); + +private: + int m_lives = 3; + int m_kills = 0; + bool m_gameOver = false; + bool m_gameWon = false; +}; diff --git a/include/GameScane.h b/include/GameScane.h new file mode 100644 index 0000000..3158279 --- /dev/null +++ b/include/GameScane.h @@ -0,0 +1,89 @@ +#pragma once + +#include +#include +#include +#include +#include +#include "GameModel.h" +#include +#include + +class Tank; +class Wall; +class BrickWall; +class Bullet; +class EnemyTank; +class Bonus; + +class GameScane final : public QGraphicsScene { + Q_OBJECT + + public: + explicit GameScane(QObject* parent = nullptr); + void ModifyPlayerLives(int delta); + void ModifyScore(int delta); + + private slots: + void Update(); + + private: + + void keyPressEvent(QKeyEvent* event) override; + void keyReleaseEvent(QKeyEvent* event) override; + + void HandlePlayerInputAndMovement(); + void SpawnEnemiesIfNeeded(); + void UpdateEnemies(); + void UpdatePlayerBullets(); + void UpdateEnemyBullets(); + + + void FireBullet(); + void RestartGame(); + void InitializeLevel(); + void UpdateBonuses(); + + bool IsCollidingWithSolidWall(const QRectF& rect) const; + BrickWall* IsCollidingWithBrickWall(const QRectF& rect) const; + bool IsCollidingWithAnyWall(const QRectF& rect) const; + + void UpdateLivesDisplay(); + void UpdateScoreDisplay(); + void ShowGameOver(); + void ShowWinScreen(); + + GameModel* m_model = nullptr; + bool m_canFire = true; + int m_enemySpawnCooldown = 0; + + + QTimer m_gameTimer; + QSet m_pressedKeys; + + + Tank* m_playerTank = nullptr; + QList m_walls; + QList m_brickWalls; + QList m_bullets; + QList m_enemyBullets; + QList m_enemyTanks; + QList m_bonuses; + QList m_freeSpawnPoints; + + + QGraphicsTextItem* m_livesText = nullptr; + QGraphicsTextItem* m_scoreText = nullptr; + + + QGraphicsRectItem* m_overlay = nullptr; + QGraphicsRectItem* m_gameOverBox = nullptr; + QGraphicsTextItem* m_gameOverText = nullptr; + QGraphicsTextItem* m_restartText = nullptr; + + + QGraphicsRectItem* m_winOverlay = nullptr; + QGraphicsRectItem* m_winBox = nullptr; + QGraphicsTextItem* m_winText = nullptr; + QGraphicsTextItem* m_winRestartText = nullptr; +}; diff --git a/include/GlobalConstants.h b/include/GlobalConstants.h new file mode 100644 index 0000000..d6ec9b8 --- /dev/null +++ b/include/GlobalConstants.h @@ -0,0 +1,72 @@ +#pragma once + +// Игровые константы: размеры сцены, карта, лимиты и условия победы +constexpr int kSceneWidth = 640; +constexpr int kSceneHeight = 640; +constexpr int kTileSize = 32; +constexpr int kMapRows = 20; +constexpr int kMapCols = 20; +constexpr int kMaxEnemies = 4; +constexpr int kSpawnCooldown = 60; +constexpr int kWinConditionKills = 10; +constexpr int kInitialPlayerLives = 3; + +// Параметры танка: размеры спрайта, скорость и компоненты для отрисовки +constexpr int kTankSize = 32; +constexpr int kTankSpeed = 2; +constexpr int kTankBodyX = 4; +constexpr int kTankBodyY = 8; +constexpr int kTankBodyWidth = 24; +constexpr int kTankBodyHeight = 16; +constexpr int kTankTrackWidth = 4; +constexpr int kTankTrackHeight = 12; +constexpr int kTankTrackLeftX = 2; +constexpr int kTankTrackRightX = 26; +constexpr int kTankTurretX = 12; +constexpr int kTankTurretY = 12; +constexpr int kTankTurretSize = 8; +constexpr int kTankGunCenter = 16; +constexpr int kTankGunLength = 12; + +// Параметры вражеского танка +constexpr int kEnemyTankSize = kTankSize; +constexpr int kEnemyTankSpeed = 2; +constexpr int kEnemyTankBodyX = kTankBodyX; +constexpr int kEnemyTankBodyY = kTankBodyY; +constexpr int kEnemyTankBodyWidth = kTankBodyWidth; +constexpr int kEnemyTankBodyHeight = kTankBodyHeight; +constexpr int kEnemyTankTrackWidth = kTankTrackWidth; +constexpr int kEnemyTankTrackHeight = kTankTrackHeight; +constexpr int kEnemyTankTurretX = kTankTurretX; +constexpr int kEnemyTankTurretY = kTankTurretY; +constexpr int kEnemyTankTurretSize = kTankTurretSize; +constexpr int kEnemyTankGunCenter = kTankGunCenter; +constexpr int kEnemyTankGunLength = kTankGunLength; + +// Пуля: размер и скорость +constexpr qreal kBulletSize = 6.0; +constexpr qreal kBulletSpeed = 4.0; + +// Кирпичная стена: параметры рисунка +constexpr int kBrickWallSize = 32; +constexpr int kBrickWidth = 14; +constexpr int kBrickHeight = 14; +constexpr int kBrickGap = 2; +constexpr int kBrickRows = 2; +constexpr int kBrickCols = 2; + +// Стена: параметры панелей и заклепок +constexpr int kWallSize = 32; +constexpr int kPanelSize = 12; +constexpr int kPanelSpacing = 4; +constexpr int kRivetRadius = 1; + +// Бонусы: размер и смещение +constexpr qreal kBonusSize = 16.0; +constexpr qreal kBonusOffset = 8.0; + +// Коллизии +constexpr int kCollisionInset = 4; + +// Задержка между выстрелами +constexpr int kPlayerFireCooldownFrames = 18; diff --git a/include/Tank.h b/include/Tank.h new file mode 100644 index 0000000..a5c5b56 --- /dev/null +++ b/include/Tank.h @@ -0,0 +1,31 @@ +#pragma once + +#include +#include + +enum class Direction +{ + Up, + Down, + Left, + Right +}; + +class Tank final : public QGraphicsPixmapItem +{ +public: + explicit Tank(qreal x, qreal y, QObject* parent = nullptr); + + void SetDirection(Direction direction); + void Update(); + void Move(); + auto GetFutureRect(Direction dir) const -> QRectF; + auto GetDirection() const -> Direction; + + +private: + void UpdatePixmap(); + + Direction m_direction { Direction::Up }; + static constexpr qreal kSpeed = 2.0; +}; diff --git a/include/Wall.h b/include/Wall.h new file mode 100644 index 0000000..e977efe --- /dev/null +++ b/include/Wall.h @@ -0,0 +1,8 @@ +#pragma once +#include + +class Wall final : public QGraphicsPixmapItem +{ +public: + explicit Wall(qreal x, qreal y); +}; diff --git a/src/Bonus.cpp b/src/Bonus.cpp new file mode 100644 index 0000000..7f16092 --- /dev/null +++ b/src/Bonus.cpp @@ -0,0 +1,39 @@ +#include "Bonus.h" +#include "GameScane.h" +#include "GlobalConstants.h" + +#include +#include + +Bonus::Bonus(qreal x, qreal y, qreal w, qreal h) : QGraphicsEllipseItem(0, 0, w, h) { + setPos(x + kBonusOffset, y + kBonusOffset); + setPen(Qt::NoPen); + setZValue(5); +} + +HealthBonus::HealthBonus(qreal x, qreal y) : Bonus(x, y, kBonusSize, kBonusSize) { + setBrush(QBrush(Qt::green)); +} + +void HealthBonus::Apply(GameScane* scene) { + if (!scene) return; + scene->ModifyPlayerLives(+1); +} + +MineBonus::MineBonus(qreal x, qreal y) : Bonus(x, y, kBonusSize, kBonusSize) { + setBrush(QBrush(Qt::red)); +} + +void MineBonus::Apply(GameScane* scene) { + if (!scene) return; + scene->ModifyPlayerLives(-1); +} + +ScoreBonus::ScoreBonus(qreal x, qreal y) : Bonus(x, y, kBonusSize, kBonusSize) { + setBrush(QBrush(Qt::cyan)); +} + +void ScoreBonus::Apply(GameScane* scene) { + if (!scene) return; + scene->ModifyScore(5); +} diff --git a/src/BrickWall.cpp b/src/BrickWall.cpp new file mode 100644 index 0000000..1dd6350 --- /dev/null +++ b/src/BrickWall.cpp @@ -0,0 +1,36 @@ + +#include "BrickWall.h" + +#include +#include + +#include "GlobalConstants.h" + +BrickWall::BrickWall(qreal x, qreal y) { + setPos(x, y); + setZValue(0); + + QPixmap pixmap(kBrickWallSize, kBrickWallSize); + pixmap.fill(Qt::transparent); + + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(0, 0, kBrickWallSize, kBrickWallSize, + QColor(200, 200, 200)); + + for (int row = 0; row < kBrickRows; ++row) { + for (int col = 0; col < kBrickCols; ++col) { + int bx = col * (kBrickWidth + kBrickGap) + kBrickGap; + int by = row * (kBrickHeight + kBrickGap) + kBrickGap; + + painter.fillRect(bx, by, kBrickWidth, kBrickHeight, + QColor(178, 34, 34)); + painter.setPen(Qt::white); + painter.drawRect(bx, by, kBrickWidth, kBrickHeight); + } + } + + painter.end(); + setPixmap(pixmap); +} diff --git a/src/Bullet.cpp b/src/Bullet.cpp new file mode 100644 index 0000000..4c724be --- /dev/null +++ b/src/Bullet.cpp @@ -0,0 +1,50 @@ +#include "Bullet.h" +#include "Tank.h" +#include +#include + +#include "GlobalConstants.h" + +Bullet::Bullet(qreal x, qreal y, Direction direction, BulletOwner owner) + : m_direction(direction), m_owner(owner) { + setPos(x, y); + setZValue(2); + + QPixmap pixmap(static_cast(kBulletSize), static_cast(kBulletSize)); + if (owner == BulletOwner::Player) { + pixmap.fill(Qt::yellow); + } else { + pixmap.fill(QColor(255, 140, 0)); + } + setPixmap(pixmap); +} + +void Bullet::Move() { + const QPointF current_pos = pos(); + switch (m_direction) { + case Direction::Up: + setPos(current_pos.x(), current_pos.y() - kBulletSpeed); + break; + case Direction::Down: + setPos(current_pos.x(), current_pos.y() + kBulletSpeed); + break; + case Direction::Left: + setPos(current_pos.x() - kBulletSpeed, current_pos.y()); + break; + case Direction::Right: + setPos(current_pos.x() + kBulletSpeed, current_pos.y()); + break; + } +} + +Direction Bullet::GetDirection() const { + return m_direction; +} + +BulletOwner Bullet::GetOwner() const { + return m_owner; +} + +QRectF Bullet::GetBoundingRect() const { + return QRectF(pos().x(), pos().y(), kBulletSize, kBulletSize); +} diff --git a/src/EnemyTank.cpp b/src/EnemyTank.cpp new file mode 100644 index 0000000..371de89 --- /dev/null +++ b/src/EnemyTank.cpp @@ -0,0 +1,274 @@ +#include "EnemyTank.h" + +#include +#include +#include + +#include "GlobalConstants.h" +#include "Bullet.h" + +EnemyTank::EnemyTank(qreal x, qreal y) { + setPos(x, y); + setZValue(1); + + m_direction = Direction::Down; + UpdatePixmap(); + + m_moveCooldown = QRandomGenerator::global()->bounded(18, 48); + m_fireCooldown = QRandomGenerator::global()->bounded(10, 50); + m_hp = 1; +} + +void EnemyTank::Update() { + if (m_moveCooldown > 0) --m_moveCooldown; + if (m_fireCooldown > 0) --m_fireCooldown; +} + +QRectF EnemyTank::GetFutureRect(Direction direction) const { + qreal new_x = pos().x(); + qreal new_y = pos().y(); + + switch (direction) { + case Direction::Up: + new_y -= GetSpeed(); + break; + case Direction::Down: + new_y += GetSpeed(); + break; + case Direction::Left: + new_x -= GetSpeed(); + break; + case Direction::Right: + new_x += GetSpeed(); + break; + } + + qreal collisionW = GetWidth() - 2 * kCollisionInset; + qreal collisionH = GetHeight() - 2 * kCollisionInset; + return QRectF(new_x + kCollisionInset, new_y + kCollisionInset, collisionW, collisionH); +} + +void EnemyTank::UpdatePixmap() { + QPixmap pixmap(GetWidth(), GetHeight()); + pixmap.fill(Qt::transparent); + + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, + QColor(139, 69, 19)); + + painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(101, 67, 33)); + painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(101, 67, 33)); + + painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, + QColor(120, 40, 10)); + + painter.setPen(QPen(Qt::black, 2)); + const int center = kEnemyTankGunCenter; + switch (m_direction) { + case Direction::Up: + painter.drawLine(center, center, center, center - kEnemyTankGunLength); + break; + case Direction::Down: + painter.drawLine(center, center, center, center + kEnemyTankGunLength); + break; + case Direction::Left: + painter.drawLine(center, center, center - kEnemyTankGunLength, center); + break; + case Direction::Right: + painter.drawLine(center, center, center + kEnemyTankGunLength, center); + break; + } + + painter.end(); + setPixmap(pixmap); +} + +void EnemyTank::SetDirection(Direction direction) { + if (m_direction == direction) { + return; + } + m_direction = direction; + UpdatePixmap(); +} + +void EnemyTank::TakeDamage(int dmg) { + m_hp -= dmg; +} + +QList EnemyTank::Fire(Direction dir) { + QList list; + QPointF pos = this->pos(); + qreal bulletX = pos.x() + GetWidth() / 2 - 3; + qreal bulletY = pos.y() + GetHeight() / 2 - 3; + + switch (dir) { + case Direction::Up: + bulletY = pos.y() - 3; + break; + case Direction::Down: + bulletY = pos.y() + GetHeight() - 3; + break; + case Direction::Left: + bulletX = pos.x() - 3; + break; + case Direction::Right: + bulletX = pos.x() + GetWidth() - 3; + break; + } + + auto* bullet = new Bullet(bulletX, bulletY, dir, BulletOwner::Enemy); + list.append(bullet); + return list; +} + +LightEnemy::LightEnemy(qreal x, qreal y) : EnemyTank(x, y) { + m_hp = 1; + UpdatePixmap(); +} + +void LightEnemy::UpdatePixmap() { + QPixmap pixmap(GetWidth(), GetHeight()); + pixmap.fill(Qt::transparent); + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, + QColor(30, 144, 255)); + + painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, QColor(10, 50, 120)); + painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, QColor(10, 50, 120)); + + painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, + QColor(0, 100, 200)); + + painter.setPen(QPen(Qt::black, 2)); + const int center = kEnemyTankGunCenter; + switch (m_direction) { + case Direction::Up: + painter.drawLine(center, center, center, center - kEnemyTankGunLength); + break; + case Direction::Down: + painter.drawLine(center, center, center, center + kEnemyTankGunLength); + break; + case Direction::Left: + painter.drawLine(center, center, center - kEnemyTankGunLength, center); + break; + case Direction::Right: + painter.drawLine(center, center, center + kEnemyTankGunLength, center); + break; + } + + painter.end(); + setPixmap(pixmap); +} + +HeavyEnemy::HeavyEnemy(qreal x, qreal y) : EnemyTank(x, y) { + m_hp = 2; + UpdatePixmap(); +} + +void HeavyEnemy::UpdatePixmap() { + QPixmap pixmap(GetWidth(), GetHeight()); + pixmap.fill(Qt::transparent); + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, + QColor(139, 0, 0)); + + painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(101, 67, 33)); + painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(101, 67, 33)); + + painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, + QColor(128, 0, 0)); + + painter.setPen(QPen(Qt::black, 2)); + const int center = kEnemyTankGunCenter; + switch (m_direction) { + case Direction::Up: + painter.drawLine(center, center, center, center - kEnemyTankGunLength); + break; + case Direction::Down: + painter.drawLine(center, center, center, center + kEnemyTankGunLength); + break; + case Direction::Left: + painter.drawLine(center, center, center - kEnemyTankGunLength, center); + break; + case Direction::Right: + painter.drawLine(center, center, center + kEnemyTankGunLength, center); + break; + } + + painter.end(); + setPixmap(pixmap); +} + +TwinShooterEnemy::TwinShooterEnemy(qreal x, qreal y) : EnemyTank(x, y) { + m_hp = 3; + UpdatePixmap(); +} + +void TwinShooterEnemy::UpdatePixmap() { + QPixmap pixmap(GetWidth(), GetHeight()); + pixmap.fill(Qt::transparent); + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, + QColor(255, 165, 0)); + + painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(140, 90, 40)); + painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(140, 90, 40)); + + painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, + QColor(200, 100, 0)); + + painter.setPen(QPen(Qt::black, 2)); + const int center = kEnemyTankGunCenter; + switch (m_direction) { + case Direction::Up: + painter.drawLine(center, center, center, center - kEnemyTankGunLength); + break; + case Direction::Down: + painter.drawLine(center, center, center, center + kEnemyTankGunLength); + break; + case Direction::Left: + painter.drawLine(center, center, center - kEnemyTankGunLength, center); + break; + case Direction::Right: + painter.drawLine(center, center, center + kEnemyTankGunLength, center); + break; + } + + painter.end(); + setPixmap(pixmap); +} + +QList TwinShooterEnemy::Fire(Direction dir) { + QList bullets; + QPointF pos = this->pos(); + + if (dir == Direction::Up || dir == Direction::Down) { + qreal bx1 = pos.x() + GetWidth() / 2 - 8; + qreal bx2 = pos.x() + GetWidth() / 2 + 8; + qreal by = (dir == Direction::Up) ? pos.y() - 3 : pos.y() + GetHeight() - 3; + bullets.append(new Bullet(bx1, by, dir, BulletOwner::Enemy)); + bullets.append(new Bullet(bx2, by, dir, BulletOwner::Enemy)); + } else { + qreal by1 = pos.y() + GetHeight() / 2 - 8; + qreal by2 = pos.y() + GetHeight() / 2 + 8; + qreal bx = (dir == Direction::Left) ? pos.x() - 3 : pos.x() + GetWidth() - 3; + bullets.append(new Bullet(bx, by1, dir, BulletOwner::Enemy)); + bullets.append(new Bullet(bx, by2, dir, BulletOwner::Enemy)); + } + + return bullets; +} diff --git a/src/GameModel.cpp b/src/GameModel.cpp new file mode 100644 index 0000000..6b24c5d --- /dev/null +++ b/src/GameModel.cpp @@ -0,0 +1,43 @@ +#include "GameModel.h" + +GameModel::GameModel(QObject* parent) : QObject(parent) {} + +void GameModel::ModifyPlayerLives(int delta) { + if (m_gameOver) return; + m_lives += delta; + if (m_lives < 0) m_lives = 0; + emit livesChanged(m_lives); + if (m_lives == 0) { + m_gameOver = true; + emit gameOver(); + } +} + +void GameModel::ModifyScore(int delta) { + if (m_gameOver) return; + m_kills += delta; + if (m_kills < 0) m_kills = 0; + emit scoreChanged(m_kills); +} + +void GameModel::SetGameOver(bool v) { + m_gameOver = v; + if (v) emit gameOver(); +} + +void GameModel::SetGameWon(bool v) { + m_gameWon = v; + if (v) emit gameWon(); +} + +void GameModel::SetLives(int lives) { + m_lives = lives; + if (m_lives < 0) m_lives = 0; + emit livesChanged(m_lives); +} + +void GameModel::SetKills(int kills) { + m_kills = kills; + if (m_kills < 0) m_kills = 0; + emit scoreChanged(m_kills); +} diff --git a/src/GameScane.cpp b/src/GameScane.cpp new file mode 100644 index 0000000..b13f01c --- /dev/null +++ b/src/GameScane.cpp @@ -0,0 +1,644 @@ +#include "GameScane.h" + +#include +#include +#include +#include +#include + +#include "BrickWall.h" +#include "Bullet.h" +#include "EnemyTank.h" +#include "Tank.h" +#include "Wall.h" +#include "Bonus.h" + +#include "GameModel.h" + +#include "GlobalConstants.h" + +static int s_playerFireCooldown = 0; +static GameModel* s_model = nullptr; + +GameScane::GameScane(QObject* parent) + : QGraphicsScene(parent), + m_canFire(true), + m_enemySpawnCooldown(kSpawnCooldown) { + setSceneRect(0, 0, kSceneWidth, kSceneHeight); + setBackgroundBrush(QColor(20, 40, 20)); + + m_playerTank = new Tank(kSceneWidth / 2, kSceneHeight / 2); + addItem(m_playerTank); + + m_livesText = new QGraphicsTextItem(); + m_livesText->setZValue(10); + addItem(m_livesText); + + m_scoreText = new QGraphicsTextItem(); + m_scoreText->setZValue(10); + addItem(m_scoreText); + + InitializeLevel(); + + m_gameTimer.setInterval(1000 / 60); + connect(&m_gameTimer, &QTimer::timeout, this, &GameScane::Update); + m_gameTimer.start(); + + s_model = new GameModel(this); + s_model->SetLives(kInitialPlayerLives); + s_model->SetKills(0); + connect(s_model, &GameModel::livesChanged, this, &GameScane::UpdateLivesDisplay); + connect(s_model, &GameModel::scoreChanged, this, &GameScane::UpdateScoreDisplay); + connect(s_model, &GameModel::gameOver, this, &GameScane::ShowGameOver); + connect(s_model, &GameModel::gameWon, this, &GameScane::ShowWinScreen); + UpdateLivesDisplay(); + UpdateScoreDisplay(); +} + +void GameScane::InitializeLevel() { + const char* levelMap[kMapRows] = { + "WWWWWWWWWWWWWWWWWWWW", + "W W", + "W BBBBBBBBBBBBBBBB W", + "W B W B W", + "W B W B W", + "W B B B W", + "W B WBBBBBBBW B W", + "W B W B W B W", + "W B W B W B W", + "W B W W B W", + "W BBBB BBBBB W", + "W B W B W B W", + "W B W B W B W", + "W B WBBBBBBBW B W", + "W B B B W", + "W B W B W", + "W B W B W", + "W B W B W", + "W BBBBBBBBBBBBBBBB W", + "WWWWWWWWWWWWWWWWWWWW" + }; + + for (int y = 0; y < kMapRows; ++y) { + for (int x = 0; x < kMapCols; ++x) { + char cell = levelMap[y][x]; + qreal posX = x * kTileSize; + qreal posY = y * kTileSize; + + if (cell == 'W') { + auto* wall = new Wall(posX, posY); + m_walls.append(wall); + addItem(wall); + } else if (cell == 'B') { + auto* brick = new BrickWall(posX, posY); + m_brickWalls.append(brick); + addItem(brick); + } else if (cell == ' ') { + m_freeSpawnPoints.append(QPointF(posX, posY)); + } + } + } + + const int kBonusesToSpawn = 4; + for (int i = 0; i < kBonusesToSpawn && !m_freeSpawnPoints.isEmpty(); ++i) { + int idx = QRandomGenerator::global()->bounded(m_freeSpawnPoints.size()); + QPointF spawn = m_freeSpawnPoints.takeAt(idx); + + int r = QRandomGenerator::global()->bounded(0, 3); + if (r == 0) { + auto* bonus = new HealthBonus(spawn.x(), spawn.y()); + m_bonuses.append(bonus); + addItem(bonus); + } else if (r == 1) { + auto* bonus = new MineBonus(spawn.x(), spawn.y()); + m_bonuses.append(bonus); + addItem(bonus); + } else { + auto* bonus = new ScoreBonus(spawn.x(), spawn.y()); + m_bonuses.append(bonus); + addItem(bonus); + } + } +} + +void GameScane::Update() { + if (s_model->IsGameOver() || s_model->IsGameWon()) { + return; + } + + HandlePlayerInputAndMovement(); + SpawnEnemiesIfNeeded(); + UpdateEnemies(); + UpdatePlayerBullets(); + UpdateBonuses(); + UpdateEnemyBullets(); + + if (s_playerFireCooldown > 0) --s_playerFireCooldown; + m_canFire = (s_playerFireCooldown <= 0); +} + +void GameScane::HandlePlayerInputAndMovement() { + Direction desiredDirection = m_playerTank->GetDirection(); + bool shouldMove = false; + + if (m_pressedKeys.contains(Qt::Key_Left)) { + desiredDirection = Direction::Left; + shouldMove = true; + } else if (m_pressedKeys.contains(Qt::Key_Right)) { + desiredDirection = Direction::Right; + shouldMove = true; + } else if (m_pressedKeys.contains(Qt::Key_Up)) { + desiredDirection = Direction::Up; + shouldMove = true; + } else if (m_pressedKeys.contains(Qt::Key_Down)) { + desiredDirection = Direction::Down; + shouldMove = true; + } + + m_playerTank->SetDirection(desiredDirection); + + if (shouldMove) { + QRectF futureRect = m_playerTank->GetFutureRect(desiredDirection); + if (!IsCollidingWithAnyWall(futureRect)) { + m_playerTank->Move(); + } + } + + m_playerTank->Update(); +} + +void GameScane::SpawnEnemiesIfNeeded() { + if (m_enemySpawnCooldown > 0) { + --m_enemySpawnCooldown; + return; + } + + if (m_freeSpawnPoints.isEmpty() || m_enemyTanks.size() >= kMaxEnemies) { + return; + } + + int idx = QRandomGenerator::global()->bounded(m_freeSpawnPoints.size()); + QPointF spawnPos = m_freeSpawnPoints[idx]; + int type = QRandomGenerator::global()->bounded(0, 3); + EnemyTank* enemy = nullptr; + if (type == 0) { + enemy = new LightEnemy(spawnPos.x(), spawnPos.y()); + } else if (type == 1) { + enemy = new HeavyEnemy(spawnPos.x(), spawnPos.y()); + } else { + enemy = new TwinShooterEnemy(spawnPos.x(), spawnPos.y()); + } + m_enemyTanks.append(enemy); + addItem(enemy); + m_enemySpawnCooldown = kSpawnCooldown; +} + +void GameScane::UpdateEnemies() { + for (auto* enemy : m_enemyTanks) { + enemy->Update(); + if (enemy->GetMoveCooldown() <= 0) { + int r = QRandomGenerator::global()->bounded(0, 6); + Direction newDir; + if (r < 3) { + newDir = Direction::Down; + } else if (r == 3) { + newDir = Direction::Left; + } else if (r == 4) { + newDir = Direction::Right; + } else { + newDir = Direction::Up; + } + enemy->SetDirection(newDir); + enemy->ResetMoveTimer(QRandomGenerator::global()->bounded(18, 48)); + } + + Direction dir = enemy->GetDirection(); + QRectF futureRect = enemy->GetFutureRect(dir); + if (!IsCollidingWithAnyWall(futureRect)) { + QPointF pos = enemy->pos(); + switch (dir) { + case Direction::Up: + enemy->setPos(pos.x(), pos.y() - enemy->GetSpeed()); + break; + case Direction::Down: + enemy->setPos(pos.x(), pos.y() + enemy->GetSpeed()); + break; + case Direction::Left: + enemy->setPos(pos.x() - enemy->GetSpeed(), pos.y()); + break; + case Direction::Right: + enemy->setPos(pos.x() + enemy->GetSpeed(), pos.y()); + break; + } + } else { + bool moved = false; + for (int t = 0; t < 4 && !moved; ++t) { + int r = QRandomGenerator::global()->bounded(0, 4); + Direction alt = static_cast(r); + QRectF altRect = enemy->GetFutureRect(alt); + if (!IsCollidingWithAnyWall(altRect)) { + enemy->SetDirection(alt); + QPointF pos = enemy->pos(); + switch (alt) { + case Direction::Up: + enemy->setPos(pos.x(), pos.y() - enemy->GetSpeed()); + break; + case Direction::Down: + enemy->setPos(pos.x(), pos.y() + enemy->GetSpeed()); + break; + case Direction::Left: + enemy->setPos(pos.x() - enemy->GetSpeed(), pos.y()); + break; + case Direction::Right: + enemy->setPos(pos.x() + enemy->GetSpeed(), pos.y()); + break; + } + moved = true; + } + } + } + + if (enemy->GetFireCooldown() <= 0) { + int dirIdx = QRandomGenerator::global()->bounded(0, 4); + Direction fireDir = static_cast(dirIdx); + + auto bullets = enemy->Fire(fireDir); + for (auto* b : bullets) { + m_enemyBullets.append(b); + addItem(b); + } + enemy->ResetFireTimer(QRandomGenerator::global()->bounded(120, 300)); + } + } +} + +void GameScane::UpdatePlayerBullets() { + for (int i = m_bullets.size() - 1; i >= 0; --i) { + auto* bullet = m_bullets[i]; + bullet->Move(); + QRectF bulletRect = bullet->GetBoundingRect(); + + if (!sceneRect().intersects(bulletRect)) { + removeItem(bullet); + delete bullet; + m_bullets.removeAt(i); + continue; + } + + bool hitEnemy = false; + for (int j = m_enemyTanks.size() - 1; j >= 0; --j) { + auto* enemy = m_enemyTanks[j]; + QRectF enemyRect = enemy->boundingRect().translated(enemy->pos()); + if (bulletRect.intersects(enemyRect)) { + enemy->TakeDamage(1); + removeItem(bullet); + delete bullet; + m_bullets.removeAt(i); + + if (enemy->IsDead()) { + removeItem(enemy); + delete enemy; + m_enemyTanks.removeAt(j); + + s_model->ModifyScore(1); + if (s_model->GetKills() >= kWinConditionKills) { + s_model->SetGameWon(true); + } + } + + hitEnemy = true; + break; + } + } + if (hitEnemy) { + continue; + } + + if (IsCollidingWithSolidWall(bulletRect)) { + removeItem(bullet); + delete bullet; + m_bullets.removeAt(i); + continue; + } + + if (auto* brick = IsCollidingWithBrickWall(bulletRect)) { + removeItem(brick); + delete brick; + m_brickWalls.removeAll(brick); + removeItem(bullet); + delete bullet; + m_bullets.removeAt(i); + continue; + } + } +} + +void GameScane::UpdateEnemyBullets() { + for (int i = m_enemyBullets.size() - 1; i >= 0; --i) { + auto* bullet = m_enemyBullets[i]; + bullet->Move(); + QRectF bulletRect = bullet->GetBoundingRect(); + + if (!sceneRect().intersects(bulletRect)) { + removeItem(bullet); + delete bullet; + m_enemyBullets.removeAt(i); + continue; + } + + if (IsCollidingWithSolidWall(bulletRect)) { + removeItem(bullet); + delete bullet; + m_enemyBullets.removeAt(i); + continue; + } + + if (auto* brick = IsCollidingWithBrickWall(bulletRect)) { + removeItem(brick); + delete brick; + m_brickWalls.removeAll(brick); + removeItem(bullet); + delete bullet; + m_enemyBullets.removeAt(i); + continue; + } + + if (!s_model->IsGameOver()) { + QRectF playerRect = m_playerTank->boundingRect().translated(m_playerTank->pos()); + if (bulletRect.intersects(playerRect)) { + removeItem(bullet); + delete bullet; + m_enemyBullets.removeAt(i); + s_model->ModifyPlayerLives(-1); + continue; + } + } + } +} + +void GameScane::UpdateBonuses() { + if (m_bonuses.isEmpty() || !m_playerTank) return; + + QRectF playerRect = m_playerTank->boundingRect().translated(m_playerTank->pos()); + + for (int i = m_bonuses.size() - 1; i >= 0; --i) { + auto* bonus = m_bonuses[i]; + if (!bonus) continue; + + QRectF bonusRect = bonus->boundingRect().translated(bonus->pos()); + if (playerRect.intersects(bonusRect)) { + bonus->Apply(this); + removeItem(bonus); + delete bonus; + m_bonuses.removeAt(i); + } + } +} + +void GameScane::ModifyPlayerLives(int delta) { + if (s_model) s_model->ModifyPlayerLives(delta); +} + +void GameScane::ModifyScore(int delta) { + if (s_model) s_model->ModifyScore(delta); +} + +void GameScane::keyPressEvent(QKeyEvent* event) { + if (event->isAutoRepeat()) { + return; + } + + if ((s_model->IsGameOver() || s_model->IsGameWon()) && + (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return)) { + RestartGame(); + return; + } + + m_pressedKeys.insert(static_cast(event->key())); + + if (event->key() == Qt::Key_Space && m_canFire && !s_model->IsGameOver()) { + FireBullet(); + m_canFire = false; + s_playerFireCooldown = kPlayerFireCooldownFrames; + } + + QGraphicsScene::keyPressEvent(event); +} + +void GameScane::keyReleaseEvent(QKeyEvent* event) { + if (event->isAutoRepeat()) { + return; + } + m_pressedKeys.remove(static_cast(event->key())); + QGraphicsScene::keyReleaseEvent(event); +} + +bool GameScane::IsCollidingWithSolidWall(const QRectF& rect) const { + for (const auto* wall : m_walls) { + if (wall->boundingRect().translated(wall->pos()).intersects(rect)) { + return true; + } + } + return false; +} + +BrickWall* GameScane::IsCollidingWithBrickWall(const QRectF& rect) const { + for (auto* brick : m_brickWalls) { + if (brick->boundingRect().translated(brick->pos()).intersects(rect)) { + return brick; + } + } + return nullptr; +} + +bool GameScane::IsCollidingWithAnyWall(const QRectF& rect) const { + return IsCollidingWithSolidWall(rect) || (IsCollidingWithBrickWall(rect) != nullptr); +} + +void GameScane::FireBullet() { + QPointF tankPos = m_playerTank->pos(); + Direction direction = m_playerTank->GetDirection(); + + constexpr qreal kTankHalf = 16.0; + constexpr qreal kBulletHalf = 3.0; + + qreal offsetX = 0.0; + qreal offsetY = 0.0; + + switch (direction) { + case Direction::Up: + offsetX = kTankHalf - kBulletHalf; + offsetY = -kBulletHalf; + break; + case Direction::Down: + offsetX = kTankHalf - kBulletHalf; + offsetY = 32.0; + break; + case Direction::Left: + offsetX = -kBulletHalf; + offsetY = kTankHalf - kBulletHalf; + break; + case Direction::Right: + offsetX = 32.0; + offsetY = kTankHalf - kBulletHalf; + break; + } + + auto* bullet = new Bullet(tankPos.x() + offsetX, tankPos.y() + offsetY, + direction, BulletOwner::Player); + m_bullets.append(bullet); + addItem(bullet); +} + +void GameScane::ShowGameOver() { + m_overlay = new QGraphicsRectItem(0, 0, kSceneWidth, kSceneHeight); + m_overlay->setBrush(QColor(0, 0, 0, 180)); + m_overlay->setPen(Qt::NoPen); + m_overlay->setZValue(999); + addItem(m_overlay); + + m_gameOverBox = new QGraphicsRectItem(0, 0, 300, 160); + m_gameOverBox->setPos(170, 220); + m_gameOverBox->setBrush(QColor(30, 30, 40)); + m_gameOverBox->setPen(QPen(Qt::red, 3)); + m_gameOverBox->setZValue(1000); + addItem(m_gameOverBox); + + m_gameOverText = new QGraphicsTextItem("GAME OVER"); + m_gameOverText->setFont(QFont("Arial", 28, QFont::Bold)); + m_gameOverText->setDefaultTextColor(Qt::red); + m_gameOverText->setPos(210, 230); + m_gameOverText->setZValue(1001); + addItem(m_gameOverText); + + m_restartText = new QGraphicsTextItem("Enter - Restart"); + m_restartText->setFont(QFont("Arial", 16)); + m_restartText->setDefaultTextColor(Qt::white); + m_restartText->setPos(240, 280); + m_restartText->setZValue(1001); + addItem(m_restartText); + + m_gameTimer.stop(); + for (auto* v : views()) if (v) v->setFocus(); +} + +void GameScane::ShowWinScreen() { + m_winOverlay = new QGraphicsRectItem(0, 0, kSceneWidth, kSceneHeight); + m_winOverlay->setBrush(QColor(0, 0, 0, 180)); + m_winOverlay->setPen(Qt::NoPen); + m_winOverlay->setZValue(999); + addItem(m_winOverlay); + + m_winBox = new QGraphicsRectItem(0, 0, 300, 160); + m_winBox->setPos(170, 220); + m_winBox->setBrush(QColor(20, 30, 20)); + m_winBox->setPen(QPen(Qt::green, 3)); + m_winBox->setZValue(1000); + addItem(m_winBox); + + m_winText = new QGraphicsTextItem("YOU WIN!"); + m_winText->setFont(QFont("Arial", 28, QFont::Bold)); + m_winText->setDefaultTextColor(Qt::green); + m_winText->setPos(230, 230); + m_winText->setZValue(1001); + addItem(m_winText); + + m_winRestartText = new QGraphicsTextItem("Enter - Restart"); + m_winRestartText->setFont(QFont("Arial", 16)); + m_winRestartText->setDefaultTextColor(Qt::white); + m_winRestartText->setPos(240, 280); + m_winRestartText->setZValue(1001); + addItem(m_winRestartText); + + m_gameTimer.stop(); + for (auto* v : views()) if (v) v->setFocus(); +} + +void GameScane::UpdateLivesDisplay() { + int lives = s_model ? s_model->GetLives() : 0; + m_livesText->setPlainText(QString("Lives: %1").arg(lives)); + m_livesText->setDefaultTextColor(Qt::white); + m_livesText->setFont(QFont("Arial", 16, QFont::Bold)); + m_livesText->setPos(5, 5); +} + +void GameScane::UpdateScoreDisplay() { + int kills = s_model ? s_model->GetKills() : 0; + m_scoreText->setPlainText(QString("Kills: %1").arg(kills)); + m_scoreText->setDefaultTextColor(Qt::yellow); + m_scoreText->setFont(QFont("Arial", 16, QFont::Bold)); + m_scoreText->setPos(513, 5); +} + +void GameScane::RestartGame() { + auto cleanup = [this](auto& container) { + for (auto* item : container) { + removeItem(item); + delete item; + } + container.clear(); + }; + + if (m_playerTank) { + removeItem(m_playerTank); + delete m_playerTank; + m_playerTank = nullptr; + } + + cleanup(m_walls); + cleanup(m_brickWalls); + cleanup(m_bullets); + cleanup(m_enemyBullets); + cleanup(m_enemyTanks); + cleanup(m_bonuses); + + + auto cleanupOptional = [this](auto& ptr) { + if (ptr) { + removeItem(ptr); + delete ptr; + ptr = nullptr; + } + }; + + cleanupOptional(m_overlay); + cleanupOptional(m_gameOverBox); + cleanupOptional(m_gameOverText); + cleanupOptional(m_restartText); + cleanupOptional(m_winOverlay); + cleanupOptional(m_winBox); + cleanupOptional(m_winText); + cleanupOptional(m_winRestartText); + cleanupOptional(m_livesText); + cleanupOptional(m_scoreText); + + m_freeSpawnPoints.clear(); + m_canFire = true; + m_enemySpawnCooldown = kSpawnCooldown; + + m_playerTank = new Tank(kSceneWidth / 2, kSceneHeight / 2); + addItem(m_playerTank); + + InitializeLevel(); + + m_livesText = new QGraphicsTextItem(); + m_livesText->setZValue(10); + addItem(m_livesText); + + m_scoreText = new QGraphicsTextItem(); + m_scoreText->setZValue(10); + addItem(m_scoreText); + + if (s_model) { + s_model->SetLives(kInitialPlayerLives); + s_model->SetKills(0); + s_model->SetGameOver(false); + s_model->SetGameWon(false); + } + + UpdateLivesDisplay(); + UpdateScoreDisplay(); + + m_gameTimer.start(); + for (auto* v : views()) if (v) v->setFocus(); +} diff --git a/src/Tank.cpp b/src/Tank.cpp new file mode 100644 index 0000000..bb6b757 --- /dev/null +++ b/src/Tank.cpp @@ -0,0 +1,110 @@ +#include "Tank.h" + +#include +#include + +#include "GlobalConstants.h" + +Tank::Tank(qreal x, qreal y, QObject* ) + : m_direction(Direction::Up) { + setPos(x, y); + setZValue(1); + UpdatePixmap(); +} + +void Tank::SetDirection(Direction direction) { + if (m_direction == direction) { + return; + } + m_direction = direction; + UpdatePixmap(); +} + +Direction Tank::GetDirection() const { + return m_direction; +} + +void Tank::Move() { + QPointF current_pos = pos(); + switch (m_direction) { + case Direction::Up: + setPos(current_pos.x(), current_pos.y() - kTankSpeed); + break; + case Direction::Down: + setPos(current_pos.x(), current_pos.y() + kTankSpeed); + break; + case Direction::Left: + setPos(current_pos.x() - kTankSpeed, current_pos.y()); + break; + case Direction::Right: + setPos(current_pos.x() + kTankSpeed, current_pos.y()); + break; + } +} + +QRectF Tank::GetFutureRect(Direction dir) const { + qreal new_x = pos().x(); + qreal new_y = pos().y(); + + switch (dir) { + case Direction::Up: + new_y -= kSpeed; + break; + case Direction::Down: + new_y += kSpeed; + break; + case Direction::Left: + new_x -= kSpeed; + break; + case Direction::Right: + new_x += kSpeed; + break; + } + + const qreal collisionSize = static_cast(kTankSize - 2 * kCollisionInset); + return QRectF(new_x + kCollisionInset, new_y + kCollisionInset, collisionSize, collisionSize); +} + +void Tank::Update() { +} + +void Tank::UpdatePixmap() { + QPixmap pixmap(kTankSize, kTankSize); + pixmap.fill(Qt::transparent); + + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + + painter.fillRect(kTankBodyX, kTankBodyY, kTankBodyWidth, kTankBodyHeight, + QColor(50, 205, 50)); + + + painter.fillRect(kTankTrackLeftX, 10, kTankTrackWidth, kTankTrackHeight, QColor(0, 100, 0)); + painter.fillRect(kTankTrackRightX, 10, kTankTrackWidth, kTankTrackHeight, QColor(0, 100, 0)); + + + painter.fillRect(kTankTurretX, kTankTurretY, kTankTurretSize, kTankTurretSize, + QColor(34, 139, 34)); + + + painter.setPen(QPen(Qt::black, 2)); + const int center = kTankGunCenter; + switch (m_direction) { + case Direction::Up: + painter.drawLine(center, center, center, center - kTankGunLength); + break; + case Direction::Down: + painter.drawLine(center, center, center, center + kTankGunLength); + break; + case Direction::Left: + painter.drawLine(center, center, center - kTankGunLength, center); + break; + case Direction::Right: + painter.drawLine(center, center, center + kTankGunLength, center); + break; + } + + painter.end(); + setPixmap(pixmap); +} diff --git a/src/Wall.cpp b/src/Wall.cpp new file mode 100644 index 0000000..f9da40f --- /dev/null +++ b/src/Wall.cpp @@ -0,0 +1,44 @@ +#include "Wall.h" + +#include +#include + +#include "GlobalConstants.h" + +Wall::Wall(qreal x, qreal y) { + setPos(x, y); + setZValue(0); + + QPixmap pixmap(kWallSize, kWallSize); + pixmap.fill(Qt::transparent); + + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(0, 0, kWallSize, kWallSize, QColor(60, 60, 60)); + + const QColor panelColor(90, 90, 90); + painter.fillRect(2, 2, kPanelSize, kPanelSize, panelColor); + painter.fillRect(18, 2, kPanelSize, kPanelSize, panelColor); + painter.fillRect(2, 18, kPanelSize, kPanelSize, panelColor); + painter.fillRect(18, 18, kPanelSize, kPanelSize, panelColor); + + painter.setPen(Qt::NoPen); + painter.setBrush(Qt::black); + const struct { int x; int y; } rivets[] = { + {4, 4}, {12, 4}, {4, 12}, {12, 12}, + {20, 4}, {28, 4}, {20, 12}, {28, 12}, + {4, 20}, {12, 20}, {4, 28}, {12, 28}, + {20, 20},{28, 20},{20, 28}, {28, 28} + }; + for (const auto& r : rivets) { + painter.drawEllipse(r.x - kRivetRadius, r.y - kRivetRadius, + 2 * kRivetRadius, 2 * kRivetRadius); + } + + painter.setPen(QPen(QColor(30, 30, 30), 2)); + painter.drawRect(0, 0, kWallSize - 1, kWallSize - 1); + + painter.end(); + setPixmap(pixmap); +} diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..437d145 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,19 @@ +#include +#include +#include "GameScane.h" +#include "GlobalConstants.h" + +int main(int argc, char* argv[]) { + QApplication app(argc, argv); + + GameScane* scene = new GameScane(); + QGraphicsView* view = new QGraphicsView(scene); + + view->setFixedSize(kSceneWidth, kSceneHeight); + view->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + view->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); + view->setWindowTitle("ТанкиNSU"); + view->show(); + + return app.exec(); +} From 28847b03aa4f3800c775fbd8df497c396dfa29e8 Mon Sep 17 00:00:00 2001 From: frankyshelloy Date: Tue, 9 Dec 2025 03:18:20 +0700 Subject: [PATCH 02/13] Some fixes --- CMakeLists.txt | 3 + cmake-build-debug/CMakeCache.txt | 357 + .../CMakeFiles/3.31.6/CMakeCXXCompiler.cmake | 105 + .../3.31.6/CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 16064 bytes .../CMakeFiles/3.31.6/CMakeSystem.cmake | 15 + .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 919 ++ .../CMakeFiles/3.31.6/CompilerIdCXX/a.out | Bin 0 -> 16168 bytes .../CMakeFiles/CMakeConfigureLog.yaml | 294 + .../CMakeDirectoryInformation.cmake | 16 + .../CMakeFiles/CMakeRuleHashes.txt | 3 + cmake-build-debug/CMakeFiles/Makefile.cmake | 101 + cmake-build-debug/CMakeFiles/Makefile2 | 189 + .../CMakeFiles/TanksGame.dir/DependInfo.cmake | 37 + .../TanksGame_autogen/mocs_compilation.cpp.o | Bin 0 -> 73912 bytes .../mocs_compilation.cpp.o.d | 362 + .../CMakeFiles/TanksGame.dir/build.make | 318 + .../TanksGame.dir/cmake_clean.cmake | 41 + .../TanksGame.dir/compiler_depend.internal | 9657 ++++++++++++++ .../TanksGame.dir/compiler_depend.make | 10928 ++++++++++++++++ .../TanksGame.dir/compiler_depend.ts | 2 + .../CMakeFiles/TanksGame.dir/depend.make | 2 + .../CMakeFiles/TanksGame.dir/flags.make | 10 + .../CMakeFiles/TanksGame.dir/link.d | 223 + .../CMakeFiles/TanksGame.dir/link.txt | 1 + .../CMakeFiles/TanksGame.dir/progress.make | 16 + .../CMakeFiles/TanksGame.dir/src/Bonus.cpp.o | Bin 0 -> 45296 bytes .../TanksGame.dir/src/Bonus.cpp.o.d | 373 + .../TanksGame.dir/src/BrickWall.cpp.o | Bin 0 -> 37232 bytes .../TanksGame.dir/src/BrickWall.cpp.o.d | 346 + .../CMakeFiles/TanksGame.dir/src/Bullet.cpp.o | Bin 0 -> 37600 bytes .../TanksGame.dir/src/Bullet.cpp.o.d | 341 + .../TanksGame.dir/src/EnemyTank.cpp.o | Bin 0 -> 100000 bytes .../TanksGame.dir/src/EnemyTank.cpp.o.d | 380 + .../TanksGame.dir/src/GameModel.cpp.o | Bin 0 -> 10344 bytes .../TanksGame.dir/src/GameModel.cpp.o.d | 304 + .../TanksGame.dir/src/GameScane.cpp.o | Bin 0 -> 304112 bytes .../TanksGame.dir/src/GameScane.cpp.o.d | 420 + .../TanksGame.dir/src/HeavyEnemy.cpp.o | Bin 0 -> 39096 bytes .../TanksGame.dir/src/HeavyEnemy.cpp.o.d | 352 + .../TanksGame.dir/src/LightEnemy.cpp.o | Bin 0 -> 39096 bytes .../TanksGame.dir/src/LightEnemy.cpp.o.d | 352 + .../CMakeFiles/TanksGame.dir/src/Tank.cpp.o | Bin 0 -> 41888 bytes .../CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d | 348 + .../TanksGame.dir/src/TwinShooterEnemy.cpp.o | Bin 0 -> 92680 bytes .../src/TwinShooterEnemy.cpp.o.d | 353 + .../CMakeFiles/TanksGame.dir/src/Wall.cpp.o | Bin 0 -> 39464 bytes .../CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d | 346 + .../CMakeFiles/TanksGame.dir/src/main.cpp.o | Bin 0 -> 31448 bytes .../CMakeFiles/TanksGame.dir/src/main.cpp.o.d | 388 + .../TanksGame_autogen.dir/AutogenInfo.json | 231 + .../TanksGame_autogen.dir/AutogenUsed.txt | 2 + .../TanksGame_autogen.dir/DependInfo.cmake | 23 + .../TanksGame_autogen.dir/ParseCache.txt | 697 + .../TanksGame_autogen.dir/build.make | 97 + .../TanksGame_autogen.dir/cmake_clean.cmake | 10 + .../compiler_depend.internal | 7121 ++++++++++ .../compiler_depend.make | 8158 ++++++++++++ .../TanksGame_autogen.dir/compiler_depend.ts | 2 + .../TanksGame_autogen.dir/progress.make | 2 + .../DependInfo.cmake | 22 + .../build.make | 86 + .../cmake_clean.cmake | 5 + .../compiler_depend.make | 2 + .../compiler_depend.ts | 2 + .../progress.make | 1 + .../CMakeFiles/TargetDirectories.txt | 5 + .../CMakeFiles/cmake.check_cache | 1 + cmake-build-debug/CMakeFiles/progress.marks | 1 + cmake-build-debug/Makefile | 533 + cmake-build-debug/TanksGame | Bin 0 -> 341248 bytes .../6YEA5652QU/moc_GameModel.cpp | 228 + .../6YEA5652QU/moc_GameModel.cpp.d | 309 + .../6YEA5652QU/moc_GameScane.cpp | 119 + .../6YEA5652QU/moc_GameScane.cpp.d | 371 + cmake-build-debug/TanksGame_autogen/deps | 457 + .../TanksGame_autogen/moc_predefs.h | 487 + .../TanksGame_autogen/mocs_compilation.cpp | 3 + cmake-build-debug/TanksGame_autogen/timestamp | 0 cmake-build-debug/cmake_install.cmake | 66 + include/EnemyTank.h | 69 +- include/GameScane.h | 9 +- include/GlobalConstants.h | 8 + include/HeavyEnemy.h | 10 + include/LightEnemy.h | 10 + include/Tank.h | 1 + include/TwinShooterEnemy.h | 11 + src/EnemyTank.cpp | 184 +- src/GameModel.cpp | 43 +- src/GameScane.cpp | 83 +- src/HeavyEnemy.cpp | 36 + src/LightEnemy.cpp | 34 + src/Tank.cpp | 40 +- src/TwinShooterEnemy.cpp | 58 + 93 files changed, 47259 insertions(+), 280 deletions(-) create mode 100644 cmake-build-debug/CMakeCache.txt create mode 100644 cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake create mode 100755 cmake-build-debug/CMakeFiles/3.31.6/CMakeDetermineCompilerABI_CXX.bin create mode 100644 cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake create mode 100644 cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100755 cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/a.out create mode 100644 cmake-build-debug/CMakeFiles/CMakeConfigureLog.yaml create mode 100644 cmake-build-debug/CMakeFiles/CMakeDirectoryInformation.cmake create mode 100644 cmake-build-debug/CMakeFiles/CMakeRuleHashes.txt create mode 100644 cmake-build-debug/CMakeFiles/Makefile.cmake create mode 100644 cmake-build-debug/CMakeFiles/Makefile2 create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/DependInfo.cmake create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/build.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/cmake_clean.cmake create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.ts create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/depend.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/flags.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/link.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/link.txt create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/progress.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bullet.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bullet.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameModel.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameModel.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameScane.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameScane.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/main.cpp.o create mode 100644 cmake-build-debug/CMakeFiles/TanksGame.dir/src/main.cpp.o.d create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/AutogenInfo.json create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/AutogenUsed.txt create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/DependInfo.cmake create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/ParseCache.txt create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/build.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/cmake_clean.cmake create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.ts create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/progress.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen_timestamp_deps.dir/DependInfo.cmake create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen_timestamp_deps.dir/build.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen_timestamp_deps.dir/cmake_clean.cmake create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen_timestamp_deps.dir/compiler_depend.make create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen_timestamp_deps.dir/compiler_depend.ts create mode 100644 cmake-build-debug/CMakeFiles/TanksGame_autogen_timestamp_deps.dir/progress.make create mode 100644 cmake-build-debug/CMakeFiles/TargetDirectories.txt create mode 100644 cmake-build-debug/CMakeFiles/cmake.check_cache create mode 100644 cmake-build-debug/CMakeFiles/progress.marks create mode 100644 cmake-build-debug/Makefile create mode 100755 cmake-build-debug/TanksGame create mode 100644 cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp create mode 100644 cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp.d create mode 100644 cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp create mode 100644 cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d create mode 100644 cmake-build-debug/TanksGame_autogen/deps create mode 100644 cmake-build-debug/TanksGame_autogen/moc_predefs.h create mode 100644 cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp create mode 100644 cmake-build-debug/TanksGame_autogen/timestamp create mode 100644 cmake-build-debug/cmake_install.cmake create mode 100644 include/HeavyEnemy.h create mode 100644 include/LightEnemy.h create mode 100644 include/TwinShooterEnemy.h create mode 100644 src/HeavyEnemy.cpp create mode 100644 src/LightEnemy.cpp create mode 100644 src/TwinShooterEnemy.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 3a44dfe..0d754c6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,6 +19,9 @@ add_executable(TanksGame src/Bonus.cpp src/Tank.cpp src/EnemyTank.cpp + src/LightEnemy.cpp + src/HeavyEnemy.cpp + src/TwinShooterEnemy.cpp src/Wall.cpp src/BrickWall.cpp src/Bullet.cpp diff --git a/cmake-build-debug/CMakeCache.txt b/cmake-build-debug/CMakeCache.txt new file mode 100644 index 0000000..5deb6a6 --- /dev/null +++ b/cmake-build-debug/CMakeCache.txt @@ -0,0 +1,357 @@ +# This is the CMakeCache file. +# For build in directory: /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//Choose the type of build, options are: None Debug Release RelWithDebInfo +// MinSizeRel ... +CMAKE_BUILD_TYPE:STRING= + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//CXX compiler +CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++ + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-14 + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-14 + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/pkgRedirects + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/gmake + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=TanksGame + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/usr/bin/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//Path to a program. +CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//The directory containing a CMake configuration file for Qt5Core. +Qt5Core_DIR:PATH=/usr/lib/x86_64-linux-gnu/cmake/Qt5Core + +//The directory containing a CMake configuration file for Qt5Gui. +Qt5Gui_DIR:PATH=/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui + +//The directory containing a CMake configuration file for Qt5Multimedia. +Qt5Multimedia_DIR:PATH=/usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia + +//The directory containing a CMake configuration file for Qt5Network. +Qt5Network_DIR:PATH=/usr/lib/x86_64-linux-gnu/cmake/Qt5Network + +//The directory containing a CMake configuration file for Qt5Widgets. +Qt5Widgets_DIR:PATH=/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets + +//The directory containing a CMake configuration file for Qt5. +Qt5_DIR:PATH=/usr/lib/x86_64-linux-gnu/cmake/Qt5 + +//Value Computed by CMake +TanksGame_BINARY_DIR:STATIC=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug + +//Value Computed by CMake +TanksGame_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +TanksGame_SOURCE_DIR:STATIC=/home/frankyshelloy/CLionProjects/TankiGame + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=31 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=6 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/frankyshelloy/CLionProjects/TankiGame +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.31 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_TAPI +CMAKE_TAPI-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 +//linker supports push/pop state +_CMAKE_CXX_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE +//linker supports push/pop state +_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE + diff --git a/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake b/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..169926d --- /dev/null +++ b/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake @@ -0,0 +1,105 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "14.2.0") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17") +set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON") +set(CMAKE_CXX_STANDARD_LATEST "26") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20;cxx_std_23;cxx_std_26") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") +set(CMAKE_CXX23_COMPILE_FEATURES "cxx_std_23") +set(CMAKE_CXX26_COMPILE_FEATURES "cxx_std_26") + +set(CMAKE_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU") +set(CMAKE_CXX_SIMULATE_VERSION "") + + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-14") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-14") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_LINKER_LINK "") +set(CMAKE_LINKER_LLD "") +set(CMAKE_CXX_COMPILER_LINKER "/usr/bin/ld") +set(CMAKE_CXX_COMPILER_LINKER_ID "GNU") +set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.44) +set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU) +set(CMAKE_MT "") +set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang IN ITEMS C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED ) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/14;/usr/include/x86_64-linux-gnu/c++/14;/usr/include/c++/14/backward;/usr/lib/gcc/x86_64-linux-gnu/14/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/14;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") +set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "") + +set(CMAKE_CXX_COMPILER_IMPORT_STD "") +### Imported target for C++23 standard library +set(CMAKE_CXX23_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE "Unsupported generator: Unix Makefiles") + + +### Imported target for C++26 standard library +set(CMAKE_CXX26_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE "Unsupported generator: Unix Makefiles") + + + diff --git a/cmake-build-debug/CMakeFiles/3.31.6/CMakeDetermineCompilerABI_CXX.bin b/cmake-build-debug/CMakeFiles/3.31.6/CMakeDetermineCompilerABI_CXX.bin new file mode 100755 index 0000000000000000000000000000000000000000..a0ed30a7c86d11473a7d572b8016085ec2b1bf2d GIT binary patch literal 16064 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 literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake b/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake new file mode 100644 index 0000000..6c21a52 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-6.14.0-36-generic") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "6.14.0-36-generic") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-6.14.0-36-generic") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "6.14.0-36-generic") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/CMakeCXXCompilerId.cpp b/cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..3b6e114 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,919 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define COMPILER_ID "IBMClang" +# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) + + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(__clang__) && defined(__cray__) +# define COMPILER_ID "CrayClang" +# define COMPILER_VERSION_MAJOR DEC(__cray_major__) +# define COMPILER_VERSION_MINOR DEC(__cray_minor__) +# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define COMPILER_ID "FujitsuClang" +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define COMPILER_ID "Tasking" + # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__ORANGEC__) +# define COMPILER_ID "OrangeC" +# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__) + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) && defined(__ti__) +# define COMPILER_ID "TIClang" + # define COMPILER_VERSION_MAJOR DEC(__ti_major__) + # define COMPILER_VERSION_MINOR DEC(__ti_minor__) + # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__) +# define COMPILER_VERSION_INTERNAL DEC(__ti_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define COMPILER_ID "LCC" +# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define SIMULATE_ID "GNU" +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "ARM" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#define CXX_STD_98 199711L +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) +# if _MSVC_LANG > CXX_STD_17 +# define CXX_STD _MSVC_LANG +# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17 +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 +# define CXX_STD CXX_STD_17 +# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# elif defined(__INTEL_CXX11_MODE__) +# define CXX_STD CXX_STD_11 +# else +# define CXX_STD CXX_STD_98 +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__NVCOMPILER) +# if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__INTEL_COMPILER) || defined(__PGI) +# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes) +# define CXX_STD CXX_STD_17 +# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__) +# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__) +# define CXX_STD CXX_STD_11 +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "98" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/a.out b/cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/a.out new file mode 100755 index 0000000000000000000000000000000000000000..083c1d629a1428b8b6aa853d127391174548c2e0 GIT binary patch literal 16168 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 Bf%X6Z literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/CMakeConfigureLog.yaml b/cmake-build-debug/CMakeFiles/CMakeConfigureLog.yaml new file mode 100644 index 0000000..2782c13 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,294 @@ + +--- +events: + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-3.31/Modules/CMakeDetermineSystem.cmake:205 (message)" + - "CMakeLists.txt:2 (project)" + message: | + The system is: Linux - 6.14.0-36-generic - x86_64 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-3.31/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/share/cmake-3.31/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/share/cmake-3.31/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:2 (project)" + message: | + Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. + Compiler: /usr/bin/c++ + Build flags: + Id flags: + + The output was: + 0 + + + Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + + The CXX compiler identification is GNU, found in: + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CompilerIdCXX/a.out + + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake-3.31/Modules/CMakeDetermineCompilerABI.cmake:74 (try_compile)" + - "/usr/share/cmake-3.31/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + checks: + - "Detecting CXX compiler ABI info" + directories: + source: "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/CMakeScratch/TryCompile-auAw5T" + binary: "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/CMakeScratch/TryCompile-auAw5T" + cmakeVariables: + CMAKE_CXX_FLAGS: "" + CMAKE_CXX_FLAGS_DEBUG: "-g" + CMAKE_CXX_SCAN_FOR_MODULES: "OFF" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_CXX_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/CMakeScratch/TryCompile-auAw5T' + + Run Build Command(s): /usr/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_4b126/fast + /usr/bin/gmake -f CMakeFiles/cmTC_4b126.dir/build.make CMakeFiles/cmTC_4b126.dir/build + gmake[1]: Entering directory '/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/CMakeScratch/TryCompile-auAw5T' + Building CXX object CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o + /usr/bin/c++ -v -o CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 14.2.0-19ubuntu2' --with-bugurl=file:///usr/share/doc/gcc-14/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2,rust --prefix=/usr --with-gcc-major-version-only --program-suffix=-14 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.0 (Ubuntu 14.2.0-19ubuntu2) + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4b126.dir/' + /usr/libexec/gcc/x86_64-linux-gnu/14/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_4b126.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccNY2We7.s + GNU C++17 (Ubuntu 14.2.0-19ubuntu2) version 14.2.0 (x86_64-linux-gnu) + compiled by GNU C version 14.2.0, GMP version 6.3.0, MPFR version 4.2.2, MPC version 1.3.1, isl version isl-0.27-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/14" + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/14/include-fixed/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/14/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /usr/include/c++/14 + /usr/include/x86_64-linux-gnu/c++/14 + /usr/include/c++/14/backward + /usr/lib/gcc/x86_64-linux-gnu/14/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + Compiler executable checksum: 5018c062212e1c72e1ce61830114a4ab + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4b126.dir/' + as -v --64 -o CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccNY2We7.s + GNU assembler version 2.44 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.44 + COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.' + Linking CXX executable cmTC_4b126 + /usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_4b126.dir/link.txt --verbose=1 + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-linux-gnu/14/lto-wrapper + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 14.2.0-19ubuntu2' --with-bugurl=file:///usr/share/doc/gcc-14/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2,rust --prefix=/usr --with-gcc-major-version-only --program-suffix=-14 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 14.2.0 (Ubuntu 14.2.0-19ubuntu2) + COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_4b126' '-foffload-options=-l_GCC_m' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_4b126.' + /usr/libexec/gcc/x86_64-linux-gnu/14/collect2 -plugin /usr/libexec/gcc/x86_64-linux-gnu/14/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/14/lto-wrapper -plugin-opt=-fresolution=/tmp/cc92Up4r.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4b126 /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/14 -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/14/../../.. -v CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o + collect2 version 14.2.0 + /usr/bin/ld -plugin /usr/libexec/gcc/x86_64-linux-gnu/14/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/14/lto-wrapper -plugin-opt=-fresolution=/tmp/cc92Up4r.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4b126 /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/14 -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/14/../../.. -v CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o + GNU ld (GNU Binutils for Ubuntu) 2.44 + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_4b126' '-foffload-options=-l_GCC_m' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_4b126.' + /usr/bin/c++ -v -Wl,-v CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_4b126 + gmake[1]: Leaving directory '/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/CMakeScratch/TryCompile-auAw5T' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-3.31/Modules/CMakeDetermineCompilerABI.cmake:182 (message)" + - "/usr/share/cmake-3.31/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CXX implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/usr/include/c++/14] + add: [/usr/include/x86_64-linux-gnu/c++/14] + add: [/usr/include/c++/14/backward] + add: [/usr/lib/gcc/x86_64-linux-gnu/14/include] + add: [/usr/local/include] + add: [/usr/include/x86_64-linux-gnu] + add: [/usr/include] + end of search list found + collapse include dir [/usr/include/c++/14] ==> [/usr/include/c++/14] + collapse include dir [/usr/include/x86_64-linux-gnu/c++/14] ==> [/usr/include/x86_64-linux-gnu/c++/14] + collapse include dir [/usr/include/c++/14/backward] ==> [/usr/include/c++/14/backward] + collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/14/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/14/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/usr/include/c++/14;/usr/include/x86_64-linux-gnu/c++/14;/usr/include/c++/14/backward;/usr/lib/gcc/x86_64-linux-gnu/14/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-3.31/Modules/CMakeDetermineCompilerABI.cmake:218 (message)" + - "/usr/share/cmake-3.31/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Parsed CXX implicit link information: + link line regex: [^( *|.*[/\\])(ld[0-9]*(\\.[a-z]+)?|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + linker tool regex: [^[ ]*(->|")?[ ]*(([^"]*[/\\])?(ld[0-9]*(\\.[a-z]+)?))("|,| |$)] + ignore line: [Change Dir: '/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/CMakeScratch/TryCompile-auAw5T'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_4b126/fast] + ignore line: [/usr/bin/gmake -f CMakeFiles/cmTC_4b126.dir/build.make CMakeFiles/cmTC_4b126.dir/build] + ignore line: [gmake[1]: Entering directory '/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/CMakeScratch/TryCompile-auAw5T'] + ignore line: [Building CXX object CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o] + ignore line: [/usr/bin/c++ -v -o CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 14.2.0-19ubuntu2' --with-bugurl=file:///usr/share/doc/gcc-14/README.Bugs --enable-languages=c ada c++ go d fortran objc obj-c++ m2 rust --prefix=/usr --with-gcc-major-version-only --program-suffix=-14 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.0 (Ubuntu 14.2.0-19ubuntu2) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4b126.dir/'] + ignore line: [ /usr/libexec/gcc/x86_64-linux-gnu/14/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-3.31/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_4b126.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -o /tmp/ccNY2We7.s] + ignore line: [GNU C++17 (Ubuntu 14.2.0-19ubuntu2) version 14.2.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 14.2.0 GMP version 6.3.0 MPFR version 4.2.2 MPC version 1.3.1 isl version isl-0.27-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/14"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/14/include-fixed/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/14/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /usr/include/c++/14] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/14] + ignore line: [ /usr/include/c++/14/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/14/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [Compiler executable checksum: 5018c062212e1c72e1ce61830114a4ab] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4b126.dir/'] + ignore line: [ as -v --64 -o CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccNY2We7.s] + ignore line: [GNU assembler version 2.44 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.44] + ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.'] + ignore line: [Linking CXX executable cmTC_4b126] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_4b126.dir/link.txt --verbose=1] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-linux-gnu/14/lto-wrapper] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 14.2.0-19ubuntu2' --with-bugurl=file:///usr/share/doc/gcc-14/README.Bugs --enable-languages=c ada c++ go d fortran objc obj-c++ m2 rust --prefix=/usr --with-gcc-major-version-only --program-suffix=-14 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-14-C86vgL/gcc-14-14.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 14.2.0 (Ubuntu 14.2.0-19ubuntu2) ] + ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/14/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/14/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/14/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_4b126' '-foffload-options=-l_GCC_m' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_4b126.'] + link line: [ /usr/libexec/gcc/x86_64-linux-gnu/14/collect2 -plugin /usr/libexec/gcc/x86_64-linux-gnu/14/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/14/lto-wrapper -plugin-opt=-fresolution=/tmp/cc92Up4r.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4b126 /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/14 -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/14/../../.. -v CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/libexec/gcc/x86_64-linux-gnu/14/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/libexec/gcc/x86_64-linux-gnu/14/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/14/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/cc92Up4r.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-znow] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_4b126] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/14] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/14] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/14/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/14/../../..] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o] + ignore line: [collect2 version 14.2.0] + ignore line: [/usr/bin/ld -plugin /usr/libexec/gcc/x86_64-linux-gnu/14/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/14/lto-wrapper -plugin-opt=-fresolution=/tmp/cc92Up4r.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_4b126 /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/14 -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/14/../../.. -v CMakeFiles/cmTC_4b126.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o] + linker tool for 'CXX': /usr/bin/ld + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o] ==> [/usr/lib/x86_64-linux-gnu/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o] ==> [/usr/lib/x86_64-linux-gnu/crti.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o] ==> [/usr/lib/x86_64-linux-gnu/crtn.o] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/14] ==> [/usr/lib/gcc/x86_64-linux-gnu/14] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/14/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/14/../../..] ==> [/usr/lib] + implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/x86_64-linux-gnu/Scrt1.o;/usr/lib/x86_64-linux-gnu/crti.o;/usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o;/usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o;/usr/lib/x86_64-linux-gnu/crtn.o] + implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/14;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-3.31/Modules/Internal/CMakeDetermineLinkerId.cmake:40 (message)" + - "/usr/share/cmake-3.31/Modules/CMakeDetermineCompilerABI.cmake:255 (cmake_determine_linker_id)" + - "/usr/share/cmake-3.31/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:2 (project)" + message: | + Running the CXX compiler's linker: "/usr/bin/ld" "-v" + GNU ld (GNU Binutils for Ubuntu) 2.44 +... diff --git a/cmake-build-debug/CMakeFiles/CMakeDirectoryInformation.cmake b/cmake-build-debug/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000..e2e1357 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.31 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/frankyshelloy/CLionProjects/TankiGame") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/cmake-build-debug/CMakeFiles/CMakeRuleHashes.txt b/cmake-build-debug/CMakeFiles/CMakeRuleHashes.txt new file mode 100644 index 0000000..a6d01c7 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/CMakeRuleHashes.txt @@ -0,0 +1,3 @@ +# Hashes of file build rules. +b6a56ef266d3a4e9ec3de13dbf39aa92 CMakeFiles/TanksGame_autogen +9f9cea12e86e8f086fe0e06a997c4509 TanksGame_autogen/timestamp diff --git a/cmake-build-debug/CMakeFiles/Makefile.cmake b/cmake-build-debug/CMakeFiles/Makefile.cmake new file mode 100644 index 0000000..eb6803a --- /dev/null +++ b/cmake-build-debug/CMakeFiles/Makefile.cmake @@ -0,0 +1,101 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.31 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "/home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt" + "CMakeFiles/3.31.6/CMakeCXXCompiler.cmake" + "CMakeFiles/3.31.6/CMakeSystem.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake" + "/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake" + "/usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake" + "/usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake" + "/usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake" + "/usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake" + "/usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake" + "/usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake" + "/usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake" + "/usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake" + "/usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + "/usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake" + "/usr/share/cmake-3.31/Modules/Compiler/GNU.cmake" + "/usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake" + "/usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake" + "/usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake" + "/usr/share/cmake-3.31/Modules/Linker/GNU.cmake" + "/usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake" + "/usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake" + "/usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake" + "/usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake" + "/usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake" + "/usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake" + "/usr/share/cmake-3.31/Modules/Platform/Linux.cmake" + "/usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/TanksGame_autogen.dir/AutogenInfo.json" + "CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/TanksGame.dir/DependInfo.cmake" + "CMakeFiles/TanksGame_autogen_timestamp_deps.dir/DependInfo.cmake" + "CMakeFiles/TanksGame_autogen.dir/DependInfo.cmake" + ) diff --git a/cmake-build-debug/CMakeFiles/Makefile2 b/cmake-build-debug/CMakeFiles/Makefile2 new file mode 100644 index 0000000..449ac33 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/Makefile2 @@ -0,0 +1,189 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.31 + +# Default target executed when no arguments are given to make. +default_target: all +.PHONY : default_target + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/frankyshelloy/CLionProjects/TankiGame + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug + +#============================================================================= +# Directory level rules for the build root directory + +# The main recursive "all" target. +all: CMakeFiles/TanksGame.dir/all +.PHONY : all + +# The main recursive "codegen" target. +codegen: CMakeFiles/TanksGame.dir/codegen +.PHONY : codegen + +# The main recursive "preinstall" target. +preinstall: +.PHONY : preinstall + +# The main recursive "clean" target. +clean: CMakeFiles/TanksGame.dir/clean +clean: CMakeFiles/TanksGame_autogen_timestamp_deps.dir/clean +clean: CMakeFiles/TanksGame_autogen.dir/clean +.PHONY : clean + +#============================================================================= +# Target rules for target CMakeFiles/TanksGame.dir + +# All Build rule for target. +CMakeFiles/TanksGame.dir/all: CMakeFiles/TanksGame_autogen_timestamp_deps.dir/all +CMakeFiles/TanksGame.dir/all: CMakeFiles/TanksGame_autogen.dir/all + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame.dir/build.make CMakeFiles/TanksGame.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame.dir/build.make CMakeFiles/TanksGame.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 "Built target TanksGame" +.PHONY : CMakeFiles/TanksGame.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/TanksGame.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles 16 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/TanksGame.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles 0 +.PHONY : CMakeFiles/TanksGame.dir/rule + +# Convenience name for target. +TanksGame: CMakeFiles/TanksGame.dir/rule +.PHONY : TanksGame + +# codegen rule for target. +CMakeFiles/TanksGame.dir/codegen: CMakeFiles/TanksGame_autogen_timestamp_deps.dir/all + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame.dir/build.make CMakeFiles/TanksGame.dir/codegen + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 "Finished codegen for target TanksGame" +.PHONY : CMakeFiles/TanksGame.dir/codegen + +# clean rule for target. +CMakeFiles/TanksGame.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame.dir/build.make CMakeFiles/TanksGame.dir/clean +.PHONY : CMakeFiles/TanksGame.dir/clean + +#============================================================================= +# Target rules for target CMakeFiles/TanksGame_autogen_timestamp_deps.dir + +# All Build rule for target. +CMakeFiles/TanksGame_autogen_timestamp_deps.dir/all: + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen_timestamp_deps.dir/build.make CMakeFiles/TanksGame_autogen_timestamp_deps.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen_timestamp_deps.dir/build.make CMakeFiles/TanksGame_autogen_timestamp_deps.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num= "Built target TanksGame_autogen_timestamp_deps" +.PHONY : CMakeFiles/TanksGame_autogen_timestamp_deps.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/TanksGame_autogen_timestamp_deps.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles 0 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/TanksGame_autogen_timestamp_deps.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles 0 +.PHONY : CMakeFiles/TanksGame_autogen_timestamp_deps.dir/rule + +# Convenience name for target. +TanksGame_autogen_timestamp_deps: CMakeFiles/TanksGame_autogen_timestamp_deps.dir/rule +.PHONY : TanksGame_autogen_timestamp_deps + +# codegen rule for target. +CMakeFiles/TanksGame_autogen_timestamp_deps.dir/codegen: + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen_timestamp_deps.dir/build.make CMakeFiles/TanksGame_autogen_timestamp_deps.dir/codegen + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num= "Finished codegen for target TanksGame_autogen_timestamp_deps" +.PHONY : CMakeFiles/TanksGame_autogen_timestamp_deps.dir/codegen + +# clean rule for target. +CMakeFiles/TanksGame_autogen_timestamp_deps.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen_timestamp_deps.dir/build.make CMakeFiles/TanksGame_autogen_timestamp_deps.dir/clean +.PHONY : CMakeFiles/TanksGame_autogen_timestamp_deps.dir/clean + +#============================================================================= +# Target rules for target CMakeFiles/TanksGame_autogen.dir + +# All Build rule for target. +CMakeFiles/TanksGame_autogen.dir/all: CMakeFiles/TanksGame_autogen_timestamp_deps.dir/all + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen.dir/build.make CMakeFiles/TanksGame_autogen.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen.dir/build.make CMakeFiles/TanksGame_autogen.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=16 "Built target TanksGame_autogen" +.PHONY : CMakeFiles/TanksGame_autogen.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/TanksGame_autogen.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles 1 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/TanksGame_autogen.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles 0 +.PHONY : CMakeFiles/TanksGame_autogen.dir/rule + +# Convenience name for target. +TanksGame_autogen: CMakeFiles/TanksGame_autogen.dir/rule +.PHONY : TanksGame_autogen + +# codegen rule for target. +CMakeFiles/TanksGame_autogen.dir/codegen: CMakeFiles/TanksGame_autogen_timestamp_deps.dir/all + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen.dir/build.make CMakeFiles/TanksGame_autogen.dir/codegen + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=16 "Finished codegen for target TanksGame_autogen" +.PHONY : CMakeFiles/TanksGame_autogen.dir/codegen + +# clean rule for target. +CMakeFiles/TanksGame_autogen.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/TanksGame_autogen.dir/build.make CMakeFiles/TanksGame_autogen.dir/clean +.PHONY : CMakeFiles/TanksGame_autogen.dir/clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/DependInfo.cmake b/cmake-build-debug/CMakeFiles/TanksGame.dir/DependInfo.cmake new file mode 100644 index 0000000..7436ff7 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/DependInfo.cmake @@ -0,0 +1,37 @@ + +# Consider dependencies only in project. +set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF) + +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + ) + +# The set of dependency files which are needed: +set(CMAKE_DEPENDS_DEPENDENCY_FILES + "" "TanksGame_autogen/timestamp" "custom" "TanksGame_autogen/deps" + "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp" "CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp" "CMakeFiles/TanksGame.dir/src/Bonus.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/Bonus.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp" "CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp" "CMakeFiles/TanksGame.dir/src/Bullet.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/Bullet.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp" "CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp" "CMakeFiles/TanksGame.dir/src/GameModel.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/GameModel.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp" "CMakeFiles/TanksGame.dir/src/GameScane.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/GameScane.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp" "CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp" "CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp" "CMakeFiles/TanksGame.dir/src/Tank.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp" "CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp" "CMakeFiles/TanksGame.dir/src/Wall.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d" + "/home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp" "CMakeFiles/TanksGame.dir/src/main.cpp.o" "gcc" "CMakeFiles/TanksGame.dir/src/main.cpp.o.d" + "" "TanksGame" "gcc" "CMakeFiles/TanksGame.dir/link.d" + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES + ) + +# Targets to which this target links which contain Fortran sources. +set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..3ffcd0b6cefe0331e47a01fa2edaa7b74a2bb74a GIT binary patch literal 73912 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 literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d new file mode 100644 index 0000000..67306d2 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d @@ -0,0 +1,362 @@ +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp \ + /usr/include/c++/14/memory /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/move.h /usr/include/c++/14/type_traits \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/concepts /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/compare /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/unique_ptr.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h /usr/include/c++/14/ostream \ + /usr/include/c++/14/bits/requires_hosted.h /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/14/exception /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/cctype \ + /usr/include/ctype.h /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/14/bits/ios_base.h /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h /usr/include/c++/14/string \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h /usr/include/c++/14/cstddef \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/streambuf \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/../../../include/GameModel.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/assert.h /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h /usr/include/c++/14/iterator \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/map /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/../../../include/GameScane.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/../../../include/Bullet.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/build.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/build.make new file mode 100644 index 0000000..5d9faea --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/build.make @@ -0,0 +1,318 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.31 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/frankyshelloy/CLionProjects/TankiGame + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug + +# Include any dependencies generated for this target. +include CMakeFiles/TanksGame.dir/depend.make +# Include any dependencies generated by the compiler for this target. +include CMakeFiles/TanksGame.dir/compiler_depend.make + +# Include the progress variables for this target. +include CMakeFiles/TanksGame.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/TanksGame.dir/flags.make + +TanksGame_autogen/timestamp: /usr/lib/qt5/bin/moc +TanksGame_autogen/timestamp: /usr/lib/qt5/bin/uic +TanksGame_autogen/timestamp: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Automatic MOC and UIC for target TanksGame" + /usr/bin/cmake -E cmake_autogen /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/AutogenInfo.json "" + /usr/bin/cmake -E touch /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/timestamp + +CMakeFiles/TanksGame.dir/codegen: +.PHONY : CMakeFiles/TanksGame.dir/codegen + +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: TanksGame_autogen/mocs_compilation.cpp +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o -MF CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d -o CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp + +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp > CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.i + +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp -o CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.s + +CMakeFiles/TanksGame.dir/src/main.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/main.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp +CMakeFiles/TanksGame.dir/src/main.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/TanksGame.dir/src/main.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/main.cpp.o -MF CMakeFiles/TanksGame.dir/src/main.cpp.o.d -o CMakeFiles/TanksGame.dir/src/main.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + +CMakeFiles/TanksGame.dir/src/main.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/main.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp > CMakeFiles/TanksGame.dir/src/main.cpp.i + +CMakeFiles/TanksGame.dir/src/main.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/main.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp -o CMakeFiles/TanksGame.dir/src/main.cpp.s + +CMakeFiles/TanksGame.dir/src/GameScane.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/GameScane.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp +CMakeFiles/TanksGame.dir/src/GameScane.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/TanksGame.dir/src/GameScane.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/GameScane.cpp.o -MF CMakeFiles/TanksGame.dir/src/GameScane.cpp.o.d -o CMakeFiles/TanksGame.dir/src/GameScane.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + +CMakeFiles/TanksGame.dir/src/GameScane.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/GameScane.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp > CMakeFiles/TanksGame.dir/src/GameScane.cpp.i + +CMakeFiles/TanksGame.dir/src/GameScane.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/GameScane.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp -o CMakeFiles/TanksGame.dir/src/GameScane.cpp.s + +CMakeFiles/TanksGame.dir/src/GameModel.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/GameModel.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp +CMakeFiles/TanksGame.dir/src/GameModel.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object CMakeFiles/TanksGame.dir/src/GameModel.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/GameModel.cpp.o -MF CMakeFiles/TanksGame.dir/src/GameModel.cpp.o.d -o CMakeFiles/TanksGame.dir/src/GameModel.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + +CMakeFiles/TanksGame.dir/src/GameModel.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/GameModel.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp > CMakeFiles/TanksGame.dir/src/GameModel.cpp.i + +CMakeFiles/TanksGame.dir/src/GameModel.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/GameModel.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp -o CMakeFiles/TanksGame.dir/src/GameModel.cpp.s + +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object CMakeFiles/TanksGame.dir/src/Bonus.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/Bonus.cpp.o -MF CMakeFiles/TanksGame.dir/src/Bonus.cpp.o.d -o CMakeFiles/TanksGame.dir/src/Bonus.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + +CMakeFiles/TanksGame.dir/src/Bonus.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/Bonus.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp > CMakeFiles/TanksGame.dir/src/Bonus.cpp.i + +CMakeFiles/TanksGame.dir/src/Bonus.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/Bonus.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp -o CMakeFiles/TanksGame.dir/src/Bonus.cpp.s + +CMakeFiles/TanksGame.dir/src/Tank.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/Tank.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp +CMakeFiles/TanksGame.dir/src/Tank.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Building CXX object CMakeFiles/TanksGame.dir/src/Tank.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/Tank.cpp.o -MF CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d -o CMakeFiles/TanksGame.dir/src/Tank.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + +CMakeFiles/TanksGame.dir/src/Tank.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/Tank.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp > CMakeFiles/TanksGame.dir/src/Tank.cpp.i + +CMakeFiles/TanksGame.dir/src/Tank.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/Tank.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp -o CMakeFiles/TanksGame.dir/src/Tank.cpp.s + +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "Building CXX object CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o -MF CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o.d -o CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp > CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.i + +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp -o CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.s + +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Building CXX object CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o -MF CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o.d -o CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp > CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.i + +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp -o CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.s + +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_10) "Building CXX object CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o -MF CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o.d -o CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp > CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.i + +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp -o CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.s + +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_11) "Building CXX object CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o -MF CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o.d -o CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp > CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.i + +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp -o CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.s + +CMakeFiles/TanksGame.dir/src/Wall.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/Wall.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp +CMakeFiles/TanksGame.dir/src/Wall.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_12) "Building CXX object CMakeFiles/TanksGame.dir/src/Wall.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/Wall.cpp.o -MF CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d -o CMakeFiles/TanksGame.dir/src/Wall.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + +CMakeFiles/TanksGame.dir/src/Wall.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/Wall.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp > CMakeFiles/TanksGame.dir/src/Wall.cpp.i + +CMakeFiles/TanksGame.dir/src/Wall.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/Wall.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp -o CMakeFiles/TanksGame.dir/src/Wall.cpp.s + +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_13) "Building CXX object CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o -MF CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o.d -o CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/BrickWall.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp > CMakeFiles/TanksGame.dir/src/BrickWall.cpp.i + +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/BrickWall.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp -o CMakeFiles/TanksGame.dir/src/BrickWall.cpp.s + +CMakeFiles/TanksGame.dir/src/Bullet.cpp.o: CMakeFiles/TanksGame.dir/flags.make +CMakeFiles/TanksGame.dir/src/Bullet.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp +CMakeFiles/TanksGame.dir/src/Bullet.cpp.o: CMakeFiles/TanksGame.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_14) "Building CXX object CMakeFiles/TanksGame.dir/src/Bullet.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/TanksGame.dir/src/Bullet.cpp.o -MF CMakeFiles/TanksGame.dir/src/Bullet.cpp.o.d -o CMakeFiles/TanksGame.dir/src/Bullet.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + +CMakeFiles/TanksGame.dir/src/Bullet.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/TanksGame.dir/src/Bullet.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp > CMakeFiles/TanksGame.dir/src/Bullet.cpp.i + +CMakeFiles/TanksGame.dir/src/Bullet.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/TanksGame.dir/src/Bullet.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp -o CMakeFiles/TanksGame.dir/src/Bullet.cpp.s + +# Object files for target TanksGame +TanksGame_OBJECTS = \ +"CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/main.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/GameScane.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/GameModel.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/Bonus.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/Tank.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/Wall.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o" \ +"CMakeFiles/TanksGame.dir/src/Bullet.cpp.o" + +# External object files for target TanksGame +TanksGame_EXTERNAL_OBJECTS = + +TanksGame: CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/main.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/GameScane.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/GameModel.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/Bonus.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/Tank.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/Wall.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/src/Bullet.cpp.o +TanksGame: CMakeFiles/TanksGame.dir/build.make +TanksGame: CMakeFiles/TanksGame.dir/compiler_depend.ts +TanksGame: /usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.15.15 +TanksGame: /usr/lib/x86_64-linux-gnu/libQt5Multimedia.so.5.15.15 +TanksGame: /usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.15.15 +TanksGame: /usr/lib/x86_64-linux-gnu/libQt5Network.so.5.15.15 +TanksGame: /usr/lib/x86_64-linux-gnu/libQt5Core.so.5.15.15 +TanksGame: CMakeFiles/TanksGame.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles --progress-num=$(CMAKE_PROGRESS_15) "Linking CXX executable TanksGame" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/TanksGame.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/TanksGame.dir/build: TanksGame +.PHONY : CMakeFiles/TanksGame.dir/build + +CMakeFiles/TanksGame.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/TanksGame.dir/cmake_clean.cmake +.PHONY : CMakeFiles/TanksGame.dir/clean + +CMakeFiles/TanksGame.dir/depend: TanksGame_autogen/timestamp + cd /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/frankyshelloy/CLionProjects/TankiGame /home/frankyshelloy/CLionProjects/TankiGame /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/DependInfo.cmake "--color=$(COLOR)" +.PHONY : CMakeFiles/TanksGame.dir/depend + diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/cmake_clean.cmake b/cmake-build-debug/CMakeFiles/TanksGame.dir/cmake_clean.cmake new file mode 100644 index 0000000..2a7e6d1 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/cmake_clean.cmake @@ -0,0 +1,41 @@ +file(REMOVE_RECURSE + "CMakeFiles/TanksGame.dir/link.d" + "CMakeFiles/TanksGame_autogen.dir/AutogenUsed.txt" + "CMakeFiles/TanksGame_autogen.dir/ParseCache.txt" + "TanksGame_autogen" + "CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o" + "CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/Bonus.cpp.o" + "CMakeFiles/TanksGame.dir/src/Bonus.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o" + "CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/Bullet.cpp.o" + "CMakeFiles/TanksGame.dir/src/Bullet.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o" + "CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/GameModel.cpp.o" + "CMakeFiles/TanksGame.dir/src/GameModel.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/GameScane.cpp.o" + "CMakeFiles/TanksGame.dir/src/GameScane.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o" + "CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o" + "CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/Tank.cpp.o" + "CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o" + "CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/Wall.cpp.o" + "CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d" + "CMakeFiles/TanksGame.dir/src/main.cpp.o" + "CMakeFiles/TanksGame.dir/src/main.cpp.o.d" + "TanksGame" + "TanksGame.pdb" + "TanksGame_autogen/mocs_compilation.cpp" + "TanksGame_autogen/timestamp" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/TanksGame.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal new file mode 100644 index 0000000..700fc45 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal @@ -0,0 +1,9657 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.31 + +/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/timestamp + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QBrush + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPen + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Bullet.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/random.h + /usr/include/c++/14/bits/random.tcc + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/specfun.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/cmath + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/random + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tr1/bessel_function.tcc + /usr/include/c++/14/tr1/beta_function.tcc + /usr/include/c++/14/tr1/ell_integral.tcc + /usr/include/c++/14/tr1/exp_integral.tcc + /usr/include/c++/14/tr1/gamma.tcc + /usr/include/c++/14/tr1/hypergeometric.tcc + /usr/include/c++/14/tr1/legendre_function.tcc + /usr/include/c++/14/tr1/modified_bessel_func.tcc + /usr/include/c++/14/tr1/poly_hermite.tcc + /usr/include/c++/14/tr1/poly_laguerre.tcc + /usr/include/c++/14/tr1/riemann_zeta.tcc + /usr/include/c++/14/tr1/special_function_util.h + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/math.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h + /usr/include/x86_64-linux-gnu/bits/fp-fast.h + /usr/include/x86_64-linux-gnu/bits/fp-logb.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/iscanonical.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/math-vector.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h + /usr/include/x86_64-linux-gnu/bits/mathcalls.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/opt_random.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QRandomGenerator + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrandom.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/GameModel.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/GameScane.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/HeavyEnemy.h + /home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/TwinShooterEnemy.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/random.h + /usr/include/c++/14/bits/random.tcc + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/specfun.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/cmath + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/random + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tr1/bessel_function.tcc + /usr/include/c++/14/tr1/beta_function.tcc + /usr/include/c++/14/tr1/ell_integral.tcc + /usr/include/c++/14/tr1/exp_integral.tcc + /usr/include/c++/14/tr1/gamma.tcc + /usr/include/c++/14/tr1/hypergeometric.tcc + /usr/include/c++/14/tr1/legendre_function.tcc + /usr/include/c++/14/tr1/modified_bessel_func.tcc + /usr/include/c++/14/tr1/poly_hermite.tcc + /usr/include/c++/14/tr1/poly_laguerre.tcc + /usr/include/c++/14/tr1/riemann_zeta.tcc + /usr/include/c++/14/tr1/special_function_util.h + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/math.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h + /usr/include/x86_64-linux-gnu/bits/fp-fast.h + /usr/include/x86_64-linux-gnu/bits/fp-logb.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/iscanonical.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/math-vector.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h + /usr/include/x86_64-linux-gnu/bits/mathcalls.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/opt_random.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QRandomGenerator + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrandom.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpalette.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsView + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qabstractscrollarea.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qframe.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsview.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qscrollarea.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qsizepolicy.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qwidget.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/HeavyEnemy.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Tank.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/TwinShooterEnemy.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Wall.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/main.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/chrono.h + /usr/include/c++/14/bits/chrono_io.h + /usr/include/c++/14/bits/codecvt.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/enable_special_members.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/hashtable.h + /usr/include/c++/14/bits/hashtable_policy.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/istream.tcc + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_conv.h + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/locale_facets_nonio.h + /usr/include/c++/14/bits/locale_facets_nonio.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/parse_numbers.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/quoted_string.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/sstream.tcc + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/unicode-data.h + /usr/include/c++/14/bits/unicode.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/unordered_map.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/chrono + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdio + /usr/include/c++/14/cstdlib + /usr/include/c++/14/ctime + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/iomanip + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/istream + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/locale + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_algorithm_defs.h + /usr/include/c++/14/pstl/glue_memory_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/pstl/pstl_config.h + /usr/include/c++/14/ratio + /usr/include/c++/14/span + /usr/include/c++/14/sstream + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/system_error + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/variant + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreapplication.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qeventloop.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlocale.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qguiapplication.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qinputmethod.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpalette.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QApplication + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsView + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qabstractscrollarea.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qapplication.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qframe.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsview.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qscrollarea.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qsizepolicy.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qwidget.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +TanksGame + /lib/x86_64-linux-gnu/libGL.so.1 + /lib/x86_64-linux-gnu/libGLX.so.0 + /lib/x86_64-linux-gnu/libGLdispatch.so.0 + /lib/x86_64-linux-gnu/libX11.so.6 + /lib/x86_64-linux-gnu/libXau.so.6 + /lib/x86_64-linux-gnu/libXdmcp.so.6 + /lib/x86_64-linux-gnu/libatomic.so.1 + /lib/x86_64-linux-gnu/libbrotlicommon.so.1 + /lib/x86_64-linux-gnu/libbrotlidec.so.1 + /lib/x86_64-linux-gnu/libbz2.so.1.0 + /lib/x86_64-linux-gnu/libc.so.6 + /lib/x86_64-linux-gnu/libdouble-conversion.so.3 + /lib/x86_64-linux-gnu/libfreetype.so.6 + /lib/x86_64-linux-gnu/libglib-2.0.so.0 + /lib/x86_64-linux-gnu/libgraphite2.so.3 + /lib/x86_64-linux-gnu/libharfbuzz.so.0 + /lib/x86_64-linux-gnu/libicudata.so.76 + /lib/x86_64-linux-gnu/libicui18n.so.76 + /lib/x86_64-linux-gnu/libicuuc.so.76 + /lib/x86_64-linux-gnu/libm.so.6 + /lib/x86_64-linux-gnu/libmd4c.so.0 + /lib/x86_64-linux-gnu/libmvec.so.1 + /lib/x86_64-linux-gnu/libpcre2-16.so.0 + /lib/x86_64-linux-gnu/libpcre2-8.so.0 + /lib/x86_64-linux-gnu/libpng16.so.16 + /lib/x86_64-linux-gnu/libxcb.so.1 + /lib/x86_64-linux-gnu/libz.so.1 + /lib/x86_64-linux-gnu/libzstd.so.1 + /lib64/ld-linux-x86-64.so.2 + /usr/lib/x86_64-linux-gnu/Scrt1.o + /usr/lib/x86_64-linux-gnu/crti.o + /usr/lib/x86_64-linux-gnu/crtn.o + /usr/lib/x86_64-linux-gnu/libc.so + /usr/lib/x86_64-linux-gnu/libgcc_s.so.1 + /usr/lib/x86_64-linux-gnu/libm.so + /usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o + /usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so + /usr/lib/gcc/x86_64-linux-gnu/14/libstdc++.so + /usr/lib/x86_64-linux-gnu/libQt5Core.so.5.15.15 + /usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.15.15 + /usr/lib/x86_64-linux-gnu/libQt5Multimedia.so.5.15.15 + /usr/lib/x86_64-linux-gnu/libQt5Network.so.5.15.15 + /usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.15.15 + /usr/lib/x86_64-linux-gnu/libc_nonshared.a + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bullet.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameModel.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameScane.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/TanksGame.dir/src/main.cpp.o + diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make new file mode 100644 index 0000000..904450b --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make @@ -0,0 +1,10928 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.31 + +TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: TanksGame_autogen/mocs_compilation.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp \ + TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QBrush \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPen \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Bullet.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/random.h \ + /usr/include/c++/14/bits/random.tcc \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/specfun.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/cmath \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/random \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tr1/bessel_function.tcc \ + /usr/include/c++/14/tr1/beta_function.tcc \ + /usr/include/c++/14/tr1/ell_integral.tcc \ + /usr/include/c++/14/tr1/exp_integral.tcc \ + /usr/include/c++/14/tr1/gamma.tcc \ + /usr/include/c++/14/tr1/hypergeometric.tcc \ + /usr/include/c++/14/tr1/legendre_function.tcc \ + /usr/include/c++/14/tr1/modified_bessel_func.tcc \ + /usr/include/c++/14/tr1/poly_hermite.tcc \ + /usr/include/c++/14/tr1/poly_laguerre.tcc \ + /usr/include/c++/14/tr1/riemann_zeta.tcc \ + /usr/include/c++/14/tr1/special_function_util.h \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/math.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/opt_random.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QRandomGenerator \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrandom.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/GameModel.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/GameScane.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/HeavyEnemy.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/TwinShooterEnemy.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/random.h \ + /usr/include/c++/14/bits/random.tcc \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/specfun.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/cmath \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/random \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tr1/bessel_function.tcc \ + /usr/include/c++/14/tr1/beta_function.tcc \ + /usr/include/c++/14/tr1/ell_integral.tcc \ + /usr/include/c++/14/tr1/exp_integral.tcc \ + /usr/include/c++/14/tr1/gamma.tcc \ + /usr/include/c++/14/tr1/hypergeometric.tcc \ + /usr/include/c++/14/tr1/legendre_function.tcc \ + /usr/include/c++/14/tr1/modified_bessel_func.tcc \ + /usr/include/c++/14/tr1/poly_hermite.tcc \ + /usr/include/c++/14/tr1/poly_laguerre.tcc \ + /usr/include/c++/14/tr1/riemann_zeta.tcc \ + /usr/include/c++/14/tr1/special_function_util.h \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/math.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/opt_random.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QRandomGenerator \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrandom.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpalette.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsView \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qabstractscrollarea.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qframe.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qscrollarea.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qsizepolicy.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qwidget.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/HeavyEnemy.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Tank.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/TwinShooterEnemy.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/Wall.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +CMakeFiles/TanksGame.dir/src/main.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/bits/chrono_io.h \ + /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/parse_numbers.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/quoted_string.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/chrono \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdio \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/ctime \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/iomanip \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/istream \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/ratio \ + /usr/include/c++/14/span \ + /usr/include/c++/14/sstream \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/system_error \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/variant \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreapplication.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qeventloop.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlocale.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qguiapplication.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qinputmethod.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpalette.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QApplication \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsView \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qabstractscrollarea.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qapplication.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qframe.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qscrollarea.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qsizepolicy.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qwidget.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + +TanksGame: /lib/x86_64-linux-gnu/libGL.so.1 \ + /lib/x86_64-linux-gnu/libGLX.so.0 \ + /lib/x86_64-linux-gnu/libGLdispatch.so.0 \ + /lib/x86_64-linux-gnu/libX11.so.6 \ + /lib/x86_64-linux-gnu/libXau.so.6 \ + /lib/x86_64-linux-gnu/libXdmcp.so.6 \ + /lib/x86_64-linux-gnu/libatomic.so.1 \ + /lib/x86_64-linux-gnu/libbrotlicommon.so.1 \ + /lib/x86_64-linux-gnu/libbrotlidec.so.1 \ + /lib/x86_64-linux-gnu/libbz2.so.1.0 \ + /lib/x86_64-linux-gnu/libc.so.6 \ + /lib/x86_64-linux-gnu/libdouble-conversion.so.3 \ + /lib/x86_64-linux-gnu/libfreetype.so.6 \ + /lib/x86_64-linux-gnu/libglib-2.0.so.0 \ + /lib/x86_64-linux-gnu/libgraphite2.so.3 \ + /lib/x86_64-linux-gnu/libharfbuzz.so.0 \ + /lib/x86_64-linux-gnu/libicudata.so.76 \ + /lib/x86_64-linux-gnu/libicui18n.so.76 \ + /lib/x86_64-linux-gnu/libicuuc.so.76 \ + /lib/x86_64-linux-gnu/libm.so.6 \ + /lib/x86_64-linux-gnu/libmd4c.so.0 \ + /lib/x86_64-linux-gnu/libmvec.so.1 \ + /lib/x86_64-linux-gnu/libpcre2-16.so.0 \ + /lib/x86_64-linux-gnu/libpcre2-8.so.0 \ + /lib/x86_64-linux-gnu/libpng16.so.16 \ + /lib/x86_64-linux-gnu/libxcb.so.1 \ + /lib/x86_64-linux-gnu/libz.so.1 \ + /lib/x86_64-linux-gnu/libzstd.so.1 \ + /lib64/ld-linux-x86-64.so.2 \ + /usr/lib/x86_64-linux-gnu/Scrt1.o \ + /usr/lib/x86_64-linux-gnu/crti.o \ + /usr/lib/x86_64-linux-gnu/crtn.o \ + /usr/lib/x86_64-linux-gnu/libc.so \ + /usr/lib/x86_64-linux-gnu/libgcc_s.so.1 \ + /usr/lib/x86_64-linux-gnu/libm.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o \ + /usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/libstdc++.so \ + /usr/lib/x86_64-linux-gnu/libQt5Core.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Multimedia.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Network.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libc_nonshared.a \ + CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o \ + CMakeFiles/TanksGame.dir/src/Bonus.cpp.o \ + CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o \ + CMakeFiles/TanksGame.dir/src/Bullet.cpp.o \ + CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o \ + CMakeFiles/TanksGame.dir/src/GameModel.cpp.o \ + CMakeFiles/TanksGame.dir/src/GameScane.cpp.o \ + CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o \ + CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o \ + CMakeFiles/TanksGame.dir/src/Tank.cpp.o \ + CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o \ + CMakeFiles/TanksGame.dir/src/Wall.cpp.o \ + CMakeFiles/TanksGame.dir/src/main.cpp.o + + +CMakeFiles/TanksGame.dir/src/Wall.cpp.o: + +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o: + +CMakeFiles/TanksGame.dir/src/Tank.cpp.o: + +CMakeFiles/TanksGame.dir/src/GameModel.cpp.o: + +CMakeFiles/TanksGame.dir/src/Bullet.cpp.o: + +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o: + +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: + +/usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Network.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Multimedia.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Core.so.5.15.15: + +/usr/lib/gcc/x86_64-linux-gnu/14/libstdc++.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a: + +/usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o: + +/usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o: + +/lib/x86_64-linux-gnu/libz.so.1: + +/lib/x86_64-linux-gnu/libpng16.so.16: + +/lib/x86_64-linux-gnu/libpcre2-8.so.0: + +/lib/x86_64-linux-gnu/libpcre2-16.so.0: + +/lib/x86_64-linux-gnu/libm.so.6: + +/lib/x86_64-linux-gnu/libicuuc.so.76: + +/lib/x86_64-linux-gnu/libicui18n.so.76: + +/lib/x86_64-linux-gnu/libgraphite2.so.3: + +/lib/x86_64-linux-gnu/libc.so.6: + +/lib/x86_64-linux-gnu/libbz2.so.1.0: + +/lib/x86_64-linux-gnu/libXau.so.6: + +/lib/x86_64-linux-gnu/libX11.so.6: + +/lib/x86_64-linux-gnu/libxcb.so.1: + +/lib/x86_64-linux-gnu/libGLdispatch.so.0: + +/lib/x86_64-linux-gnu/libGLX.so.0: + +/lib/x86_64-linux-gnu/libGL.so.1: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qapplication.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qinputmethod.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qguiapplication.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreapplication.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qwidget.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qsizepolicy.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qscrollarea.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpalette.h: + +/lib/x86_64-linux-gnu/libfreetype.so.6: + +/home/frankyshelloy/CLionProjects/TankiGame/include/HeavyEnemy.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qrandom.h: + +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/QRandomGenerator: + +/usr/include/x86_64-linux-gnu/c++/14/bits/opt_random.h: + +/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h: + +/usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h: + +/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + +/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + +/usr/include/x86_64-linux-gnu/bits/fp-logb.h: + +/usr/include/x86_64-linux-gnu/bits/fp-fast.h: + +/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + +/usr/include/c++/14/tr1/riemann_zeta.tcc: + +/usr/include/c++/14/tr1/poly_laguerre.tcc: + +/usr/include/c++/14/tr1/modified_bessel_func.tcc: + +/usr/include/c++/14/tr1/legendre_function.tcc: + +/usr/include/c++/14/tr1/hypergeometric.tcc: + +/usr/include/c++/14/tr1/exp_integral.tcc: + +/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + +/usr/include/math.h: + +/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + +/usr/include/c++/14/pstl/glue_algorithm_defs.h: + +/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + +/usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/timex.h: + +/usr/include/x86_64-linux-gnu/bits/stdio_lim.h: + +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: + +/usr/include/x86_64-linux-gnu/bits/time64.h: + +/usr/include/x86_64-linux-gnu/bits/time.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h: + +/usr/include/c++/14/bits/iterator_concepts.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h: + +/usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/TwinShooterEnemy.h: + +/usr/include/c++/14/charconv: + +/usr/include/time.h: + +/usr/include/c++/14/bits/streambuf.tcc: + +/home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h: + +/usr/include/x86_64-linux-gnu/bits/getopt_core.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h: + +/lib/x86_64-linux-gnu/libmd4c.so.0: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qeventloop.h: + +/usr/include/x86_64-linux-gnu/bits/floatn.h: + +/usr/include/wctype.h: + +/usr/include/x86_64-linux-gnu/bits/setjmp.h: + +/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: + +/usr/include/x86_64-linux-gnu/asm/bitsperlong.h: + +/usr/include/c++/14/numeric: + +/usr/include/locale.h: + +/usr/include/linux/types.h: + +/lib/x86_64-linux-gnu/libbrotlicommon.so.1: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h: + +/usr/include/ctype.h: + +/usr/include/c++/14/pstl/execution_defs.h: + +/usr/include/asm-generic/types.h: + +/usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h: + +/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + +/usr/include/c++/14/unordered_map: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake: + +/usr/include/c++/14/typeinfo: + +/lib64/ld-linux-x86-64.so.2: + +/usr/include/c++/14/type_traits: + +/usr/include/c++/14/tuple: + +/usr/include/c++/14/bits/ostream.tcc: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h: + +/usr/include/c++/14/memory: + +/usr/include/c++/14/bits/stl_function.h: + +/usr/include/c++/14/list: + +/usr/include/c++/14/bits/char_traits.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h: + +/usr/include/c++/14/initializer_list: + +/usr/include/c++/14/format: + +/usr/include/c++/14/ext/alloc_traits.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h: + +/usr/include/c++/14/ext/string_conversions.h: + +/usr/include/c++/14/ext/concurrence.h: + +/usr/include/c++/14/ext/atomicity.h: + +/usr/include/c++/14/exception: + +/usr/include/c++/14/atomic: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake: + +/usr/include/c++/14/chrono: + +/usr/include/c++/14/debug/assertions.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h: + +/usr/include/asm-generic/bitsperlong.h: + +/usr/include/c++/14/cwctype: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake: + +/lib/x86_64-linux-gnu/libatomic.so.1: + +/usr/include/c++/14/cstdlib: + +/usr/include/c++/14/cstdint: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake: + +/usr/lib/x86_64-linux-gnu/libc_nonshared.a: + +/usr/include/c++/14/cstddef: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h: + +/usr/include/x86_64-linux-gnu/bits/math-vector.h: + +/usr/include/c++/14/concepts: + +/usr/include/c++/14/tr1/special_function_util.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake: + +/usr/include/c++/14/ostream: + +/usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/x86_64-linux-gnu/bits/endian.h: + +/usr/include/asm-generic/errno.h: + +/usr/include/c++/14/bits/parse_numbers.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp: + +/usr/include/c++/14/climits: + +TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp: + +/usr/include/x86_64-linux-gnu/bits/syscall.h: + +/usr/include/c++/14/string_view: + +/home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp: + +/usr/include/c++/14/cerrno: + +/usr/include/c++/14/bits/version.h: + +/usr/include/c++/14/bits/vector.tcc: + +/usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h: + +/usr/include/c++/14/bits/utility.h: + +/usr/include/c++/14/cstdio: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h: + +/usr/include/c++/14/bits/invoke.h: + +/usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake: + +/usr/include/c++/14/bits/move_only_function.h: + +/usr/include/c++/14/iterator: + +/usr/include/c++/14/bits/unique_ptr.h: + +/usr/include/x86_64-linux-gnu/bits/unistd_ext.h: + +/usr/include/c++/14/limits: + +/usr/include/c++/14/iomanip: + +/usr/include/c++/14/bits/cpp_type_traits.h: + +/usr/include/c++/14/bits/stringfwd.h: + +/usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake: + +/usr/include/c++/14/bits/c++0x_warning.h: + +/usr/include/c++/14/bits/basic_string.h: + +/usr/lib/x86_64-linux-gnu/crti.o: + +/usr/include/c++/14/bits/locale_facets.h: + +/usr/lib/x86_64-linux-gnu/libm.so: + +TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp: + +/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + +/usr/include/c++/14/stdlib.h: + +/usr/include/x86_64-linux-gnu/bits/long-double.h: + +/usr/include/c++/14/bits/charconv.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QApplication: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h: + +/usr/include/linux/limits.h: + +/usr/include/c++/14/bits/atomic_base.h: + +/usr/include/c++/14/optional: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake: + +/usr/include/c++/14/bits/cxxabi_forced.h: + +/usr/include/stdio.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake: + +/usr/include/x86_64-linux-gnu/bits/sched.h: + +/usr/include/c++/14/bits/atomic_wait.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h: + +/usr/include/c++/14/bits/ostream_insert.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsview.h: + +/usr/include/c++/14/bits/stl_pair.h: + +/usr/include/c++/14/backward/binders.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake: + +/usr/include/unistd.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake: + +/usr/include/c++/14/bits/allocator.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h: + +/usr/include/pthread.h: + +/usr/include/c++/14/bits/functexcept.h: + +CMakeFiles/3.31.6/CMakeSystem.cmake: + +/usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake: + +/usr/include/c++/14/text_encoding: + +/usr/include/c++/14/bits/locale_facets.tcc: + +/usr/include/c++/14/bits/chrono.h: + +/usr/include/c++/14/bits/stl_tree.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake: + +/usr/bin/cmake: + +/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h: + +/usr/include/c++/14/streambuf: + +/usr/include/c++/14/bits/string_view.tcc: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/QObject: + +/home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake: + +/usr/include/c++/14/cctype: + +/usr/include/c++/14/bits/exception.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h: + +/usr/include/assert.h: + +/usr/include/c++/14/bits/stl_iterator_base_funcs.h: + +/usr/include/c++/14/bits/allocated_ptr.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp: + +/usr/include/stdc-predef.h: + +/usr/include/asm-generic/posix_types.h: + +/usr/include/asm-generic/int-ll64.h: + +/usr/include/c++/14/ios: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp: + +/usr/include/c++/14/bits/shared_ptr.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h: + +/usr/include/linux/errno.h: + +/usr/include/c++/14/bits/stl_multimap.h: + +/usr/include/x86_64-linux-gnu/bits/environments.h: + +/usr/include/c++/14/clocale: + +/usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake: + +/usr/include/c++/14/bits/basic_string.tcc: + +/usr/include/c++/14/bits/ranges_util.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h: + +/usr/include/c++/14/bits/stl_vector.h: + +/usr/include/x86_64-linux-gnu/asm/unistd.h: + +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o: + +/usr/include/c++/14/bits/stl_numeric.h: + +/usr/include/c++/14/utility: + +/usr/include/c++/14/bits/basic_ios.h: + +/usr/include/c++/14/bits/stl_raw_storage_iter.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp: + +/usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + +/home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt: + +/usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h: + +/usr/include/c++/14/bits/out_ptr.h: + +CMakeFiles/3.31.6/CMakeCXXCompiler.cmake: + +/usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h: + +/usr/include/c++/14/bits/alloc_traits.h: + +/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qabstractscrollarea.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + +/usr/include/c++/14/algorithm: + +/usr/include/errno.h: + +/usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + +/usr/include/c++/14/debug/debug.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake: + +/home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp: + +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: + +/usr/include/c++/14/tr1/poly_hermite.tcc: + +/usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + +/usr/include/c++/14/bits/locale_facets_nonio.tcc: + +/usr/include/x86_64-linux-gnu/bits/select.h: + +/usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake: + +/usr/include/c++/14/stdexcept: + +/usr/include/c++/14/cwchar: + +/usr/include/c++/14/ext/type_traits.h: + +/usr/include/x86_64-linux-gnu/asm/posix_types.h: + +/usr/include/x86_64-linux-gnu/bits/waitflags.h: + +/usr/include/c++/14/bits/list.tcc: + +/usr/include/c++/14/array: + +/usr/include/x86_64-linux-gnu/bits/posix2_lim.h: + +/usr/include/linux/posix_types.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h: + +/lib/x86_64-linux-gnu/libbrotlidec.so.1: + +/usr/include/c++/14/bits/locale_classes.tcc: + +/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + +/usr/include/libintl.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h: + +/usr/include/c++/14/pstl/glue_numeric_defs.h: + +/usr/include/c++/14/bits/atomic_lockfree_defines.h: + +/usr/include/c++/14/backward/auto_ptr.h: + +/usr/include/c++/14/bits/move.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem: + +/usr/include/c++/14/tr1/ell_integral.tcc: + +/usr/include/c++/14/bits/localefwd.h: + +/usr/include/c++/14/bits/exception_ptr.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake: + +/usr/include/x86_64-linux-gnu/asm/errno.h: + +/usr/include/c++/14/ratio: + +/usr/include/c++/14/bits/sat_arith.h: + +/usr/include/c++/14/bits/ranges_algobase.h: + +/usr/include/c++/14/bits/stl_tempbuf.h: + +/usr/include/c++/14/bits/max_size_type.h: + +/usr/include/c++/14/bits/memory_resource.h: + +/usr/include/c++/14/bits/std_function.h: + +/usr/include/c++/14/bits/enable_special_members.h: + +/usr/include/c++/14/bits/memoryfwd.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h: + +/usr/include/c++/14/bits/node_handle.h: + +/usr/include/features.h: + +/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h: + +/usr/include/x86_64-linux-gnu/asm/unistd_64.h: + +/usr/include/c++/14/pstl/pstl_config.h: + +/usr/include/c++/14/bits/mofunc_impl.h: + +/usr/include/linux/stddef.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake: + +/usr/include/c++/14/bits/stl_relops.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + +/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + +/usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake: + +/usr/include/x86_64-linux-gnu/bits/posix_opt.h: + +/usr/include/c++/14/bits/nested_exception.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene: + +/usr/lib/x86_64-linux-gnu/libc.so: + +/usr/lib/x86_64-linux-gnu/Scrt1.o: + +/usr/include/c++/14/bits/stl_uninitialized.h: + +/usr/include/c++/14/bits/locale_classes.h: + +/usr/include/sched.h: + +/usr/include/c++/14/bits/new_allocator.h: + +/usr/include/x86_64-linux-gnu/bits/endianness.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake: + +/usr/include/c++/14/bits/stl_bvector.h: + +/usr/include/c++/14/bits/ptr_traits.h: + +/usr/include/c++/14/bits/algorithmfwd.h: + +/usr/include/c++/14/bits/istream.tcc: + +/usr/include/c++/14/bits/predefined_ops.h: + +/usr/include/c++/14/bits/stl_construct.h: + +/usr/include/x86_64-linux-gnu/bits/types/error_t.h: + +/usr/include/c++/14/bits/erase_if.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h: + +/usr/include/c++/14/bits/functional_hash.h: + +/usr/include/c++/14/bits/ranges_algo.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h: + +/usr/include/x86_64-linux-gnu/asm/types.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp: + +/usr/include/c++/14/bits/ranges_base.h: + +/usr/include/c++/14/bits/ranges_cmp.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp: + +/usr/include/c++/14/bits/streambuf_iterator.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + +/usr/include/c++/14/bits/ranges_uninitialized.h: + +/usr/include/x86_64-linux-gnu/bits/iscanonical.h: + +/usr/include/c++/14/bits/stl_map.h: + +/usr/include/c++/14/bits/refwrap.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h: + +/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + +/usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake: + +/usr/include/strings.h: + +/usr/include/c++/14/random: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake: + +/usr/include/c++/14/bits/requires_hosted.h: + +/usr/include/c++/14/bits/shared_ptr_atomic.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp: + +/usr/include/c++/14/bits/std_abs.h: + +/usr/include/x86_64-linux-gnu/bits/floatn-common.h: + +/usr/include/linux/sched/types.h: + +/usr/include/c++/14/sstream: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h: + +/usr/include/c++/14/cmath: + +/usr/include/x86_64-linux-gnu/bits/cpu-set.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h: + +/usr/include/c++/14/bits/stl_algobase.h: + +/usr/include/c++/14/bits/stl_iterator.h: + +/usr/include/c++/14/bits/uniform_int_dist.h: + +/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + +/usr/include/c++/14/ext/numeric_traits.h: + +/lib/x86_64-linux-gnu/libmvec.so.1: + +/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + +/usr/include/c++/14/ctime: + +/usr/include/c++/14/compare: + +/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h: + +/usr/include/c++/14/bits/stl_iterator_base_types.h: + +/usr/include/x86_64-linux-gnu/bits/confname.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h: + +/usr/include/asm-generic/errno-base.h: + +/usr/include/c++/14/bits/hashtable_policy.h: + +/usr/include/c++/14/new: + +/usr/include/c++/14/bits/stl_list.h: + +/usr/include/c++/14/bits/stream_iterator.h: + +/usr/include/c++/14/tr1/beta_function.tcc: + +/home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h: + +/usr/include/c++/14/bits/uses_allocator_args.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h: + +/usr/include/c++/14/iosfwd: + +/usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h: + +/usr/include/c++/14/bits/chrono_io.h: + +/usr/include/x86_64-linux-gnu/bits/types/FILE.h: + +/usr/include/x86_64-linux-gnu/bits/types/time_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + +CMakeFiles/TanksGame.dir/src/GameScane.cpp.o: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake: + +/usr/include/x86_64-linux-gnu/bits/types/wint_t.h: + +/usr/include/x86_64-linux-gnu/bits/typesizes.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h: + +/usr/include/x86_64-linux-gnu/bits/wchar.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h: + +/usr/include/c++/14/bits/stl_heap.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h: + +/usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + +/usr/include/features-time64.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h: + +/usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h: + +/usr/lib/x86_64-linux-gnu/libgcc_s.so.1: + +/usr/include/x86_64-linux-gnu/gnu/stubs.h: + +/usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake: + +/usr/include/c++/14/bits/basic_ios.tcc: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/QList: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qlocale.h: + +/usr/include/endian.h: + +/usr/include/stdint.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/QSet: + +/usr/include/c++/14/bits/concept_check.h: + +/usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake: + +/lib/x86_64-linux-gnu/libicudata.so.76: + +/lib/x86_64-linux-gnu/libharfbuzz.so.0: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsView: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h: + +/usr/include/c++/14/bits/sstream.tcc: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h: + +/usr/lib/x86_64-linux-gnu/crtn.o: + +/usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake: + +/usr/include/x86_64-linux-gnu/asm/posix_types_64.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h: + +CMakeFiles/TanksGame.dir/src/main.cpp.o: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/QColor: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h: + +/usr/include/c++/14/bits/cxxabi_init_exception.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h: + +/usr/include/c++/14/string: + +/usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h: + +/usr/include/x86_64-linux-gnu/bits/locale.h: + +/usr/include/x86_64-linux-gnu/bits/posix1_lim.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/QPen: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h: + +/usr/include/c++/14/tr1/gamma.tcc: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h: + +/usr/include/c++/14/bits/stl_algo.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h: + +/usr/include/limits.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h: + +/usr/include/syscall.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h: + +TanksGame_autogen/moc_predefs.h: + +/usr/include/c++/14/bits/range_access.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h: + +/usr/include/c++/14/numbers: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h: + +/lib/x86_64-linux-gnu/libzstd.so.1: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h: + +/lib/x86_64-linux-gnu/libglib-2.0.so.0: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h: + +/usr/include/c++/14/bits/hash_bytes.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h: + +/usr/include/c++/14/bits/std_mutex.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h: + +/usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h: + +/usr/include/c++/14/bits/exception_defines.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h: + +/usr/include/c++/14/bits/quoted_string.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h: + +/usr/include/c++/14/bits/align.h: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h: + +/usr/include/c++/14/bits/locale_facets_nonio.h: + +/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h: + +/usr/include/c++/14/bits/shared_ptr_base.h: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem: + +/lib/x86_64-linux-gnu/libXdmcp.so.6: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h: + +/usr/include/c++/14/bit: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake: + +/usr/include/x86_64-linux-gnu/sys/syscall.h: + +/usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h: + +/usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake: + +/usr/include/c++/14/bits/postypes.h: + +/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake: + +/usr/include/c++/14/functional: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake: + +/usr/include/c++/14/bits/specfun.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake: + +/usr/include/x86_64-linux-gnu/bits/getopt_posix.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/qframe.h: + +/usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake: + +/usr/include/string.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake: + +/usr/share/cmake-3.31/Modules/Linker/GNU.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake: + +/usr/include/c++/14/bits/ios_base.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake: + +/usr/include/x86_64-linux-gnu/sys/select.h: + +/usr/include/c++/14/bits/random.tcc: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake: + +/usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake: + +/usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake: + +/usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake: + +/usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake: + +/usr/share/cmake-3.31/Modules/Compiler/GNU.cmake: + +/usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake: + +/home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp: + +/usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake: + +/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h: + +/usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake: + +/usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake: + +/usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake: + +/usr/share/cmake-3.31/Modules/Platform/Linux.cmake: + +/usr/include/c++/14/ext/aligned_buffer.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h: + +TanksGame_autogen/mocs_compilation.cpp: + +/usr/include/stdlib.h: + +/usr/include/alloca.h: + +/usr/include/c++/14/variant: + +/usr/include/c++/14/bits/codecvt.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent: + +/usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake: + +/usr/include/x86_64-linux-gnu/bits/errno.h: + +/usr/include/c++/14/bits/hashtable.h: + +/usr/include/c++/14/bits/locale_conv.h: + +/usr/include/c++/14/bits/unicode-data.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake: + +/usr/include/c++/14/locale: + +/usr/include/wchar.h: + +/usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + +/usr/include/c++/14/map: + +/usr/include/c++/14/bits/unicode.h: + +/usr/include/c++/14/bits/unordered_map.h: + +/usr/include/c++/14/istream: + +/usr/include/c++/14/pstl/glue_memory_defs.h: + +/usr/include/c++/14/span: + +/usr/include/c++/14/system_error: + +/usr/include/linux/close_range.h: + +/usr/include/x86_64-linux-gnu/bits/byteswap.h: + +/usr/include/c++/14/bits/uses_allocator.h: + +/usr/include/x86_64-linux-gnu/bits/local_lim.h: + +/usr/include/x86_64-linux-gnu/bits/stdint-least.h: + +/usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + +/usr/include/x86_64-linux-gnu/bits/uio_lim.h: + +/home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp: + +/usr/include/x86_64-linux-gnu/bits/waitstatus.h: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake: + +/usr/include/x86_64-linux-gnu/bits/xopen_lim.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h: + +/usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h: + +/lib/x86_64-linux-gnu/libdouble-conversion.so.3: + +/usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake: + +/usr/include/x86_64-linux-gnu/sys/single_threaded.h: + +/usr/include/x86_64-linux-gnu/sys/types.h: + +/usr/include/c++/14/vector: + +/usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/QBrush: + +/home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap: + +/usr/include/c++/14/bits/random.h: + +/usr/include/c++/14/tr1/bessel_function.tcc: diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.ts b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.ts new file mode 100644 index 0000000..d81bda8 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.ts @@ -0,0 +1,2 @@ +# CMAKE generated file: DO NOT EDIT! +# Timestamp file for compiler generated dependencies management for TanksGame. diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/depend.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/depend.make new file mode 100644 index 0000000..f3f5248 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for TanksGame. +# This may be replaced when dependencies are built. diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/flags.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/flags.make new file mode 100644 index 0000000..ad191b1 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.31 + +# compile CXX with /usr/bin/c++ +CXX_DEFINES = -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB + +CXX_INCLUDES = -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork + +CXX_FLAGS = -std=gnu++20 -fPIC + diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/link.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/link.d new file mode 100644 index 0000000..d5e5422 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/link.d @@ -0,0 +1,223 @@ +TanksGame: \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o \ + /usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o \ + CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o \ + CMakeFiles/TanksGame.dir/src/main.cpp.o \ + CMakeFiles/TanksGame.dir/src/GameScane.cpp.o \ + CMakeFiles/TanksGame.dir/src/GameModel.cpp.o \ + CMakeFiles/TanksGame.dir/src/Bonus.cpp.o \ + CMakeFiles/TanksGame.dir/src/Tank.cpp.o \ + CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o \ + CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o \ + CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o \ + CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o \ + CMakeFiles/TanksGame.dir/src/Wall.cpp.o \ + CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o \ + CMakeFiles/TanksGame.dir/src/Bullet.cpp.o \ + /usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Multimedia.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Network.so.5.15.15 \ + /usr/lib/x86_64-linux-gnu/libQt5Core.so.5.15.15 \ + /usr/lib/gcc/x86_64-linux-gnu/14/libstdc++.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libm.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libm.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libm.so \ + /lib/x86_64-linux-gnu/libm.so.6 \ + /lib/x86_64-linux-gnu/libmvec.so.1 \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libgcc_s.so.1 \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libc.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libc.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libc.so \ + /lib/x86_64-linux-gnu/libc.so.6 \ + /usr/lib/x86_64-linux-gnu/libc_nonshared.a \ + /lib64/ld-linux-x86-64.so.2 \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libgcc_s.so.1 \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a \ + /usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a \ + /usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o \ + /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o \ + /lib/x86_64-linux-gnu/libm.so.6 \ + /lib/x86_64-linux-gnu/libGL.so.1 \ + /lib/x86_64-linux-gnu/libpng16.so.16 \ + /lib/x86_64-linux-gnu/libz.so.1 \ + /lib/x86_64-linux-gnu/libharfbuzz.so.0 \ + /lib/x86_64-linux-gnu/libmd4c.so.0 \ + /lib/x86_64-linux-gnu/libdouble-conversion.so.3 \ + /lib/x86_64-linux-gnu/libicui18n.so.76 \ + /lib/x86_64-linux-gnu/libicuuc.so.76 \ + /lib/x86_64-linux-gnu/libpcre2-16.so.0 \ + /lib/x86_64-linux-gnu/libzstd.so.1 \ + /lib/x86_64-linux-gnu/libglib-2.0.so.0 \ + /lib64/ld-linux-x86-64.so.2 \ + /lib/x86_64-linux-gnu/libGLdispatch.so.0 \ + /lib/x86_64-linux-gnu/libGLX.so.0 \ + /lib/x86_64-linux-gnu/libfreetype.so.6 \ + /lib/x86_64-linux-gnu/libgraphite2.so.3 \ + /lib/x86_64-linux-gnu/libicudata.so.76 \ + /lib/x86_64-linux-gnu/libatomic.so.1 \ + /lib/x86_64-linux-gnu/libpcre2-8.so.0 \ + /lib/x86_64-linux-gnu/libX11.so.6 \ + /lib/x86_64-linux-gnu/libbz2.so.1.0 \ + /lib/x86_64-linux-gnu/libbrotlidec.so.1 \ + /lib/x86_64-linux-gnu/libxcb.so.1 \ + /lib/x86_64-linux-gnu/libbrotlicommon.so.1 \ + /lib/x86_64-linux-gnu/libXau.so.6 \ + /lib/x86_64-linux-gnu/libXdmcp.so.6 + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crti.o: + +/usr/lib/gcc/x86_64-linux-gnu/14/crtbeginS.o: + +CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: + +CMakeFiles/TanksGame.dir/src/main.cpp.o: + +CMakeFiles/TanksGame.dir/src/GameScane.cpp.o: + +CMakeFiles/TanksGame.dir/src/GameModel.cpp.o: + +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: + +CMakeFiles/TanksGame.dir/src/Tank.cpp.o: + +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: + +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o: + +CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o: + +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o: + +CMakeFiles/TanksGame.dir/src/Wall.cpp.o: + +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o: + +CMakeFiles/TanksGame.dir/src/Bullet.cpp.o: + +/usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Multimedia.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Network.so.5.15.15: + +/usr/lib/x86_64-linux-gnu/libQt5Core.so.5.15.15: + +/usr/lib/gcc/x86_64-linux-gnu/14/libstdc++.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libm.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libm.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libm.so: + +/lib/x86_64-linux-gnu/libm.so.6: + +/lib/x86_64-linux-gnu/libmvec.so.1: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libgcc_s.so.1: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libc.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libc.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libc.so: + +/lib/x86_64-linux-gnu/libc.so.6: + +/usr/lib/x86_64-linux-gnu/libc_nonshared.a: + +/lib64/ld-linux-x86-64.so.2: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc_s.so: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/libgcc_s.so.1: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a: + +/usr/lib/gcc/x86_64-linux-gnu/14/libgcc.a: + +/usr/lib/gcc/x86_64-linux-gnu/14/crtendS.o: + +/usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/crtn.o: + +/lib/x86_64-linux-gnu/libm.so.6: + +/lib/x86_64-linux-gnu/libGL.so.1: + +/lib/x86_64-linux-gnu/libpng16.so.16: + +/lib/x86_64-linux-gnu/libz.so.1: + +/lib/x86_64-linux-gnu/libharfbuzz.so.0: + +/lib/x86_64-linux-gnu/libmd4c.so.0: + +/lib/x86_64-linux-gnu/libdouble-conversion.so.3: + +/lib/x86_64-linux-gnu/libicui18n.so.76: + +/lib/x86_64-linux-gnu/libicuuc.so.76: + +/lib/x86_64-linux-gnu/libpcre2-16.so.0: + +/lib/x86_64-linux-gnu/libzstd.so.1: + +/lib/x86_64-linux-gnu/libglib-2.0.so.0: + +/lib64/ld-linux-x86-64.so.2: + +/lib/x86_64-linux-gnu/libGLdispatch.so.0: + +/lib/x86_64-linux-gnu/libGLX.so.0: + +/lib/x86_64-linux-gnu/libfreetype.so.6: + +/lib/x86_64-linux-gnu/libgraphite2.so.3: + +/lib/x86_64-linux-gnu/libicudata.so.76: + +/lib/x86_64-linux-gnu/libatomic.so.1: + +/lib/x86_64-linux-gnu/libpcre2-8.so.0: + +/lib/x86_64-linux-gnu/libX11.so.6: + +/lib/x86_64-linux-gnu/libbz2.so.1.0: + +/lib/x86_64-linux-gnu/libbrotlidec.so.1: + +/lib/x86_64-linux-gnu/libxcb.so.1: + +/lib/x86_64-linux-gnu/libbrotlicommon.so.1: + +/lib/x86_64-linux-gnu/libXau.so.6: + +/lib/x86_64-linux-gnu/libXdmcp.so.6: diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/link.txt b/cmake-build-debug/CMakeFiles/TanksGame.dir/link.txt new file mode 100644 index 0000000..ba51a29 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/link.txt @@ -0,0 +1 @@ +/usr/bin/c++ -Wl,--dependency-file=CMakeFiles/TanksGame.dir/link.d CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o CMakeFiles/TanksGame.dir/src/main.cpp.o CMakeFiles/TanksGame.dir/src/GameScane.cpp.o CMakeFiles/TanksGame.dir/src/GameModel.cpp.o CMakeFiles/TanksGame.dir/src/Bonus.cpp.o CMakeFiles/TanksGame.dir/src/Tank.cpp.o CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o CMakeFiles/TanksGame.dir/src/Wall.cpp.o CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o CMakeFiles/TanksGame.dir/src/Bullet.cpp.o -o TanksGame /usr/lib/x86_64-linux-gnu/libQt5Widgets.so.5.15.15 /usr/lib/x86_64-linux-gnu/libQt5Multimedia.so.5.15.15 /usr/lib/x86_64-linux-gnu/libQt5Gui.so.5.15.15 /usr/lib/x86_64-linux-gnu/libQt5Network.so.5.15.15 /usr/lib/x86_64-linux-gnu/libQt5Core.so.5.15.15 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/progress.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/progress.make new file mode 100644 index 0000000..1029366 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/progress.make @@ -0,0 +1,16 @@ +CMAKE_PROGRESS_1 = 1 +CMAKE_PROGRESS_2 = 2 +CMAKE_PROGRESS_3 = 3 +CMAKE_PROGRESS_4 = 4 +CMAKE_PROGRESS_5 = 5 +CMAKE_PROGRESS_6 = 6 +CMAKE_PROGRESS_7 = 7 +CMAKE_PROGRESS_8 = 8 +CMAKE_PROGRESS_9 = 9 +CMAKE_PROGRESS_10 = 10 +CMAKE_PROGRESS_11 = 11 +CMAKE_PROGRESS_12 = 12 +CMAKE_PROGRESS_13 = 13 +CMAKE_PROGRESS_14 = 14 +CMAKE_PROGRESS_15 = 15 + diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..cd491e804a1185ac68b644fec1f259ebd75fcc3a GIT binary patch literal 45296 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 literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o.d new file mode 100644 index 0000000..ed83cf4 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o.d @@ -0,0 +1,373 @@ +CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/type_traits \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/version.h /usr/include/c++/14/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/utility.h /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h /usr/include/assert.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_iterator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/stl_tempbuf.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic /usr/include/c++/14/bits/atomic_base.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/c++/14/string /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/cctype /usr/include/ctype.h \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/iterator /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/streambuf /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/exception \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/ostream /usr/include/c++/14/ios \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h /usr/include/c++/14/map \ + /usr/include/c++/14/bits/stl_tree.h /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QBrush \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPen \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..3a652fe9d0790ea6413d5634a9844c6285f0c049 GIT binary patch literal 37232 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 literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o.d new file mode 100644 index 0000000..c121e57 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o.d @@ -0,0 +1,346 @@ +CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/type_traits \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/version.h /usr/include/c++/14/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/utility.h /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h /usr/include/assert.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_iterator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/stl_tempbuf.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic /usr/include/c++/14/bits/atomic_base.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/c++/14/string /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/cctype /usr/include/ctype.h \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/iterator /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/streambuf /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/exception \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/ostream /usr/include/c++/14/ios \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h /usr/include/c++/14/map \ + /usr/include/c++/14/bits/stl_tree.h /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bullet.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bullet.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..52750e8cc7c4bb86d65da229f95098a56c598e8d GIT binary patch literal 37600 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 UCjH(M&@-QJC8UpUlDg#o0~{?o`v3p{ literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o.d new file mode 100644 index 0000000..552f6a5 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o.d @@ -0,0 +1,380 @@ +CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/type_traits \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/version.h /usr/include/c++/14/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/utility.h /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h /usr/include/assert.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_iterator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/stl_tempbuf.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic /usr/include/c++/14/bits/atomic_base.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/c++/14/string /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/cctype /usr/include/ctype.h \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/iterator /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/streambuf /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/exception \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/ostream /usr/include/c++/14/ios \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h /usr/include/c++/14/map \ + /usr/include/c++/14/bits/stl_tree.h /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QRandomGenerator \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrandom.h \ + /usr/include/c++/14/random /usr/include/c++/14/cmath /usr/include/math.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/c++/14/bits/specfun.h /usr/include/c++/14/tr1/gamma.tcc \ + /usr/include/c++/14/tr1/special_function_util.h \ + /usr/include/c++/14/tr1/bessel_function.tcc \ + /usr/include/c++/14/tr1/beta_function.tcc \ + /usr/include/c++/14/tr1/ell_integral.tcc \ + /usr/include/c++/14/tr1/exp_integral.tcc \ + /usr/include/c++/14/tr1/hypergeometric.tcc \ + /usr/include/c++/14/tr1/legendre_function.tcc \ + /usr/include/c++/14/tr1/modified_bessel_func.tcc \ + /usr/include/c++/14/tr1/poly_hermite.tcc \ + /usr/include/c++/14/tr1/poly_laguerre.tcc \ + /usr/include/c++/14/tr1/riemann_zeta.tcc \ + /usr/include/c++/14/bits/random.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/opt_random.h \ + /usr/include/c++/14/bits/random.tcc \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameModel.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameModel.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..38f8a0079e71fad912b29ffdf9ed474998f96c3b GIT binary patch literal 10344 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 lu8+k*p*joawV1vM=TqLq#qADpiqTGUU2O21y(5 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 literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o.d new file mode 100644 index 0000000..b3d5f07 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o.d @@ -0,0 +1,352 @@ +CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/type_traits \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/version.h /usr/include/c++/14/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/utility.h /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h /usr/include/assert.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_iterator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/stl_tempbuf.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic /usr/include/c++/14/bits/atomic_base.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/c++/14/string /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/cctype /usr/include/ctype.h \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/iterator /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/streambuf /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/exception \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/ostream /usr/include/c++/14/ios \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h /usr/include/c++/14/map \ + /usr/include/c++/14/bits/stl_tree.h /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..e88f7eb92a0daafe75ddf911b7eabf957d0b36f6 GIT binary patch literal 41888 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 >+2^b#>cJrp+h&^ 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 Otu9FP1#B$qJmrHp2QssHo-*v(cv= z*$A7n5uRnUKv%8NheW6^YOY^y(}U$e)+b??#tt_1&Bo@2rG~FIq~(xH;Aul+C3M8D zcvcK$7}0UO7{&7IiseBt+n-K`a5&DJoV~&?>ze`7ihCjEic`e6;g&rn(O<#;_RX7x>va zYrXTu#%55_W#Oaim48R+AIhaRJx*OfKQfm_oGayA{72@}kF0dwlk{tx+e~C5$5rW9 zKsQx3a$J?XnUT}Hn<^VQt}58nU}L-OY-=yd6@pceI~$Ki;3f|4V%svE*5uz1ji8oR ze`qDFvZ_KYCf=Aq;3L}BfR9EsH~8?OUnL@R1oRZg8`FWLDlzgFura#s)0+@|70o zmw;-5MaY^Ez%mM}hK0zgsmfw01(nsch}v6PjLKEZQsHEGG?HGPF?*|FA2OIolbH^Q zEqQA_A-Ge5jd|F9>TglkGsK~m(KQ@Xql`Gb`+~J3LCywGt&V3&#-?BpPi}8pJGPoB*V8%7ZF`psPwN$ z^qJJ9Sv@L~(63}?msO|)9ZR$DD9;q_Tv(0}sg{+LxnRf$A1+bDjJgEG@oO@Mu`HHo z5647vib-8%@MAX#SX~2Zk#Aba95j5g!#2Q&>m$ND`DCLKoZlio!q*60IMGIpg4Tkg`m7}8he3ei&DPh}ru17D2>Y3 z6kokuw4bm8pMWVbK^weOWMMzA33v3tS0!Mwz-&#n2Eq1BA`4F_<6WZ5$lhctS(WY% zC-XhgZXCk51mNpE@JU?onwpMf$%S?q)e(G51CKN=jb^%W1jCfo8WMf32BWR8Lo0^L z3RrfCp4Y^>exZtBIMWSfs%~ed5V)(ev)}MV(-*g=BQSnC7WacqtWXy(dJ{?byqmcQ zK1$`%`c+As#sk58V+Wgj{#By)U7WABR?%8WZ_CkYaWq{8R8X6K=*zsKg4>fzJ+OyJvAGU$dC_7}mG@oYIJ>b*+$t=tQ znQr)km2|mLvuZhmn3GSVhMsj*)`V{ah`G92%Pg^7x!x$Q_`1dCGI8-xt6EL01SM~2 zs$F#ne47!z9w`m5o$YJV*<>=2%A^AuGA2CZhm{$h73-`dVT-LEA6(NdITsZ(GOG^e zRp_8Tvh+Z))-#ntYeWO^sip@lK83q;brv{P0VS>w1o*-!s8_#WeXY zjib#BM=ti!^y%f2+oI{T&+D_2d5q!NB$3q{-|0@74IFnm_kyTyL-c)VN;mG3WpY zynVl-aov8CIJfg!2Y!bG$Nv|Cf$RAN<1bSGd71H7iNEW>|2N}GPtJj#Lceo^$t{{c zy&Bj3e2vBvn*3IcCpA8z@pT%1T;upZc+@!hwZ_vLf0a1SC-{H1lsx{Q5)5endv z@>gj5H2OgbF8@{Hs9%@A$U(kMlfP2apLLMO|964`%gt!=-zCob!;_kPR+ImY#``q> zn#R{_{Er&npmF@aDHzb6kjCe0ykFyIX#8r8S7`iO8b43tI47(2x>Do1ooS8hc5c?V zuK!+*>-u+ST<^EfXk4HFpVPQ5FPsB!C&Q}|>{mhkLKgb%BCTEl65xD^#+xaVSTxCyMujHU1rq zU#4-jmO!*tD^clONLffX26Ie6z;4YJ6DZw`hEu#&6a5h{n}# zpdortbKbt?bP^fn*5l?Z`b&4jo+d1agBdZ<9jv!eT`3Oe4EDiYy3`) zPip)wjZbO(ZjGxS)e#5RXZYoLgV$C{F54At8vVuf*SkC!kT|ZnEXD<@MDetSt)_zZjGZZHCFdC{vyTa zkr8;nm--#Wvl&;vm)Oj>`n|*$S`KMgMow`=^6MB;si#{Z&mPer=F7d{sU z$4p8dyVY6BjD;(3FVj;2PkzFliuQEcQvp91BO)SoU51`idW2vFY-gxvlj2!ro~r$B z@i@y8&hLYZ$C7zz3**DdJT81hnaAoWBt4ge2V`V7nj;_eL9yZ~W?>rJq_6;sZ^p<6goRvta#+z7iG<7z5i^;A2gI7YRzwoLy||@X5l>{y3izMO z=ZFWo6o(JfRU~2C*i2>m$rQ6Y)QR6m@lgbeT{m!nMLoxp%m=jb!b#%(VT9o4P==m4VBL5nj{CJbD5k4oiJN2mN5oBR#4$bSvx*V`{Ji~O5y^5cGqvRfUU?7!V6|7EktKVp*~ z@55EO>gZJd!<1j|KX`wy@~NX!{v9^?@%~-qQ%9%#&)DS0`+1d59i8&;vZ;S$7Wv01 z|M7Ih@wapq`QNcAAMeMM-RkIM|0Lzt{g3N7l}{a=@~d^T-hXl3qVlO@Ig|sqU~Pv* z&qWB~1$}V`ak~7AG4AxPLXc>ee?R5->zU!4=kIgKf656m<7bQH z-|CRxNBK`IlK%mR{1;LF)*|_T=8*qB%71y0{CgepPf`BnBKh(8jTk@7vE9`EUdoT{ ze>%K)`yU2o*M1G;_;r+D9au3QT*KRyzm3Xoq>Nbp7vROqKLrZ6EB^^9ANz+Mc=;zn zX1nqyY|1|q6!G$LO=DO7+0=3R^}^wtmw$mn`3rBB8TI;q*`|Darh(eN?(wSpYX19IDxc4PL7Xfh;QX!!W~R8GwkzL54`TK42mhL5TKPGL z@^7H>F^?X2`R_Z_-)mDo)`i#qL{JDSJly{~seI)pWrNDE;-7~6cJ*INUcHf*Jbeh=#w~+ag|S{-VFJ1i3Ep&fd7vXL%Ddj-jw}{+)w56{0k}n zI7{I9?}c>H{z@So$H;#RDL?w}Yw%L}mH)6ltO%iD>J)MC>?H@{I%ydQ^ZXwN&ev|3 fbG!lHJ)Xr_uok%gJ_TuZ`S%aYOpi0;c>ezfm;0V7 literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d new file mode 100644 index 0000000..f73e379 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o.d @@ -0,0 +1,348 @@ +CMakeFiles/TanksGame.dir/src/Tank.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/type_traits \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/version.h /usr/include/c++/14/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/utility.h /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h /usr/include/assert.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_iterator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/stl_tempbuf.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic /usr/include/c++/14/bits/atomic_base.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/c++/14/string /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/cctype /usr/include/ctype.h \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/iterator /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/streambuf /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/exception \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/ostream /usr/include/c++/14/ios \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h /usr/include/c++/14/map \ + /usr/include/c++/14/bits/stl_tree.h /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..0f40cfa5a19dcd4810e7c730b3a39d4518404b87 GIT binary patch literal 92680 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 J4dctV{|C6M36lT- literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o.d new file mode 100644 index 0000000..4ecde51 --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o.d @@ -0,0 +1,353 @@ +CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/TwinShooterEnemy.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/EnemyTank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/type_traits \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/version.h /usr/include/c++/14/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/utility.h /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h /usr/include/assert.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_iterator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/stl_tempbuf.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic /usr/include/c++/14/bits/atomic_base.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/c++/14/string /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/cctype /usr/include/ctype.h \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/iterator /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/streambuf /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/exception \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/ostream /usr/include/c++/14/ios \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h /usr/include/c++/14/map \ + /usr/include/c++/14/bits/stl_tree.h /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..0e4b1139a65d8ba11f192cab1923db9e8fee6924 GIT binary patch literal 39464 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 literal 0 HcmV?d00001 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d new file mode 100644 index 0000000..fe6d28d --- /dev/null +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o.d @@ -0,0 +1,346 @@ +CMakeFiles/TanksGame.dir/src/Wall.cpp.o: \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /usr/include/stdc-predef.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/c++/14/type_traits \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/c++/14/pstl/pstl_config.h \ + /usr/include/c++/14/bits/version.h /usr/include/c++/14/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/include/c++/14/utility /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_pair.h /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/utility.h /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/ext/type_traits.h /usr/include/assert.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/c++/14/algorithm /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/bits/stl_iterator.h /usr/include/c++/14/new \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/bits/predefined_ops.h /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/stl_tempbuf.h /usr/include/c++/14/cstdlib \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/max_size_type.h /usr/include/c++/14/numbers \ + /usr/include/c++/14/bits/invoke.h /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/pstl/glue_algorithm_defs.h \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/c++/14/atomic /usr/include/c++/14/bits/atomic_base.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h /usr/include/c++/14/cstdint \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/c++/14/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/14/climits \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/c++/14/stdlib.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/include/c++/14/string /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/postypes.h /usr/include/c++/14/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/c++/14/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/cctype /usr/include/ctype.h \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/bits/alloc_traits.h /usr/include/c++/14/string_view \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/ext/string_conversions.h /usr/include/c++/14/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h /usr/include/c++/14/tuple \ + /usr/include/c++/14/iterator /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/streambuf /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/system_error \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/c++/14/stdexcept /usr/include/c++/14/exception \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/typeinfo /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/c++/14/numeric /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/limits /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/functional /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/bits/unordered_map.h \ + /usr/include/c++/14/bits/hashtable.h \ + /usr/include/c++/14/bits/hashtable_policy.h \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/bits/enable_special_members.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/erase_if.h /usr/include/c++/14/vector \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/vector.tcc /usr/include/c++/14/array \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/c++/14/list /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/align.h /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/ostream /usr/include/c++/14/ios \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/locale_facets.h /usr/include/c++/14/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/pstl/glue_memory_defs.h /usr/include/c++/14/map \ + /usr/include/c++/14/bits/stl_tree.h /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/c++/14/chrono /usr/include/c++/14/bits/chrono.h \ + /usr/include/c++/14/ratio /usr/include/c++/14/ctime \ + /usr/include/c++/14/bits/parse_numbers.h /usr/include/c++/14/sstream \ + /usr/include/c++/14/istream /usr/include/c++/14/bits/istream.tcc \ + /usr/include/c++/14/bits/sstream.tcc \ + /usr/include/c++/14/bits/chrono_io.h /usr/include/c++/14/iomanip \ + /usr/include/c++/14/locale \ + /usr/include/c++/14/bits/locale_facets_nonio.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h \ + /usr/include/libintl.h /usr/include/c++/14/bits/codecvt.h \ + /usr/include/c++/14/bits/locale_facets_nonio.tcc \ + /usr/include/c++/14/bits/locale_conv.h \ + /usr/include/c++/14/bits/quoted_string.h /usr/include/c++/14/format \ + /usr/include/c++/14/charconv /usr/include/c++/14/optional \ + /usr/include/c++/14/span /usr/include/c++/14/variant \ + /usr/include/c++/14/bits/unicode.h \ + /usr/include/c++/14/bits/unicode-data.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtextoption.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontmetrics.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/main.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/main.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..61febc9716ac5e5d80091c70e7171235cc56be4f GIT binary patch literal 31448 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 +#include "../../../include/GameModel.h" +#include +#include +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'GameModel.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 67 +#error "This file was generated using the moc from 5.15.15. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED +struct qt_meta_stringdata_GameModel_t { + QByteArrayData data[16]; + char stringdata0[145]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + qptrdiff(offsetof(qt_meta_stringdata_GameModel_t, stringdata0) + ofs \ + - idx * sizeof(QByteArrayData)) \ + ) +static const qt_meta_stringdata_GameModel_t qt_meta_stringdata_GameModel = { + { +QT_MOC_LITERAL(0, 0, 9), // "GameModel" +QT_MOC_LITERAL(1, 10, 12), // "livesChanged" +QT_MOC_LITERAL(2, 23, 0), // "" +QT_MOC_LITERAL(3, 24, 12), // "scoreChanged" +QT_MOC_LITERAL(4, 37, 8), // "gameOver" +QT_MOC_LITERAL(5, 46, 7), // "gameWon" +QT_MOC_LITERAL(6, 54, 17), // "ModifyPlayerLives" +QT_MOC_LITERAL(7, 72, 5), // "delta" +QT_MOC_LITERAL(8, 78, 11), // "ModifyScore" +QT_MOC_LITERAL(9, 90, 11), // "SetGameOver" +QT_MOC_LITERAL(10, 102, 1), // "v" +QT_MOC_LITERAL(11, 104, 10), // "SetGameWon" +QT_MOC_LITERAL(12, 115, 8), // "SetLives" +QT_MOC_LITERAL(13, 124, 5), // "lives" +QT_MOC_LITERAL(14, 130, 8), // "SetKills" +QT_MOC_LITERAL(15, 139, 5) // "kills" + + }, + "GameModel\0livesChanged\0\0scoreChanged\0" + "gameOver\0gameWon\0ModifyPlayerLives\0" + "delta\0ModifyScore\0SetGameOver\0v\0" + "SetGameWon\0SetLives\0lives\0SetKills\0" + "kills" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_GameModel[] = { + + // content: + 8, // revision + 0, // classname + 0, 0, // classinfo + 12, 14, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 4, // signalCount + + // signals: name, argc, parameters, tag, flags + 1, 1, 74, 2, 0x06 /* Public */, + 3, 1, 77, 2, 0x06 /* Public */, + 4, 0, 80, 2, 0x06 /* Public */, + 5, 0, 81, 2, 0x06 /* Public */, + + // slots: name, argc, parameters, tag, flags + 6, 1, 82, 2, 0x0a /* Public */, + 8, 1, 85, 2, 0x0a /* Public */, + 9, 1, 88, 2, 0x0a /* Public */, + 9, 0, 91, 2, 0x2a /* Public | MethodCloned */, + 11, 1, 92, 2, 0x0a /* Public */, + 11, 0, 95, 2, 0x2a /* Public | MethodCloned */, + 12, 1, 96, 2, 0x0a /* Public */, + 14, 1, 99, 2, 0x0a /* Public */, + + // signals: parameters + QMetaType::Void, QMetaType::Int, 2, + QMetaType::Void, QMetaType::Int, 2, + QMetaType::Void, + QMetaType::Void, + + // slots: parameters + QMetaType::Void, QMetaType::Int, 7, + QMetaType::Void, QMetaType::Int, 7, + QMetaType::Void, QMetaType::Bool, 10, + QMetaType::Void, + QMetaType::Void, QMetaType::Bool, 10, + QMetaType::Void, + QMetaType::Void, QMetaType::Int, 13, + QMetaType::Void, QMetaType::Int, 15, + + 0 // eod +}; + +void GameModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + if (_c == QMetaObject::InvokeMetaMethod) { + auto *_t = static_cast(_o); + (void)_t; + switch (_id) { + case 0: _t->livesChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 1: _t->scoreChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 2: _t->gameOver(); break; + case 3: _t->gameWon(); break; + case 4: _t->ModifyPlayerLives((*reinterpret_cast< int(*)>(_a[1]))); break; + case 5: _t->ModifyScore((*reinterpret_cast< int(*)>(_a[1]))); break; + case 6: _t->SetGameOver((*reinterpret_cast< bool(*)>(_a[1]))); break; + case 7: _t->SetGameOver(); break; + case 8: _t->SetGameWon((*reinterpret_cast< bool(*)>(_a[1]))); break; + case 9: _t->SetGameWon(); break; + case 10: _t->SetLives((*reinterpret_cast< int(*)>(_a[1]))); break; + case 11: _t->SetKills((*reinterpret_cast< int(*)>(_a[1]))); break; + default: ; + } + } else if (_c == QMetaObject::IndexOfMethod) { + int *result = reinterpret_cast(_a[0]); + { + using _t = void (GameModel::*)(int ); + if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&GameModel::livesChanged)) { + *result = 0; + return; + } + } + { + using _t = void (GameModel::*)(int ); + if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&GameModel::scoreChanged)) { + *result = 1; + return; + } + } + { + using _t = void (GameModel::*)(); + if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&GameModel::gameOver)) { + *result = 2; + return; + } + } + { + using _t = void (GameModel::*)(); + if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&GameModel::gameWon)) { + *result = 3; + return; + } + } + } +} + +QT_INIT_METAOBJECT const QMetaObject GameModel::staticMetaObject = { { + QMetaObject::SuperData::link(), + qt_meta_stringdata_GameModel.data, + qt_meta_data_GameModel, + qt_static_metacall, + nullptr, + nullptr +} }; + + +const QMetaObject *GameModel::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *GameModel::qt_metacast(const char *_clname) +{ + if (!_clname) return nullptr; + if (!strcmp(_clname, qt_meta_stringdata_GameModel.stringdata0)) + return static_cast(this); + return QObject::qt_metacast(_clname); +} + +int GameModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QObject::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + if (_id < 12) + qt_static_metacall(this, _c, _id, _a); + _id -= 12; + } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { + if (_id < 12) + *reinterpret_cast(_a[0]) = -1; + _id -= 12; + } + return _id; +} + +// SIGNAL 0 +void GameModel::livesChanged(int _t1) +{ + void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; + QMetaObject::activate(this, &staticMetaObject, 0, _a); +} + +// SIGNAL 1 +void GameModel::scoreChanged(int _t1) +{ + void *_a[] = { nullptr, const_cast(reinterpret_cast(std::addressof(_t1))) }; + QMetaObject::activate(this, &staticMetaObject, 1, _a); +} + +// SIGNAL 2 +void GameModel::gameOver() +{ + QMetaObject::activate(this, &staticMetaObject, 2, nullptr); +} + +// SIGNAL 3 +void GameModel::gameWon() +{ + QMetaObject::activate(this, &staticMetaObject, 3, nullptr); +} +QT_WARNING_POP +QT_END_MOC_NAMESPACE diff --git a/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp.d b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp.d new file mode 100644 index 0000000..cc6e458 --- /dev/null +++ b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp.d @@ -0,0 +1,309 @@ +/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp: /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h diff --git a/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp new file mode 100644 index 0000000..5b5d3c7 --- /dev/null +++ b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp @@ -0,0 +1,119 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'GameScane.h' +** +** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.15) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include +#include "../../../include/GameScane.h" +#include +#include +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'GameScane.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 67 +#error "This file was generated using the moc from 5.15.15. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +QT_WARNING_PUSH +QT_WARNING_DISABLE_DEPRECATED +struct qt_meta_stringdata_GameScane_t { + QByteArrayData data[3]; + char stringdata0[18]; +}; +#define QT_MOC_LITERAL(idx, ofs, len) \ + Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \ + qptrdiff(offsetof(qt_meta_stringdata_GameScane_t, stringdata0) + ofs \ + - idx * sizeof(QByteArrayData)) \ + ) +static const qt_meta_stringdata_GameScane_t qt_meta_stringdata_GameScane = { + { +QT_MOC_LITERAL(0, 0, 9), // "GameScane" +QT_MOC_LITERAL(1, 10, 6), // "Update" +QT_MOC_LITERAL(2, 17, 0) // "" + + }, + "GameScane\0Update\0" +}; +#undef QT_MOC_LITERAL + +static const uint qt_meta_data_GameScane[] = { + + // content: + 8, // revision + 0, // classname + 0, 0, // classinfo + 1, 14, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + // slots: name, argc, parameters, tag, flags + 1, 0, 19, 2, 0x08 /* Private */, + + // slots: parameters + QMetaType::Void, + + 0 // eod +}; + +void GameScane::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + if (_c == QMetaObject::InvokeMetaMethod) { + auto *_t = static_cast(_o); + (void)_t; + switch (_id) { + case 0: _t->Update(); break; + default: ; + } + } + (void)_a; +} + +QT_INIT_METAOBJECT const QMetaObject GameScane::staticMetaObject = { { + QMetaObject::SuperData::link(), + qt_meta_stringdata_GameScane.data, + qt_meta_data_GameScane, + qt_static_metacall, + nullptr, + nullptr +} }; + + +const QMetaObject *GameScane::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject; +} + +void *GameScane::qt_metacast(const char *_clname) +{ + if (!_clname) return nullptr; + if (!strcmp(_clname, qt_meta_stringdata_GameScane.stringdata0)) + return static_cast(this); + return QGraphicsScene::qt_metacast(_clname); +} + +int GameScane::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QGraphicsScene::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + if (_id < 1) + qt_static_metacall(this, _c, _id, _a); + _id -= 1; + } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { + if (_id < 1) + *reinterpret_cast(_a[0]) = -1; + _id -= 1; + } + return _id; +} +QT_WARNING_POP +QT_END_MOC_NAMESPACE diff --git a/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d new file mode 100644 index 0000000..3f07975 --- /dev/null +++ b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d @@ -0,0 +1,371 @@ +/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp: /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h diff --git a/cmake-build-debug/TanksGame_autogen/deps b/cmake-build-debug/TanksGame_autogen/deps new file mode 100644 index 0000000..da1914d --- /dev/null +++ b/cmake-build-debug/TanksGame_autogen/deps @@ -0,0 +1,457 @@ +TanksGame_autogen/timestamp: \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /usr/bin/cmake diff --git a/cmake-build-debug/TanksGame_autogen/moc_predefs.h b/cmake-build-debug/TanksGame_autogen/moc_predefs.h new file mode 100644 index 0000000..6dabae7 --- /dev/null +++ b/cmake-build-debug/TanksGame_autogen/moc_predefs.h @@ -0,0 +1,487 @@ +#define __DBL_MIN_EXP__ (-1021) +#define __cpp_nontype_template_parameter_auto 201606L +#define __UINT_LEAST16_MAX__ 0xffff +#define __FLT16_HAS_QUIET_NAN__ 1 +#define __ATOMIC_ACQUIRE 2 +#define __FLT128_MAX_10_EXP__ 4932 +#define __FLT_MIN__ 1.17549435082228750796873653722224568e-38F +#define __GCC_IEC_559_COMPLEX 2 +#define __cpp_aggregate_nsdmi 201304L +#define __UINT_LEAST8_TYPE__ unsigned char +#define __SIZEOF_FLOAT80__ 16 +#define __BFLT16_DENORM_MIN__ 9.18354961579912115600575419704879436e-41BF16 +#define __cpp_impl_three_way_comparison 201907L +#define __INTMAX_C(c) c ## L +#define __CHAR_BIT__ 8 +#define __cpp_designated_initializers 201707L +#define __UINT8_MAX__ 0xff +#define __SCHAR_WIDTH__ 8 +#define __WINT_MAX__ 0xffffffffU +#define __FLT32_MIN_EXP__ (-125) +#define __cpp_static_assert 201411L +#define __BFLT16_MIN_10_EXP__ (-37) +#define QT_GUI_LIB 1 +#define __ORDER_LITTLE_ENDIAN__ 1234 +#define __WCHAR_MAX__ 0x7fffffff +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1 +#define __GCC_ATOMIC_CHAR_LOCK_FREE 2 +#define __GCC_IEC_559 2 +#define __FLT32X_DECIMAL_DIG__ 17 +#define __FLT_EVAL_METHOD__ 0 +#define __cpp_binary_literals 201304L +#define __FLT64_DECIMAL_DIG__ 17 +#define __CET__ 3 +#define __cpp_noexcept_function_type 201510L +#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2 +#define __cpp_variadic_templates 200704L +#define __UINT_FAST64_MAX__ 0xffffffffffffffffUL +#define __SIG_ATOMIC_TYPE__ int +#define __DBL_MIN_10_EXP__ (-307) +#define __FINITE_MATH_ONLY__ 0 +#define __cpp_variable_templates 201304L +#define __FLT32X_MAX_EXP__ 1024 +#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1 +#define __FLT32_HAS_DENORM__ 1 +#define __UINT_FAST8_MAX__ 0xff +#define __cpp_rvalue_reference 200610L +#define __cpp_nested_namespace_definitions 201411L +#define __DEC64_MAX_EXP__ 385 +#define __INT8_C(c) c +#define __LDBL_HAS_INFINITY__ 1 +#define __INT_LEAST8_WIDTH__ 8 +#define __cpp_variadic_using 201611L +#define __UINT_LEAST64_MAX__ 0xffffffffffffffffUL +#define __INT_LEAST8_MAX__ 0x7f +#define __cpp_attributes 200809L +#define __cpp_capture_star_this 201603L +#define __SHRT_MAX__ 0x7fff +#define __LDBL_MAX__ 1.18973149535723176502126385303097021e+4932L +#define __cpp_impl_coroutine 201902L +#define __FLT64X_MAX_10_EXP__ 4932 +#define __cpp_if_constexpr 201606L +#define __BFLT16_MAX_10_EXP__ 38 +#define __BFLT16_MAX_EXP__ 128 +#define __LDBL_IS_IEC_60559__ 1 +#define QT_NO_DEBUG 1 +#define __FLT64X_HAS_QUIET_NAN__ 1 +#define __UINT_LEAST8_MAX__ 0xff +#define __GCC_ATOMIC_BOOL_LOCK_FREE 2 +#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966F128 +#define __UINTMAX_TYPE__ long unsigned int +#define __cpp_nsdmi 200809L +#define __BFLT16_DECIMAL_DIG__ 4 +#define __linux 1 +#define __DEC32_EPSILON__ 1E-6DF +#define __FLT_EVAL_METHOD_TS_18661_3__ 0 +#define __UINT32_MAX__ 0xffffffffU +#define __GXX_EXPERIMENTAL_CXX0X__ 1 +#define __DBL_DENORM_MIN__ double(4.94065645841246544176568792868221372e-324L) +#define __FLT128_MIN_EXP__ (-16381) +#define __WINT_MIN__ 0U +#define __FLT128_MIN_10_EXP__ (-4931) +#define __FLT32X_IS_IEC_60559__ 1 +#define __INT_LEAST16_WIDTH__ 16 +#define __SCHAR_MAX__ 0x7f +#define __FLT128_MANT_DIG__ 113 +#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1) +#define __INT64_C(c) c ## L +#define __SSP_STRONG__ 3 +#define __cpp_impl_destroying_delete 201806L +#define __GCC_ATOMIC_POINTER_LOCK_FREE 2 +#define __ATOMIC_SEQ_CST 5 +#define __unix 1 +#define __INT_LEAST64_MAX__ 0x7fffffffffffffffL +#define __FLT32X_MANT_DIG__ 53 +#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2 +#define __cpp_aligned_new 201606L +#define __FLT32_MAX_10_EXP__ 38 +#define __FLT64X_EPSILON__ 1.08420217248550443400745280086994171e-19F64x +#define __STDC_HOSTED__ 1 +#define __DEC64_MIN_EXP__ (-382) +#define __cpp_decltype_auto 201304L +#define __DBL_DIG__ 15 +#define __FLT_EPSILON__ 1.19209289550781250000000000000000000e-7F +#define __cpp_char8_t 202207L +#define __GXX_WEAK__ 1 +#define __SHRT_WIDTH__ 16 +#define __FLT32_IS_IEC_60559__ 1 +#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L +#define __DBL_IS_IEC_60559__ 1 +#define __DEC32_MAX__ 9.999999E96DF +#define __CHAR8_TYPE__ unsigned char +#define __cpp_threadsafe_static_init 200806L +#define __cpp_enumerator_attributes 201411L +#define __FLT64X_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951F64x +#define __FLT32X_HAS_INFINITY__ 1 +#define __unix__ 1 +#define __INT_WIDTH__ 32 +#define __STDC_IEC_559__ 1 +#define __STDC_ISO_10646__ 201706L +#define __GCC_ATOMIC_CHAR8_T_LOCK_FREE 2 +#define __DECIMAL_DIG__ 21 +#define __STDC_IEC_559_COMPLEX__ 1 +#define __FLT64_EPSILON__ 2.22044604925031308084726333618164062e-16F64 +#define __gnu_linux__ 1 +#define __INT16_MAX__ 0x7fff +#define __FLT64_MIN_EXP__ (-1021) +#define __cpp_using_enum 201907L +#define __FLT64X_MIN_10_EXP__ (-4931) +#define __LDBL_HAS_QUIET_NAN__ 1 +#define __cpp_return_type_deduction 201304L +#define __FLT16_MIN_EXP__ (-13) +#define __FLT64_MANT_DIG__ 53 +#define __cpp_consteval 202211L +#define __FLT64X_MANT_DIG__ 64 +#define __BFLT16_DIG__ 2 +#define __GNUC__ 14 +#define __GXX_RTTI 1 +#define __pie__ 2 +#define __MMX__ 1 +#define __FLT_HAS_DENORM__ 1 +#define __SIZEOF_LONG_DOUBLE__ 16 +#define __BIGGEST_ALIGNMENT__ 16 +#define __STDC_UTF_16__ 1 +#define __FLT64_MAX_10_EXP__ 308 +#define __BFLT16_IS_IEC_60559__ 0 +#define __FLT16_MAX_10_EXP__ 4 +#define __cpp_delegating_constructors 200604L +#define __DBL_MAX__ double(1.79769313486231570814527423731704357e+308L) +#define __cpp_raw_strings 200710L +#define __INT_FAST32_MAX__ 0x7fffffffffffffffL +#define __DBL_HAS_INFINITY__ 1 +#define __INT64_MAX__ 0x7fffffffffffffffL +#define __SIZEOF_FLOAT__ 4 +#define __HAVE_SPECULATION_SAFE_VALUE 1 +#define __cpp_fold_expressions 201603L +#define __DEC32_MIN_EXP__ (-94) +#define __INTPTR_WIDTH__ 64 +#define __UINT_LEAST32_MAX__ 0xffffffffU +#define __FLT32X_HAS_DENORM__ 1 +#define __INT_FAST16_TYPE__ long int +#define __MMX_WITH_SSE__ 1 +#define __LDBL_HAS_DENORM__ 1 +#define QT_WIDGETS_LIB 1 +#define __SEG_GS 1 +#define __BFLT16_EPSILON__ 7.81250000000000000000000000000000000e-3BF16 +#define __cplusplus 202002L +#define __cpp_ref_qualifiers 200710L +#define __DEC32_MIN__ 1E-95DF +#define __DEPRECATED 1 +#define __cpp_rvalue_references 200610L +#define __DBL_MAX_EXP__ 1024 +#define __WCHAR_WIDTH__ 32 +#define __FLT32_MAX__ 3.40282346638528859811704183484516925e+38F32 +#define __DEC128_EPSILON__ 1E-33DL +#define __FLT16_DECIMAL_DIG__ 5 +#define __SSE2_MATH__ 1 +#define __ATOMIC_HLE_RELEASE 131072 +#define __PTRDIFF_MAX__ 0x7fffffffffffffffL +#define __amd64 1 +#define __ATOMIC_HLE_ACQUIRE 65536 +#define __GNUG__ 14 +#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL +#define __SIZEOF_SIZE_T__ 8 +#define __BFLT16_HAS_INFINITY__ 1 +#define __FLT64X_MIN_EXP__ (-16381) +#define __SIZEOF_WINT_T__ 4 +#define __FLT32X_DIG__ 15 +#define __LONG_LONG_WIDTH__ 64 +#define __cpp_initializer_lists 200806L +#define __FLT32_MAX_EXP__ 128 +#define ABI_ID "ELF" +#define __cpp_hex_float 201603L +#define __GXX_ABI_VERSION 1019 +#define __FLT_MIN_EXP__ (-125) +#define __GCC_HAVE_DWARF2_CFI_ASM 1 +#define __x86_64 1 +#define __cpp_lambdas 200907L +#define __INT_FAST64_TYPE__ long int +#define __BFLT16_MAX__ 3.38953138925153547590470800371487867e+38BF16 +#define __FLT64_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F64 +#define __cpp_template_auto 201606L +#define __FLT16_DENORM_MIN__ 5.96046447753906250000000000000000000e-8F16 +#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34F128 +#define __FLT64X_NORM_MAX__ 1.18973149535723176502126385303097021e+4932F64x +#define __SIZEOF_POINTER__ 8 +#define __SIZE_TYPE__ long unsigned int +#define __LP64__ 1 +#define __DBL_HAS_QUIET_NAN__ 1 +#define __FLT32X_EPSILON__ 2.22044604925031308084726333618164062e-16F32x +#define __LDBL_MAX_EXP__ 16384 +#define __DECIMAL_BID_FORMAT__ 1 +#define __FLT64_MIN_10_EXP__ (-307) +#define __FLT16_MIN_10_EXP__ (-4) +#define __FLT64X_DECIMAL_DIG__ 21 +#define __DEC128_MIN__ 1E-6143DL +#define __REGISTER_PREFIX__ +#define __UINT16_MAX__ 0xffff +#define __FLT128_HAS_INFINITY__ 1 +#define __FLT32_MIN__ 1.17549435082228750796873653722224568e-38F32 +#define __UINT8_TYPE__ unsigned char +#define __FLT_DIG__ 6 +#define __NO_INLINE__ 1 +#define __DEC_EVAL_METHOD__ 2 +#define __FLT_MANT_DIG__ 24 +#define __LDBL_DECIMAL_DIG__ 21 +#define __VERSION__ "14.2.0" +#define __UINT64_C(c) c ## UL +#define __cpp_unicode_characters 201411L +#define _STDC_PREDEF_H 1 +#define __INT_LEAST32_MAX__ 0x7fffffff +#define __GCC_ATOMIC_INT_LOCK_FREE 2 +#define __FLT128_MAX_EXP__ 16384 +#define __cpp_conditional_explicit 201806L +#define __FLT32_MANT_DIG__ 24 +#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__ +#define SIZEOF_DPTR (sizeof(void*)) +#define __FLT32X_MIN_EXP__ (-1021) +#define __cpp_aggregate_paren_init 201902L +#define __STDC_IEC_60559_COMPLEX__ 201404L +#define __cpp_aggregate_bases 201603L +#define __BFLT16_MIN__ 1.17549435082228750796873653722224568e-38BF16 +#define __FLT128_HAS_DENORM__ 1 +#define __FLT32_DECIMAL_DIG__ 9 +#define __FLT128_DIG__ 33 +#define __INT32_C(c) c +#define __DEC64_EPSILON__ 1E-15DD +#define __ORDER_PDP_ENDIAN__ 3412 +#define __DEC128_MIN_EXP__ (-6142) +#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL +#define __cpp_constinit 201907L +#define __INT_FAST32_TYPE__ long int +#define __UINT_LEAST16_TYPE__ short unsigned int +#define __DEC128_MAX_EXP__ 6145 +#define unix 1 +#define __DBL_HAS_DENORM__ 1 +#define __cpp_rtti 199711L +#define __UINT64_MAX__ 0xffffffffffffffffUL +#define __FLT_IS_IEC_60559__ 1 +#define __GNUC_WIDE_EXECUTION_CHARSET_NAME "UTF-32LE" +#define __FLT64X_DIG__ 18 +#define __INT8_TYPE__ signed char +#define __cpp_digit_separators 201309L +#define __ELF__ 1 +#define __GCC_ASM_FLAG_OUTPUTS__ 1 +#define __UINT32_TYPE__ unsigned int +#define __BFLT16_HAS_QUIET_NAN__ 1 +#define __FLT_RADIX__ 2 +#define __INT_LEAST16_TYPE__ short int +#define __LDBL_EPSILON__ 1.08420217248550443400745280086994171e-19L +#define __UINTMAX_C(c) c ## UL +#define __FLT16_DIG__ 3 +#define __k8 1 +#define QT_MULTIMEDIA_LIB 1 +#define __FLT32X_MIN__ 2.22507385850720138309023271733240406e-308F32x +#define __SIG_ATOMIC_MAX__ 0x7fffffff +#define __cpp_constexpr 202002L +#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2 +#define __USER_LABEL_PREFIX__ +#define __STDC_IEC_60559_BFP__ 201404L +#define __SIZEOF_PTRDIFF_T__ 8 +#define __FLT64X_HAS_INFINITY__ 1 +#define __SIZEOF_LONG__ 8 +#define __LDBL_DIG__ 18 +#define __FLT64_IS_IEC_60559__ 1 +#define __x86_64__ 1 +#define __FLT16_IS_IEC_60559__ 1 +#define __FLT16_MAX_EXP__ 16 +#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF +#define __INT_FAST16_MAX__ 0x7fffffffffffffffL +#define __GCC_CONSTRUCTIVE_SIZE 64 +#define __FLT64_DIG__ 15 +#define __UINT_FAST32_MAX__ 0xffffffffffffffffUL +#define __UINT_LEAST64_TYPE__ long unsigned int +#define __FLT16_EPSILON__ 9.76562500000000000000000000000000000e-4F16 +#define __FLT_HAS_QUIET_NAN__ 1 +#define __FLT_MAX_10_EXP__ 38 +#define __FLT64X_HAS_DENORM__ 1 +#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL +#define __FLT_HAS_INFINITY__ 1 +#define __GNUC_EXECUTION_CHARSET_NAME "UTF-8" +#define __cpp_unicode_literals 200710L +#define __UINT_FAST16_TYPE__ long unsigned int +#define __DEC64_MAX__ 9.999999999999999E384DD +#define __INT_FAST32_WIDTH__ 64 +#define __CHAR16_TYPE__ short unsigned int +#define __PRAGMA_REDEFINE_EXTNAME 1 +#define __SIZE_WIDTH__ 64 +#define __SEG_FS 1 +#define __INT_LEAST16_MAX__ 0x7fff +#define __FLT16_NORM_MAX__ 6.55040000000000000000000000000000000e+4F16 +#define __DEC64_MANT_DIG__ 16 +#define QT_NETWORK_LIB 1 +#define __FLT32_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F32 +#define __SIG_ATOMIC_WIDTH__ 32 +#define __INT_LEAST64_TYPE__ long int +#define __INT16_TYPE__ short int +#define __INT_LEAST8_TYPE__ signed char +#define __FLT16_MAX__ 6.55040000000000000000000000000000000e+4F16 +#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932F128 +#define __cpp_structured_bindings 201606L +#define __SIZEOF_INT__ 4 +#define __DEC32_MAX_EXP__ 97 +#define __INT_FAST8_MAX__ 0x7f +#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932F128 +#define __INTPTR_MAX__ 0x7fffffffffffffffL +#define __cpp_sized_deallocation 201309L +#define __cpp_guaranteed_copy_elision 201606L +#define linux 1 +#define __FLT64_HAS_QUIET_NAN__ 1 +#define __FLT32_MIN_10_EXP__ (-37) +#define __EXCEPTIONS 1 +#define __UINT16_C(c) c +#define __PTRDIFF_WIDTH__ 64 +#define __LDBL_MANT_DIG__ 64 +#define __cpp_range_based_for 201603L +#define __INT_FAST16_WIDTH__ 64 +#define __FLT64_HAS_INFINITY__ 1 +#define __FLT64X_MAX__ 1.18973149535723176502126385303097021e+4932F64x +#define __FLT16_HAS_INFINITY__ 1 +#define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16 +#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1) +#define __code_model_small__ 1 +#define __GCC_ATOMIC_LONG_LOCK_FREE 2 +#define __cpp_nontype_template_args 201911L +#define __DEC32_MANT_DIG__ 7 +#define __k8__ 1 +#define __INTPTR_TYPE__ long int +#define __UINT16_TYPE__ short unsigned int +#define __WCHAR_TYPE__ int +#define __pic__ 2 +#define __UINTPTR_MAX__ 0xffffffffffffffffUL +#define __INT_FAST64_WIDTH__ 64 +#define __cpp_nontype_template_parameter_class 201806L +#define __cpp_concepts 202002L +#define __cpp_decltype 200707L +#define __INT_FAST64_MAX__ 0x7fffffffffffffffL +#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1 +#define __FLT_NORM_MAX__ 3.40282346638528859811704183484516925e+38F +#define __FLT32_HAS_INFINITY__ 1 +#define __FLT64X_MAX_EXP__ 16384 +#define __UINT_FAST64_TYPE__ long unsigned int +#define __cpp_constexpr_in_decltype 201711L +#define __cpp_inline_variables 201606L +#define __BFLT16_MIN_EXP__ (-125) +#define __INT_MAX__ 0x7fffffff +#define __linux__ 1 +#define __INT64_TYPE__ long int +#define __FLT_MAX_EXP__ 128 +#define __ORDER_BIG_ENDIAN__ 4321 +#define __DBL_MANT_DIG__ 53 +#define __cpp_inheriting_constructors 201511L +#define QT_CORE_LIB 1 +#define __SIZEOF_FLOAT128__ 16 +#define __BFLT16_MANT_DIG__ 8 +#define __DEC64_MIN__ 1E-383DD +#define __WINT_TYPE__ unsigned int +#define __UINT_LEAST32_TYPE__ unsigned int +#define __SIZEOF_SHORT__ 2 +#define __FLT32_NORM_MAX__ 3.40282346638528859811704183484516925e+38F32 +#define __SSE__ 1 +#define __LDBL_MIN_EXP__ (-16381) +#define __FLT64_MAX__ 1.79769313486231570814527423731704357e+308F64 +#define __amd64__ 1 +#define __WINT_WIDTH__ 32 +#define __INT_LEAST64_WIDTH__ 64 +#define __FLT32X_MAX_10_EXP__ 308 +#define __cpp_namespace_attributes 201411L +#define __SIZEOF_INT128__ 16 +#define __FLT16_MIN__ 6.10351562500000000000000000000000000e-5F16 +#define __FLT64X_IS_IEC_60559__ 1 +#define __LDBL_MAX_10_EXP__ 4932 +#define __ATOMIC_RELAXED 0 +#define __DBL_EPSILON__ double(2.22044604925031308084726333618164062e-16L) +#define __INT_LEAST32_TYPE__ int +#define _LP64 1 +#define __UINT8_C(c) c +#define __FLT64_MAX_EXP__ 1024 +#define __SIZEOF_WCHAR_T__ 4 +#define __GNUC_PATCHLEVEL__ 0 +#define __FLT128_NORM_MAX__ 1.18973149535723176508575932662800702e+4932F128 +#define __FLT64_NORM_MAX__ 1.79769313486231570814527423731704357e+308F64 +#define __FLT128_HAS_QUIET_NAN__ 1 +#define __INTMAX_MAX__ 0x7fffffffffffffffL +#define __INT_FAST8_TYPE__ signed char +#define __FLT64X_MIN__ 3.36210314311209350626267781732175260e-4932F64x +#define __STDCPP_THREADS__ 1 +#define __BFLT16_HAS_DENORM__ 1 +#define __GNUC_STDC_INLINE__ 1 +#define __FLT64_HAS_DENORM__ 1 +#define __FLT32_EPSILON__ 1.19209289550781250000000000000000000e-7F32 +#define __FLT16_HAS_DENORM__ 1 +#define __DBL_DECIMAL_DIG__ 17 +#define __STDC_UTF_32__ 1 +#define __INT_FAST8_WIDTH__ 8 +#define __FXSR__ 1 +#define __FLT32X_MAX__ 1.79769313486231570814527423731704357e+308F32x +#define __DBL_NORM_MAX__ double(1.79769313486231570814527423731704357e+308L) +#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__ +#define __GCC_DESTRUCTIVE_SIZE 64 +#define __INTMAX_WIDTH__ 64 +#define __cpp_runtime_arrays 198712L +#define __FLT32_DIG__ 6 +#define __UINT64_TYPE__ long unsigned int +#define __UINT32_C(c) c ## U +#define __cpp_alias_templates 200704L +#define __cpp_constexpr_dynamic_alloc 201907L +#define __FLT_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F +#define __FLT128_IS_IEC_60559__ 1 +#define __INT8_MAX__ 0x7f +#define __LONG_WIDTH__ 64 +#define __DBL_MIN__ double(2.22507385850720138309023271733240406e-308L) +#define __PIC__ 2 +#define __INT32_MAX__ 0x7fffffff +#define __UINT_FAST32_TYPE__ long unsigned int +#define __FLT16_MANT_DIG__ 11 +#define __FLT32X_NORM_MAX__ 1.79769313486231570814527423731704357e+308F32x +#define __CHAR32_TYPE__ unsigned int +#define __FLT_MAX__ 3.40282346638528859811704183484516925e+38F +#define __SSE2__ 1 +#define __cpp_deduction_guides 201907L +#define __BFLT16_NORM_MAX__ 3.38953138925153547590470800371487867e+38BF16 +#define __INT32_TYPE__ int +#define __SIZEOF_DOUBLE__ 8 +#define __cpp_exceptions 199711L +#define __FLT_MIN_10_EXP__ (-37) +#define __FLT64_MIN__ 2.22507385850720138309023271733240406e-308F64 +#define __INT_LEAST32_WIDTH__ 32 +#define __INTMAX_TYPE__ long int +#define __GLIBCXX_BITSIZE_INT_N_0 128 +#define __FLT32X_HAS_QUIET_NAN__ 1 +#define __ATOMIC_CONSUME 1 +#define __GNUC_MINOR__ 2 +#define __GLIBCXX_TYPE_INT_N_0 __int128 +#define __UINTMAX_MAX__ 0xffffffffffffffffUL +#define __PIE__ 2 +#define __FLT32X_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F32x +#define __cpp_template_template_args 201611L +#define __DBL_MAX_10_EXP__ 308 +#define __LDBL_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951L +#define __INT16_C(c) c +#define __STDC__ 1 +#define __PTRDIFF_TYPE__ long int +#define __LONG_MAX__ 0x7fffffffffffffffL +#define __FLT32X_MIN_10_EXP__ (-307) +#define __UINTPTR_TYPE__ long unsigned int +#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD +#define __DEC128_MANT_DIG__ 34 +#define __LDBL_MIN_10_EXP__ (-4931) +#define __cpp_generic_lambdas 201707L +#define __SSE_MATH__ 1 +#define __SIZEOF_LONG_LONG__ 8 +#define __cpp_user_defined_literals 200809L +#define __FLT128_DECIMAL_DIG__ 36 +#define __GCC_ATOMIC_LLONG_LOCK_FREE 2 +#define __FLT32_HAS_QUIET_NAN__ 1 +#define __FLT_DECIMAL_DIG__ 9 +#define __UINT_FAST16_MAX__ 0xffffffffffffffffUL +#define __LDBL_NORM_MAX__ 1.18973149535723176502126385303097021e+4932L +#define __GCC_ATOMIC_SHORT_LOCK_FREE 2 +#define __SIZE_MAX__ 0xffffffffffffffffUL +#define __UINT_FAST8_TYPE__ unsigned char +#define _GNU_SOURCE 1 +#define __cpp_init_captures 201803L +#define __ATOMIC_ACQ_REL 4 +#define __ATOMIC_RELEASE 3 diff --git a/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp b/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp new file mode 100644 index 0000000..b0555ee --- /dev/null +++ b/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp @@ -0,0 +1,3 @@ +// This file is autogenerated. Changes will be overwritten. +#include "6YEA5652QU/moc_GameModel.cpp" +#include "6YEA5652QU/moc_GameScane.cpp" diff --git a/cmake-build-debug/TanksGame_autogen/timestamp b/cmake-build-debug/TanksGame_autogen/timestamp new file mode 100644 index 0000000..e69de29 diff --git a/cmake-build-debug/cmake_install.cmake b/cmake-build-debug/cmake_install.cmake new file mode 100644 index 0000000..e5e4939 --- /dev/null +++ b/cmake-build-debug/cmake_install.cmake @@ -0,0 +1,66 @@ +# Install script for directory: /home/frankyshelloy/CLionProjects/TankiGame + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "/usr/local") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Install shared libraries without execute permission? +if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE) + set(CMAKE_INSTALL_SO_NO_EXE "1") +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "FALSE") +endif() + +# Set path to fallback-tool for dependency-resolution. +if(NOT DEFINED CMAKE_OBJDUMP) + set(CMAKE_OBJDUMP "/usr/bin/objdump") +endif() + +string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT + "${CMAKE_INSTALL_MANIFEST_FILES}") +if(CMAKE_INSTALL_LOCAL_ONLY) + file(WRITE "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/install_local_manifest.txt" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() +if(CMAKE_INSTALL_COMPONENT) + if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") + else() + string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}") + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt") + unset(CMAKE_INST_COMP_HASH) + endif() +else() + set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") +endif() + +if(NOT CMAKE_INSTALL_LOCAL_ONLY) + file(WRITE "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") +endif() diff --git a/include/EnemyTank.h b/include/EnemyTank.h index ee7dea4..c2edfd0 100644 --- a/include/EnemyTank.h +++ b/include/EnemyTank.h @@ -1,6 +1,10 @@ #pragma once #include #include +#include +#include + +class QPainter; #include "Tank.h" class Bullet; @@ -15,62 +19,35 @@ class EnemyTank : public QGraphicsPixmapItem { Direction GetDirection() const { return m_direction; } void SetDirection(Direction dir); - void ResetMoveTimer(int frames) { m_moveCooldown = frames; } - void ResetFireTimer(int frames) { m_fireCooldown = frames; } - int GetMoveCooldown() const { return m_moveCooldown; } - int GetFireCooldown() const { return m_fireCooldown; } - - - static constexpr qreal kSpeed = 30.0; - static constexpr qreal kWidth = 32.0; - static constexpr qreal kHeight = 32.0; + void ResetMoveTimer(int frames) { moveCooldown = frames; } + void ResetFireTimer(int frames) { fireCooldown = frames; } + int GetMoveCooldown() const { return moveCooldown; } + int GetFireCooldown() const { return fireCooldown; } - - virtual qreal GetSpeed() const { return kSpeed; } - virtual qreal GetWidth() const { return kWidth; } - virtual qreal GetHeight() const { return kHeight; } + virtual qreal GetSpeed() const { return Speed; } + virtual qreal GetWidth() const { return Width; } + virtual qreal GetHeight() const { return Height; } - int GetHP() const { return m_hp; } + int GetHP() const { return hp; } void TakeDamage(int dmg); - bool IsDead() const { return m_hp <= 0; } + bool IsDead() const { return hp <= 0; } - virtual QList Fire(Direction dir); + virtual std::vector> Fire(Direction dir); + +private: + static constexpr qreal Speed = 30.0; + static constexpr qreal Width = 32.0; + static constexpr qreal Height = 32.0; protected: virtual void UpdatePixmap(); + void DrawGun(QPainter& painter, int center, int gunLength) const; Direction m_direction = Direction::Down; - int m_moveCooldown = 0; - int m_fireCooldown = 0; - int m_hp = 1; -}; - -// Легкий -class LightEnemy : public EnemyTank { -public: - explicit LightEnemy(qreal x, qreal y); - qreal GetSpeed() const override { return 1.5; } -protected: - void UpdatePixmap() override; -}; - -// Тяжелый -class HeavyEnemy : public EnemyTank { -public: - explicit HeavyEnemy(qreal x, qreal y); - qreal GetSpeed() const override { return 1; } -protected: - void UpdatePixmap() override; + int moveCooldown = 0; + int fireCooldown = 0; + int hp = 1; }; -// Двупульный тяжелый -class TwinShooterEnemy : public EnemyTank { -public: - explicit TwinShooterEnemy(qreal x, qreal y); - qreal GetSpeed() const override { return 0.8; } -protected: - void UpdatePixmap() override; - QList Fire(Direction dir) override; -}; diff --git a/include/GameScane.h b/include/GameScane.h index 3158279..44687f0 100644 --- a/include/GameScane.h +++ b/include/GameScane.h @@ -6,8 +6,11 @@ #include #include #include "GameModel.h" +#include "Bullet.h" #include #include +#include +#include class Tank; class Wall; @@ -45,7 +48,7 @@ class GameScane final : public QGraphicsScene { void UpdateBonuses(); bool IsCollidingWithSolidWall(const QRectF& rect) const; - BrickWall* IsCollidingWithBrickWall(const QRectF& rect) const; + BrickWall* FindCollidingBrickWall(const QRectF& rect) const; bool IsCollidingWithAnyWall(const QRectF& rect) const; void UpdateLivesDisplay(); @@ -65,8 +68,8 @@ class GameScane final : public QGraphicsScene { Tank* m_playerTank = nullptr; QList m_walls; QList m_brickWalls; - QList m_bullets; - QList m_enemyBullets; + std::vector> m_bullets; + std::vector> m_enemyBullets; QList m_enemyTanks; QList m_bonuses; QList m_freeSpawnPoints; diff --git a/include/GlobalConstants.h b/include/GlobalConstants.h index d6ec9b8..30b089a 100644 --- a/include/GlobalConstants.h +++ b/include/GlobalConstants.h @@ -70,3 +70,11 @@ constexpr int kCollisionInset = 4; // Задержка между выстрелами constexpr int kPlayerFireCooldownFrames = 18; + +// Цвета +#include +inline const QColor kSceneBackgroundColor = QColor(20, 40, 20); +inline const QColor kTankBodyColor = QColor(50, 205, 50); +inline const QColor kTankTrackColor = QColor(0, 100, 0); +inline const QColor kTankTurretColor = QColor(34, 139, 34); + diff --git a/include/HeavyEnemy.h b/include/HeavyEnemy.h new file mode 100644 index 0000000..d9975e3 --- /dev/null +++ b/include/HeavyEnemy.h @@ -0,0 +1,10 @@ +#pragma once +#include "EnemyTank.h" + +class HeavyEnemy : public EnemyTank { +public: + explicit HeavyEnemy(qreal x, qreal y); + qreal GetSpeed() const override { return 1; } +protected: + void UpdatePixmap() override; +}; diff --git a/include/LightEnemy.h b/include/LightEnemy.h new file mode 100644 index 0000000..14dd78a --- /dev/null +++ b/include/LightEnemy.h @@ -0,0 +1,10 @@ +#pragma once +#include "EnemyTank.h" + +class LightEnemy : public EnemyTank { +public: + explicit LightEnemy(qreal x, qreal y); + qreal GetSpeed() const override { return 1.5; } +protected: + void UpdatePixmap() override; +}; diff --git a/include/Tank.h b/include/Tank.h index a5c5b56..b40a625 100644 --- a/include/Tank.h +++ b/include/Tank.h @@ -25,6 +25,7 @@ class Tank final : public QGraphicsPixmapItem private: void UpdatePixmap(); + void DrawGun(QPainter& painter, int center, int gunLength) const; Direction m_direction { Direction::Up }; static constexpr qreal kSpeed = 2.0; diff --git a/include/TwinShooterEnemy.h b/include/TwinShooterEnemy.h new file mode 100644 index 0000000..68443c1 --- /dev/null +++ b/include/TwinShooterEnemy.h @@ -0,0 +1,11 @@ +#pragma once +#include "EnemyTank.h" + +class TwinShooterEnemy : public EnemyTank { +public: + explicit TwinShooterEnemy(qreal x, qreal y); + qreal GetSpeed() const override { return 0.8; } +protected: + void UpdatePixmap() override; + std::vector> Fire(Direction dir) override; +}; diff --git a/src/EnemyTank.cpp b/src/EnemyTank.cpp index 371de89..5ce6743 100644 --- a/src/EnemyTank.cpp +++ b/src/EnemyTank.cpp @@ -14,14 +14,14 @@ EnemyTank::EnemyTank(qreal x, qreal y) { m_direction = Direction::Down; UpdatePixmap(); - m_moveCooldown = QRandomGenerator::global()->bounded(18, 48); - m_fireCooldown = QRandomGenerator::global()->bounded(10, 50); - m_hp = 1; + moveCooldown = QRandomGenerator::global()->bounded(18, 48); + fireCooldown = QRandomGenerator::global()->bounded(10, 50); + hp = 1; } void EnemyTank::Update() { - if (m_moveCooldown > 0) --m_moveCooldown; - if (m_fireCooldown > 0) --m_fireCooldown; + if (moveCooldown > 0) --moveCooldown; + if (fireCooldown > 0) --fireCooldown; } QRectF EnemyTank::GetFutureRect(Direction direction) const { @@ -68,23 +68,27 @@ void EnemyTank::UpdatePixmap() { painter.setPen(QPen(Qt::black, 2)); const int center = kEnemyTankGunCenter; + DrawGun(painter, center, kEnemyTankGunLength); + + painter.end(); + setPixmap(pixmap); +} + +void EnemyTank::DrawGun(QPainter& painter, int center, int gunLength) const { switch (m_direction) { case Direction::Up: - painter.drawLine(center, center, center, center - kEnemyTankGunLength); + painter.drawLine(center, center, center, center - gunLength); break; case Direction::Down: - painter.drawLine(center, center, center, center + kEnemyTankGunLength); + painter.drawLine(center, center, center, center + gunLength); break; case Direction::Left: - painter.drawLine(center, center, center - kEnemyTankGunLength, center); + painter.drawLine(center, center, center - gunLength, center); break; case Direction::Right: - painter.drawLine(center, center, center + kEnemyTankGunLength, center); + painter.drawLine(center, center, center + gunLength, center); break; } - - painter.end(); - setPixmap(pixmap); } void EnemyTank::SetDirection(Direction direction) { @@ -96,11 +100,11 @@ void EnemyTank::SetDirection(Direction direction) { } void EnemyTank::TakeDamage(int dmg) { - m_hp -= dmg; + hp -= dmg; } -QList EnemyTank::Fire(Direction dir) { - QList list; +std::vector> EnemyTank::Fire(Direction dir) { + std::vector> list; QPointF pos = this->pos(); qreal bulletX = pos.x() + GetWidth() / 2 - 3; qreal bulletY = pos.y() + GetHeight() / 2 - 3; @@ -120,155 +124,7 @@ QList EnemyTank::Fire(Direction dir) { break; } - auto* bullet = new Bullet(bulletX, bulletY, dir, BulletOwner::Enemy); - list.append(bullet); + list.push_back(std::make_unique(bulletX, bulletY, dir, BulletOwner::Enemy)); return list; } -LightEnemy::LightEnemy(qreal x, qreal y) : EnemyTank(x, y) { - m_hp = 1; - UpdatePixmap(); -} - -void LightEnemy::UpdatePixmap() { - QPixmap pixmap(GetWidth(), GetHeight()); - pixmap.fill(Qt::transparent); - QPainter painter(&pixmap); - painter.setRenderHint(QPainter::Antialiasing, false); - - painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, - QColor(30, 144, 255)); - - painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, QColor(10, 50, 120)); - painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, QColor(10, 50, 120)); - - painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, - QColor(0, 100, 200)); - - painter.setPen(QPen(Qt::black, 2)); - const int center = kEnemyTankGunCenter; - switch (m_direction) { - case Direction::Up: - painter.drawLine(center, center, center, center - kEnemyTankGunLength); - break; - case Direction::Down: - painter.drawLine(center, center, center, center + kEnemyTankGunLength); - break; - case Direction::Left: - painter.drawLine(center, center, center - kEnemyTankGunLength, center); - break; - case Direction::Right: - painter.drawLine(center, center, center + kEnemyTankGunLength, center); - break; - } - - painter.end(); - setPixmap(pixmap); -} - -HeavyEnemy::HeavyEnemy(qreal x, qreal y) : EnemyTank(x, y) { - m_hp = 2; - UpdatePixmap(); -} - -void HeavyEnemy::UpdatePixmap() { - QPixmap pixmap(GetWidth(), GetHeight()); - pixmap.fill(Qt::transparent); - QPainter painter(&pixmap); - painter.setRenderHint(QPainter::Antialiasing, false); - - painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, - QColor(139, 0, 0)); - - painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, - QColor(101, 67, 33)); - painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, - QColor(101, 67, 33)); - - painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, - QColor(128, 0, 0)); - - painter.setPen(QPen(Qt::black, 2)); - const int center = kEnemyTankGunCenter; - switch (m_direction) { - case Direction::Up: - painter.drawLine(center, center, center, center - kEnemyTankGunLength); - break; - case Direction::Down: - painter.drawLine(center, center, center, center + kEnemyTankGunLength); - break; - case Direction::Left: - painter.drawLine(center, center, center - kEnemyTankGunLength, center); - break; - case Direction::Right: - painter.drawLine(center, center, center + kEnemyTankGunLength, center); - break; - } - - painter.end(); - setPixmap(pixmap); -} - -TwinShooterEnemy::TwinShooterEnemy(qreal x, qreal y) : EnemyTank(x, y) { - m_hp = 3; - UpdatePixmap(); -} - -void TwinShooterEnemy::UpdatePixmap() { - QPixmap pixmap(GetWidth(), GetHeight()); - pixmap.fill(Qt::transparent); - QPainter painter(&pixmap); - painter.setRenderHint(QPainter::Antialiasing, false); - - painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, - QColor(255, 165, 0)); - - painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, - QColor(140, 90, 40)); - painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, - QColor(140, 90, 40)); - - painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, - QColor(200, 100, 0)); - - painter.setPen(QPen(Qt::black, 2)); - const int center = kEnemyTankGunCenter; - switch (m_direction) { - case Direction::Up: - painter.drawLine(center, center, center, center - kEnemyTankGunLength); - break; - case Direction::Down: - painter.drawLine(center, center, center, center + kEnemyTankGunLength); - break; - case Direction::Left: - painter.drawLine(center, center, center - kEnemyTankGunLength, center); - break; - case Direction::Right: - painter.drawLine(center, center, center + kEnemyTankGunLength, center); - break; - } - - painter.end(); - setPixmap(pixmap); -} - -QList TwinShooterEnemy::Fire(Direction dir) { - QList bullets; - QPointF pos = this->pos(); - - if (dir == Direction::Up || dir == Direction::Down) { - qreal bx1 = pos.x() + GetWidth() / 2 - 8; - qreal bx2 = pos.x() + GetWidth() / 2 + 8; - qreal by = (dir == Direction::Up) ? pos.y() - 3 : pos.y() + GetHeight() - 3; - bullets.append(new Bullet(bx1, by, dir, BulletOwner::Enemy)); - bullets.append(new Bullet(bx2, by, dir, BulletOwner::Enemy)); - } else { - qreal by1 = pos.y() + GetHeight() / 2 - 8; - qreal by2 = pos.y() + GetHeight() / 2 + 8; - qreal bx = (dir == Direction::Left) ? pos.x() - 3 : pos.x() + GetWidth() - 3; - bullets.append(new Bullet(bx, by1, dir, BulletOwner::Enemy)); - bullets.append(new Bullet(bx, by2, dir, BulletOwner::Enemy)); - } - - return bullets; -} diff --git a/src/GameModel.cpp b/src/GameModel.cpp index 6b24c5d..13de451 100644 --- a/src/GameModel.cpp +++ b/src/GameModel.cpp @@ -3,10 +3,18 @@ GameModel::GameModel(QObject* parent) : QObject(parent) {} void GameModel::ModifyPlayerLives(int delta) { - if (m_gameOver) return; + if (m_gameOver) { + return; + } + m_lives += delta; - if (m_lives < 0) m_lives = 0; + + if (m_lives < 0) { + m_lives = 0; + } + emit livesChanged(m_lives); + if (m_lives == 0) { m_gameOver = true; emit gameOver(); @@ -14,30 +22,45 @@ void GameModel::ModifyPlayerLives(int delta) { } void GameModel::ModifyScore(int delta) { - if (m_gameOver) return; - m_kills += delta; - if (m_kills < 0) m_kills = 0; - emit scoreChanged(m_kills); + if (m_gameOver) { + return; + } + + SetKills(m_kills + delta); } void GameModel::SetGameOver(bool v) { m_gameOver = v; - if (v) emit gameOver(); + + if (v) { + emit gameOver(); + } } void GameModel::SetGameWon(bool v) { m_gameWon = v; - if (v) emit gameWon(); + + if (v) { + emit gameWon(); + } } void GameModel::SetLives(int lives) { m_lives = lives; - if (m_lives < 0) m_lives = 0; + + if (m_lives < 0) { + m_lives = 0; + } + emit livesChanged(m_lives); } void GameModel::SetKills(int kills) { m_kills = kills; - if (m_kills < 0) m_kills = 0; + + if (m_kills < 0) { + m_kills = 0; + } + emit scoreChanged(m_kills); } diff --git a/src/GameScane.cpp b/src/GameScane.cpp index b13f01c..713c703 100644 --- a/src/GameScane.cpp +++ b/src/GameScane.cpp @@ -5,10 +5,15 @@ #include #include #include +#include +#include #include "BrickWall.h" #include "Bullet.h" #include "EnemyTank.h" +#include "LightEnemy.h" +#include "HeavyEnemy.h" +#include "TwinShooterEnemy.h" #include "Tank.h" #include "Wall.h" #include "Bonus.h" @@ -263,9 +268,9 @@ void GameScane::UpdateEnemies() { Direction fireDir = static_cast(dirIdx); auto bullets = enemy->Fire(fireDir); - for (auto* b : bullets) { - m_enemyBullets.append(b); - addItem(b); + for (auto& b : bullets) { + addItem(b.get()); + m_enemyBullets.push_back(std::move(b)); } enemy->ResetFireTimer(QRandomGenerator::global()->bounded(120, 300)); } @@ -273,27 +278,26 @@ void GameScane::UpdateEnemies() { } void GameScane::UpdatePlayerBullets() { - for (int i = m_bullets.size() - 1; i >= 0; --i) { - auto* bullet = m_bullets[i]; + for (int i = (int)m_bullets.size() - 1; i >= 0; --i) { + auto& bulletPtr = m_bullets[i]; + Bullet* bullet = bulletPtr.get(); bullet->Move(); QRectF bulletRect = bullet->GetBoundingRect(); if (!sceneRect().intersects(bulletRect)) { removeItem(bullet); - delete bullet; - m_bullets.removeAt(i); + m_bullets.erase(m_bullets.begin() + i); continue; } bool hitEnemy = false; - for (int j = m_enemyTanks.size() - 1; j >= 0; --j) { + for (int j = (int)m_enemyTanks.size() - 1; j >= 0; --j) { auto* enemy = m_enemyTanks[j]; QRectF enemyRect = enemy->boundingRect().translated(enemy->pos()); if (bulletRect.intersects(enemyRect)) { enemy->TakeDamage(1); removeItem(bullet); - delete bullet; - m_bullets.removeAt(i); + m_bullets.erase(m_bullets.begin() + i); if (enemy->IsDead()) { removeItem(enemy); @@ -316,59 +320,54 @@ void GameScane::UpdatePlayerBullets() { if (IsCollidingWithSolidWall(bulletRect)) { removeItem(bullet); - delete bullet; - m_bullets.removeAt(i); + m_bullets.erase(m_bullets.begin() + i); continue; } - if (auto* brick = IsCollidingWithBrickWall(bulletRect)) { + if (auto* brick = FindCollidingBrickWall(bulletRect)) { removeItem(brick); delete brick; m_brickWalls.removeAll(brick); removeItem(bullet); - delete bullet; - m_bullets.removeAt(i); + m_bullets.erase(m_bullets.begin() + i); continue; } } } void GameScane::UpdateEnemyBullets() { - for (int i = m_enemyBullets.size() - 1; i >= 0; --i) { - auto* bullet = m_enemyBullets[i]; + for (int i = (int)m_enemyBullets.size() - 1; i >= 0; --i) { + auto& bulletPtr = m_enemyBullets[i]; + Bullet* bullet = bulletPtr.get(); bullet->Move(); QRectF bulletRect = bullet->GetBoundingRect(); if (!sceneRect().intersects(bulletRect)) { removeItem(bullet); - delete bullet; - m_enemyBullets.removeAt(i); + m_enemyBullets.erase(m_enemyBullets.begin() + i); continue; } if (IsCollidingWithSolidWall(bulletRect)) { removeItem(bullet); - delete bullet; - m_enemyBullets.removeAt(i); + m_enemyBullets.erase(m_enemyBullets.begin() + i); continue; } - if (auto* brick = IsCollidingWithBrickWall(bulletRect)) { + if (auto* brick = FindCollidingBrickWall(bulletRect)) { removeItem(brick); delete brick; m_brickWalls.removeAll(brick); removeItem(bullet); - delete bullet; - m_enemyBullets.removeAt(i); + m_enemyBullets.erase(m_enemyBullets.begin() + i); continue; } - if (!s_model->IsGameOver()) { + if (!s_model->IsGameOver()) { QRectF playerRect = m_playerTank->boundingRect().translated(m_playerTank->pos()); if (bulletRect.intersects(playerRect)) { removeItem(bullet); - delete bullet; - m_enemyBullets.removeAt(i); + m_enemyBullets.erase(m_enemyBullets.begin() + i); s_model->ModifyPlayerLives(-1); continue; } @@ -442,7 +441,7 @@ bool GameScane::IsCollidingWithSolidWall(const QRectF& rect) const { return false; } -BrickWall* GameScane::IsCollidingWithBrickWall(const QRectF& rect) const { +BrickWall* GameScane::FindCollidingBrickWall(const QRectF& rect) const { for (auto* brick : m_brickWalls) { if (brick->boundingRect().translated(brick->pos()).intersects(rect)) { return brick; @@ -452,7 +451,7 @@ BrickWall* GameScane::IsCollidingWithBrickWall(const QRectF& rect) const { } bool GameScane::IsCollidingWithAnyWall(const QRectF& rect) const { - return IsCollidingWithSolidWall(rect) || (IsCollidingWithBrickWall(rect) != nullptr); + return IsCollidingWithSolidWall(rect) || (FindCollidingBrickWall(rect) != nullptr); } void GameScane::FireBullet() { @@ -484,10 +483,10 @@ void GameScane::FireBullet() { break; } - auto* bullet = new Bullet(tankPos.x() + offsetX, tankPos.y() + offsetY, + auto bullet = std::make_unique(tankPos.x() + offsetX, tankPos.y() + offsetY, direction, BulletOwner::Player); - m_bullets.append(bullet); - addItem(bullet); + addItem(bullet.get()); + m_bullets.push_back(std::move(bullet)); } void GameScane::ShowGameOver() { @@ -571,7 +570,7 @@ void GameScane::UpdateScoreDisplay() { } void GameScane::RestartGame() { - auto cleanup = [this](auto& container) { + auto cleanupRaw = [this](auto& container) { for (auto* item : container) { removeItem(item); delete item; @@ -579,18 +578,24 @@ void GameScane::RestartGame() { container.clear(); }; + auto cleanupBullets = [this](auto& container) { + for (auto& uptr : container) { + if (uptr) removeItem(uptr.get()); + } + container.clear(); + }; if (m_playerTank) { removeItem(m_playerTank); delete m_playerTank; m_playerTank = nullptr; } - cleanup(m_walls); - cleanup(m_brickWalls); - cleanup(m_bullets); - cleanup(m_enemyBullets); - cleanup(m_enemyTanks); - cleanup(m_bonuses); + cleanupRaw(m_walls); + cleanupRaw(m_brickWalls); + cleanupBullets(m_bullets); + cleanupBullets(m_enemyBullets); + cleanupRaw(m_enemyTanks); + cleanupRaw(m_bonuses); auto cleanupOptional = [this](auto& ptr) { diff --git a/src/HeavyEnemy.cpp b/src/HeavyEnemy.cpp new file mode 100644 index 0000000..d897bc5 --- /dev/null +++ b/src/HeavyEnemy.cpp @@ -0,0 +1,36 @@ +#include "HeavyEnemy.h" + +#include +#include + +#include "GlobalConstants.h" + +HeavyEnemy::HeavyEnemy(qreal x, qreal y) : EnemyTank(x, y) { + hp = 2; + UpdatePixmap(); +} + +void HeavyEnemy::UpdatePixmap() { + QPixmap pixmap(GetWidth(), GetHeight()); + pixmap.fill(Qt::transparent); + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, + QColor(139, 0, 0)); + + painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(101, 67, 33)); + painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(101, 67, 33)); + + painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, + QColor(128, 0, 0)); + + painter.setPen(QPen(Qt::black, 2)); + const int center = kEnemyTankGunCenter; + DrawGun(painter, center, kEnemyTankGunLength); + + painter.end(); + setPixmap(pixmap); +} diff --git a/src/LightEnemy.cpp b/src/LightEnemy.cpp new file mode 100644 index 0000000..78ba13c --- /dev/null +++ b/src/LightEnemy.cpp @@ -0,0 +1,34 @@ +#include "LightEnemy.h" + +#include +#include + +#include "GlobalConstants.h" + +LightEnemy::LightEnemy(qreal x, qreal y) : EnemyTank(x, y) { + hp = 1; + UpdatePixmap(); +} + +void LightEnemy::UpdatePixmap() { + QPixmap pixmap(GetWidth(), GetHeight()); + pixmap.fill(Qt::transparent); + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, + QColor(30, 144, 255)); + + painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, QColor(10, 50, 120)); + painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, QColor(10, 50, 120)); + + painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, + QColor(0, 100, 200)); + + painter.setPen(QPen(Qt::black, 2)); + const int center = kEnemyTankGunCenter; + DrawGun(painter, center, kEnemyTankGunLength); + + painter.end(); + setPixmap(pixmap); +} diff --git a/src/Tank.cpp b/src/Tank.cpp index bb6b757..18f760e 100644 --- a/src/Tank.cpp +++ b/src/Tank.cpp @@ -5,6 +5,23 @@ #include "GlobalConstants.h" +void Tank::DrawGun(QPainter& painter, int center, int gunLength) const { + switch (m_direction) { + case Direction::Up: + painter.drawLine(center, center, center, center - gunLength); + break; + case Direction::Down: + painter.drawLine(center, center, center, center + gunLength); + break; + case Direction::Left: + painter.drawLine(center, center, center - gunLength, center); + break; + case Direction::Right: + painter.drawLine(center, center, center + gunLength, center); + break; + } +} + Tank::Tank(qreal x, qreal y, QObject* ) : m_direction(Direction::Up) { setPos(x, y); @@ -77,33 +94,20 @@ void Tank::UpdatePixmap() { painter.fillRect(kTankBodyX, kTankBodyY, kTankBodyWidth, kTankBodyHeight, - QColor(50, 205, 50)); + kTankBodyColor); - painter.fillRect(kTankTrackLeftX, 10, kTankTrackWidth, kTankTrackHeight, QColor(0, 100, 0)); - painter.fillRect(kTankTrackRightX, 10, kTankTrackWidth, kTankTrackHeight, QColor(0, 100, 0)); + painter.fillRect(kTankTrackLeftX, 10, kTankTrackWidth, kTankTrackHeight, kTankTrackColor); + painter.fillRect(kTankTrackRightX, 10, kTankTrackWidth, kTankTrackHeight, kTankTrackColor); painter.fillRect(kTankTurretX, kTankTurretY, kTankTurretSize, kTankTurretSize, - QColor(34, 139, 34)); + kTankTurretColor); painter.setPen(QPen(Qt::black, 2)); const int center = kTankGunCenter; - switch (m_direction) { - case Direction::Up: - painter.drawLine(center, center, center, center - kTankGunLength); - break; - case Direction::Down: - painter.drawLine(center, center, center, center + kTankGunLength); - break; - case Direction::Left: - painter.drawLine(center, center, center - kTankGunLength, center); - break; - case Direction::Right: - painter.drawLine(center, center, center + kTankGunLength, center); - break; - } + DrawGun(painter, center, kTankGunLength); painter.end(); setPixmap(pixmap); diff --git a/src/TwinShooterEnemy.cpp b/src/TwinShooterEnemy.cpp new file mode 100644 index 0000000..5d9c868 --- /dev/null +++ b/src/TwinShooterEnemy.cpp @@ -0,0 +1,58 @@ +#include "TwinShooterEnemy.h" + +#include +#include + +#include "GlobalConstants.h" +#include "Bullet.h" + +TwinShooterEnemy::TwinShooterEnemy(qreal x, qreal y) : EnemyTank(x, y) { + hp = 3; + UpdatePixmap(); +} + +void TwinShooterEnemy::UpdatePixmap() { + QPixmap pixmap(GetWidth(), GetHeight()); + pixmap.fill(Qt::transparent); + QPainter painter(&pixmap); + painter.setRenderHint(QPainter::Antialiasing, false); + + painter.fillRect(kEnemyTankBodyX, kEnemyTankBodyY, kEnemyTankBodyWidth, kEnemyTankBodyHeight, + QColor(255, 165, 0)); + + painter.fillRect(kTankTrackLeftX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(140, 90, 40)); + painter.fillRect(kTankTrackRightX, 10, kEnemyTankTrackWidth, kEnemyTankTrackHeight, + QColor(140, 90, 40)); + + painter.fillRect(kEnemyTankTurretX, kEnemyTankTurretY, kEnemyTankTurretSize, kEnemyTankTurretSize, + QColor(200, 100, 0)); + + painter.setPen(QPen(Qt::black, 2)); + const int center = kEnemyTankGunCenter; + DrawGun(painter, center, kEnemyTankGunLength); + + painter.end(); + setPixmap(pixmap); +} + +std::vector> TwinShooterEnemy::Fire(Direction dir) { + std::vector> bullets; + QPointF pos = this->pos(); + + if (dir == Direction::Up || dir == Direction::Down) { + qreal bx1 = pos.x() + GetWidth() / 2 - 8; + qreal bx2 = pos.x() + GetWidth() / 2 + 8; + qreal by = (dir == Direction::Up) ? pos.y() - 3 : pos.y() + GetHeight() - 3; + bullets.push_back(std::make_unique(bx1, by, dir, BulletOwner::Enemy)); + bullets.push_back(std::make_unique(bx2, by, dir, BulletOwner::Enemy)); + } else { + qreal by1 = pos.y() + GetHeight() / 2 - 8; + qreal by2 = pos.y() + GetHeight() / 2 + 8; + qreal bx = (dir == Direction::Left) ? pos.x() - 3 : pos.x() + GetWidth() - 3; + bullets.push_back(std::make_unique(bx, by1, dir, BulletOwner::Enemy)); + bullets.push_back(std::make_unique(bx, by2, dir, BulletOwner::Enemy)); + } + + return bullets; +} From e2febdaabe27142802dd97f08aa23c6e93c4c2b8 Mon Sep 17 00:00:00 2001 From: frankyshelloy Date: Tue, 9 Dec 2025 03:28:56 +0700 Subject: [PATCH 03/13] A few more changes --- .../TanksGame.dir/compiler_depend.internal | 1368 +++++++++++++++++ .../TanksGame.dir/compiler_depend.make | 1368 +++++++++++++++++ .../TanksGame.dir/src/EnemyTank.cpp.o | Bin 100000 -> 243704 bytes .../CMakeFiles/TanksGame.dir/src/Tank.cpp.o | Bin 41888 -> 185688 bytes .../CMakeFiles/TanksGame.dir/src/Wall.cpp.o | Bin 39464 -> 41096 bytes .../compiler_depend.internal | 1368 +++++++++++++++++ .../compiler_depend.make | 1368 +++++++++++++++++ cmake-build-debug/TanksGame | Bin 341248 -> 444240 bytes include/Wall.h | 5 + src/EnemyTank.cpp | 27 +- src/Tank.cpp | 27 +- src/Wall.cpp | 23 +- 12 files changed, 5519 insertions(+), 35 deletions(-) diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal index 700fc45..a53f98e 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal @@ -4102,6 +4102,1374 @@ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake-3.31/Modules/Platform/Linux.cmake /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make index 904450b..8f29692 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make @@ -4100,6 +4100,1374 @@ TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLi /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: TanksGame_autogen/mocs_compilation.cpp \ diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o index 4cb7820f3091439b146cdf8acae05a805497235f..4fcb3e5fe1efd0506a9f3acdb973ed102d8717b8 100644 GIT binary patch literal 243704 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 Z|5Z|QQb2wO4>t6?QsyD%5BlND|9@ouwxa+5 literal 100000 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 UCjH(M&@-QJC8UpUlDg#o0~{?o`v3p{ diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Tank.cpp.o index e88f7eb92a0daafe75ddf911b7eabf957d0b36f6..a31a697a58332ec8b1e2f75b57de2208d1b4f0a2 100644 GIT binary patch literal 185688 zcmeEv3t&{m_4h(RQE7>-531Hiw3b@6*^q?9stu5ZjRXjUD7EUcBnw&dG}-X5q9~xI zF`BAWe3n{msr5nCB2ueSsnWl%sI;YOHCk)2pr$Rh_-el2nK^Us+}S(32?T7*ca_Y& zzd85JnKNh3oS8fK?nR-}iGv3X$_Vf=C~#_Ekh;*)mGcHWS4HBiDDc3bwS$QE$M{F- zPdNQ4r*|Oz8K2+D>0O-Ojr1NqU&HCoIlY(D`#8Oy(_e79meU6~UB~HzoUZ5emz+L? z^jCcTFw#f(yc6l8eEt~H$N78%r@!X(2~M9xx{=R+gY^IS{3)bQ^Z7GKpXKu|PM_!W z1x{Z?x{1$!%jxfs{+`b_BmD!Pzl8Kc#Oa$z|IFua zA^i)VZ$bJtpZ^unJdb9xBUL-~9p(l7A&VVoY$=@Cf3$md5Q{Su#NAw7!EMwMgsuydG%-pEn{skI$QsHuHG`X$zmv=X3$mg?zq< z)ANyjhtDrSx|q)|M0ydQFX8lJq?hpdQl!iHd^yrf`TR1Zm-Bfm((m$l8>d$wZRhhV zIlT&L2cLhB)2oqQ!{^r`UBTzy=kz+HEBX9-PH#YZBcI=d^kzQ41?dm?d==6k^7*Yu zf5hjvA-x^{evE%VVeAg1KjZT|IlT+%-S}4#ZvAt3>9(wJ>*5{Z)|Q^uifye^wzP$| zeJ!-5^~ts=+uAC&wY6*uw}pDfwSwYFa)^PB-#p%7xfA4}E$t@{PI0T{PFd!oZHsrZ z%;AGm+)8DZqoSix(JiQGceu4;GirrYR;eu$S6f=e-*Ee^VYu2%c_$ta2!vao2)Dkr zB?qS+;kL7PaP4=BU&7_La3J`tclkX$5c~qeo%#;JsjBZkMjZJe>2TZ`<4zw}F>Ypg z_~LCNVL##4Uv2q!Z*REu7u`r&SG+=h+c)EHRk&@)mq)``!mXi=!OjtDhmz$i>l|@y zC;lv>&J%7Im}-LMog-F=JaPn2EdM>21WMa)&+6^%Ep2`M$>jl@5RY*CiVu(%ZWoAX zoaeS24y2_0tYbz$xqJxdz=7yKlyrn}BTgV>>Ej?929Sa^kbNY{2w}2XflLNjCO``N zK=!dDBZNy`LCBNKHzJWV%Sqaj)+fe2GDO_7yq73imyZP8(GhNM|F__=;u9pLt^X`- zg)rNOp(;dIR?_;LlGZMY&!Dvr4fTYVZpd_?$DFe#!fhTcIvLzm!|gYdOyP?kUnM0H zSA~x!J{w-T72V-A(WAG%6>eKDT5@S;CRNVcG~rgEu4Gi`qJ4!-Bu(q@RD&+<8AMG@ zaT;nUwJW6xw=W#lCd{Nwm<$Rh`$54%nzwJqEo5>ft-tQ8{8N^{nHalHv_e}uHAwiY z8^f)Sgi$k?>((W|686?IBB_pW6BQe)!e2W`SaV{i zkWf_-{Ubz~($rOEdu;Q!$DK9q>~ZIei=6$q>N}3V`1^_K7{uZotu5Pe!;ZG1%)-$2#7J>ovAtEu=nM>72VrP%?xZnA z-g5Ti9SSAiv2y>_qh*h4<(peWAXgjVOHSj*Jn@4o3H; zldC8MTDoKKh-EYfqLZt>31oR^V*jN(1|?>_9mEwp_Qr5~sLR6|Dipnjv;_WVQ5hAT zeq>WRiKbI^l(%U{VX_3b&yec=K4R9RBy67;t?*$qw`9bH8~mhjgxw5bH3H znLSLj-5q#^6f{Pl)PCO5wRG{F8HsB8d(k5N9h@kpzZccvZy+%Ye+MNF+Zv(ng7#HS zbe3qMuC0>*O(9(9RyAGM)~^%&Mw5Qy)SgVrHS4ordk@ne z)kb7<4}abRRCEz(*mdXO_KG!tR(hb&N?Jw;JdBQ}Gh4}CsHFAzaqGx&Jvb77)(<06 zF)}KLMf{}05~K(@0uK_w`u&MijL&@|Jq+|(Z9H75*azv)dgA{u{n1EQtta8VWwo6G z2%}cZD%5!OxOGLidXVZNXsOpd>2j!8ovfDCZgyyuI)5^BE%5+bh!?v2K@w!WK=eAQ zb5IDC>n%XqXOAr!$94Ozbu8R^p7QXJUD0pd*99GcbkO0fgHDeOV}NL@Ah+N<4$47M z#Kt1LXV(vVThg-`=irn^tm&nUZ3`zqm)$M7ex|+(Sy0ss? z&MQ?Gf)oh38>9+>b821XP}x$dSyBw8tIpjf)t}Q!^@1za4zE-ZUhf4ERoX}IThS20JPV|Q&yIU(>X$!rAIAvdoQx4l&0Pb5H z?(HIgL)^DDA9y$6V}u@@knK@%IdbbEZ56MC+op8O+n*)MPGqf<9f;yMW%p^c_Q#J+ ztsRMBZntUei(u~2T0WIF;96Vj)mjLJgj;>JR*bCvYweUIt=&rXa0lgqwY49Dxkqd3 zsk8yt+DYK5O%Hw}E`7DO5n27$+RY!Cws!13yHRUj26KD~YnwboZ3A*Uw>S?P*|Q@DCZZ?9kkpML;|N?ZRTNT_m|B3S3a zH%l;Prp-b!3`{)mF2=R=69a3lW5Cy=_iO;V-aV0l76nLQeEcP*e2FIfx#)aM^%7zH zxv0_gp)rrvTpv0GxKP)7Vuiu+p^HTzF>>n(D*ri=Pa_8!K|~hsp-s1bM)Ca|$v+?s z*YK~MX}G(Eg}Dv44%fS*;p)NH({MEa^oH}sbbFxX-c8eT&nC6pS0S?7a-~#(0cp9( z|J<3D+aksxx8?qh>)p|EtHIaPa<>EcFKf9kKV+>ycP_21|>ON71N60 zsE&79F^nq6(yMt0*XuNymBvqgYIPph$2#9E=B@fv>UtoSI=>{d{!{CG*`NB>&LA3c7WVra!`_d+n>vQ=mqqPdAe~+a zk6TFNz4lHSXvsl7v=h2=SNnS0H4x$P;8d|rEyr5p_)!aOvsX zdo8adKcZ8IyuYVs2d0LE$?Fe4+`9Gmv~A8QUr8wQFS@9=cN1;3xEL{qEPk_Qo4-{_VFPhr_*o_0@IjF1yUV zjzn&`Wz{P8n&hP`#s7sD;_)Mobgz4RFS@9#%)PFvTCw6C+OFrwzhj49pI2Tv=%ABN zcJoPEU4N9*)~4sT;c&0lt-JKn1F-u-@&Bnf-0MJ~s*0{``M>(r0}s^HxcS6e=U-7# zQ}gw&yZODnS6o3?ir@9u=j1&7w0kY@b+6xk`}^NN|9toQs;eG)=&GyS>u~s#Q}pt_ z{`F}%+KWY|9+SMGtZob!@Zt789UT2aj(f5_4|8z-g-+~fb4H? z;rQ@FoxZ2%ecEcu?Qy{cAJaxs=bH4V_s_fT+PwL#x7_@m9&dfSyGa5!|3e%v&^BG> z|DrhD>yD0h-|gsdug(14-nDBVebmkG?OnA>x6iDsd+)vD4mba@%btB!uit_NmtTJU z^=`g-y=KjZ4X@IJddD7nd%L^cYh@iOKPTszXL54fe6lWGA5?d}{>uBR`{&Mm<{4dH z;-u?${rZXuy?1_xd~EsjhyPwiR)mQJj%e|&E-TpuMsr=sFP)NUi>7~ZT-_h1?uJ60=ZrP&ibLGm9K3cib z&A;cKcX7DaFTdQ_sQa7V-uK@7?Qh-u-rkp9dQfbulKthGXO=Jj<~Q~H&d#TvaOx!2pb z-*(&V+3xj;C$_bnafW-{+x!0edi__enla;q6Wn|=zM=lJb*r0y?zv~4soQ5`JbkdUX4t-f+=HF29KrFS$hbXD_^P|NXjuB5mpRvw8C)k8IxT-rw6>SvhHvdtFr2 z-QCsYUcdY9C70;+egFMeU%l@>H=n$d-ajc`(fyywRrn} z4A2e)Oyor#NCJe@CW4Xpm&w=k1fTK_!#_Hwe?&w1be@HOsqXc=2ee& zv;2?vsegnM50Y&V{>dY|NTyjugnthI2I&VV=|4J-J9Fyf+?mn(nz6-A(FK!Q>O(UM zrk6$I^@&(hJRYj3Ee}SJ=0pT_@}EB5AKbR+WX9adi|DIP*cuncvyda{ zrc%0Sn<5r1*OLW@Tj|m8xZW1l7QSxQ*mjjg%K<%ORVf?>+$xr>&@S}U;GFx0c2 z2*Uqr!BdkiFV#P=*-Pvi{0FvFZO2uB#KR5`>LLM}1$uZ=UR%*HFAsjUkDLmWST@YO z3mR=j4(@Hkc0{qA1eC31Lkx*&<5>^>Od*+fVDpu@5(3c$HdP*2M9fWzkcr&}J}3$5 zkzY#EI%QjNEA7He5(x5PWBs76_Of2eMO`2$9yV#naIVF zr+Bt?Vk;m?fX#hkJDJap)%FT{+=+EuXWMWGmFjM1k{fP+qv@JUY;D=pTG7=yqtLdNP1u~(t-ZVuZWsF{HjABHvS-LT`4?-}(^G0GwvFif>rmZPCAZNQ zQ(1cYf~kuLFWuW~#;4|d(w+Zk($Y$tZ~^%{lXZXJd5B_U3*SZ_C^<2xmZ!4I-@= zxnW4)!Y2paGbFHW@K9{A=^Z?D`H;Z6jAMZOZHS~KYWg?)o47uG=-Gk!68~&2(#gl+ zjh!Dc&jW59^tJB~4%|D~z45^720a21+J+3pv$+*R-HiR`9)I`Xz{`U4#-j!u^5~!- zUPj0mx;0}^&yb<-4+-2z#LiHQ^7lJ?=yw9wb5Z+OXW-3-AJdi76wWGXGLl5Z-d4Ft zGD)0MG(qmtVIVh9;~5HEBKl3Ibiu8E$D^ul;g(yc^pv)SHp4!VzkG{a|r0~(q*qg1N7#&7i;Z+iG2X$>- zR=g)f2Ix}LLs7qdyk<*gkxA)FqD}qnp&qlH(5)(Hu=eZ<)@&llUj3f|J2u4h=&V|F zMJ+c{*tl>-PBWpdTijMN-t`F&f=+b%)OrfkBs)fz(=pl>XF`pgs16h)-^$VbqENhN zqb0R<-`=H3_VS3gJ>Fbsn|6L}{Tk{7;e-=Hs;UYMdY1Kd8*}O6?m)}49o|8ic5A8P{G=V}N-MgC);6LvVw2Qj)Yo8pEuGNyI^C3vcYWku zL)bLgH~CVkEGa=%{xN!UF7$idj9ckxB^ZkrGpQx0My46c=6CC({FDFK;?-iNqs1g| z*3%ZCa(^#0;pdSY{=z?)O7`B7jdEbau0f(%x=tIO-6T}=y??P@F?(1kB$*oufoq<$}s~eVl@krxBqdq!7 zJGlv0h<2I-I^EnMM@cE?9m;=f6gExfC*uXGw$@CK6Ccnh>&1jkTC`pesnz3{xtbn7 zsO)HIXLh(S)PvAv#M(~G^6{Fi+aKW?8=;TY5NZ{gZ)LJR04rIjRoz!YM3c3L9zfb7 z-uhaHGZJhi(v8p><#gd19gP~61P*lzqr)KgSpZIzwjK(NcEe#(>&yThgQ1X}hNt?>2=;YekutTw%2_K&+j-a<_aL8UFh0QSLk&sIn*oIkBTeOa6< zYZKv-x91gxx)b|~=^#5V%o4vSZ=zDcNZpL$-@X9rwsH%Z?&JI-iXz=3(7PPTdfX@- zE19fgoG6h@dkfV27g7d|GZlXU3L?i{bjWLu^UIc4rbw`yMe{*%F5aHjNZps2gwK?3 z_RbaWlgjafIb@S3r;<|i6en^b>qfH;avVb95V{i+MZrd#!)I(g2o2XGuC&@{R-CNK zbbW&K?AWSfS6Z8Gm7%YEB?YbNs(NXtdo*O}#@MjAq|&FbE-{B2>~5y&tmr zYZUd;{B<&o_WcdvwJ={39aVHU#}3isMoBm+ZbO!*S9!FTDRisG5;0RsVxadgQ<`KO zf)rb1V>!a<^DK{@@>_gl-pO-8&t1?99I);gXG8MUG_ED}=A<#~5$?Wip;f{F+Czju zjntJxovOjl0MIGFub`%%k8U}IT-Q+A@&*yfUOL0A8<%zuf>seIC-+D>ITWr#_VleF zo6-r=ZeEAcOb6`9OktMn737GzN}K+6nRBWxI0D_lkKTF|jg|)L{SW~MqiR$|8)QR! zFk{QO;)$>2@ZvOPxb;y8!0z6u3+hPDX}JCw1l?}@>{{BM*0247Y%SZza6P%YbtLiD zZYEh^@%+-8epeB+0+X=Cj@0~Q+fbZv7d>vf$yo@-2~AHl3jsF`ArXplt z1FhCh!w37%dQ}fNo1FAZG@UHmkV3%q8vrzxB+;@Z=gLuL}RgI z`A>wF1Q0we!SjtZ$bt)X?kH`Gb(Xf(ZG4+P;3fDwCV;Y*F1|d_(i(1C;VI7H3u9b~ z;_#2_r01-1t93Ok)M1>M0!n6u`H;HFQN(JLw>ltduzDwIKzp{pRH|Mvg&i-KZK4o3 zf#uXLG~&@)!SbP*aH}gs%Lv^$3WC(@WE~xm#|hV^>;_6$f|y2(Voxl;2%HCn+gDHu zbwlO8>IRGkk|LG1Vg>lGC}*?VVG6hAkm<=)V24t^=TBsw6+OjBD*WONWRb=T&Tuh1 z(7Fh99Q#H8%Mvj412G??Ie%ApP^bJJ&kz|BAkS%4!-*&H%LYGZR6}vXTZPv_6?BY1 zblE-PYImLtqd3gT{SxIiOaCh?Lh&d*3#4j?{^`iB)?>j3b`mpCnuStSfrv!3o9Zoy`u*3n zl0BnBsBuOcmeB3U)-FEZ=G08|I~qLj@Ivczv^4Crw%1A_5rw#|LL)eZ>cqwaRlK7W z8dqq&3jyR|q&+#sMlxfVX49J6C&3q@u+^}tRj{g+m_&78we4~}#FZl@{1X=0MBjFL z2g(4vFiWIu;yV|sg#c|+E>|DVLh#m#r{Z038ka+*NJz1+ppb~oJyics!G z;l#yaHciD`W0avUAZ3iGAkEg)*VeF*K(%{&2ma`_N9XDh*RqRrikmd=;;f!I!Q&QQ zb6eio5*O5M;?rr+CwZBTqKB%lsktGiybICq(#N1bqJ(?_p6u5Np=D>*M^vOaYsnV5{8a-4ze5D#}fry^bgSrln z{rcSAYGG#gK|@m=d^(n11;1>X+GK8BC~wv^4Pwe;Na`{d(*|nyEv0Q)NRZ9u;Io8@ zaG`WiH$Ls)Cl@pz8;YLY8$G~rBbrrHCv!A}p`cs14>3AAHVXeeO2SFYHpsHA`}mb6 zd!R55SwFq4s7)^3)=75W`l~QvDaJCD!!n*0t1|0p0WKsxuhhI%ckqg$bRvLPE^1< zq&Oz7d;9F9VT)Yxx;x}C*nfUdA&;TS^8;EP@yu78j^p%VM+}9iFXYPbV>29J7b3ll z!pFdko+(or}X+xW1XTR6Ei_gM&(DuqJ-KL4KYxcmgX5q|_Q`bWnh^e6P$%u5GP_{=_2K!8iiqjyl~5HAX;{L|e0vt+jQ{tGyt z-v4m;m$>)elqR3D2c2J5DkR_cM!Gy)$)AObV+g@~I`Pf0X=F-TR9;zg*8BERBG4I-B#)^yEtgQvMRoFZJY4 z5Cu^FD$W-#AFA>PS3CKgoIl@lf1Q)x&H0Nw`HfD#>Ij9DKaOoYA+m*yXK_b4Nzd2p zr-<`y_s>pq{}Rr(weKp{HbdW$G6(9Px z5FIueYOgY;vDK%M^M$@td&=erP&B)lWjz_GAXPMFS7lr|q;8uFnIkBrNNtd!r#`6Ki)Cdx9XE}L1#i($8BT{4;n3qs;U-&Ui;<~uj1 z$=|{G^v<4R_nPk=iEqi#aU%Uub&W|msr&-Y7au`Tb~pGEN4{B{Z{xo(&HXFW+`lf( z{hQO=za!24Blo3>2Lf^Wqv}6+wo|_X&Zi*2$)D!xXBOxC^@A+j(#hqI#kr@Q>s=l< zF^{i;#wkOJAbit9oPVUAU*X>W3g;iI=WAor$DHri#$<~}&_Iu48U0Z@C~42QV#v~= zgPYuPikZ%4i&dO2Y+l)l7AGv@e7wlw+G4HbPjcMG`3orDl!I+D3t3My-9d%nHYynmeHJV(@U81 z)9Iy=>1=w*f(+L(&38#4)!x*O7f72R8u9Wok~;kJ^q;{pxFR3*3iA;%D?T!G2xKAu zW6nQL_thvT;|Srd<@kR92yvW7e-w|wSfpPQJ@ChtR>pGw|trb#95kk3$s@vb@jQT5jJe+=iRled)VZ1UD} zekyr8m?o9H_cM)6-c6jJPTr51&L-~>V(_-x1KDm7)A+?qls}vECz5Ve|A9>{gh`QY zZ)6!R#<`~-lif8-yCXiUnU8IrvXS#kLF<$=*qujg;rz*-{PCgy;y+9{KKndqH0O&% z)q~?Ux^Ye5bJWi4fPjkMXzoYzZ zoIg#!f3U0s>l} zGo9a9L~?B6{KIuV+MIbi=iBOW(1CQL{GNp?hg*JbihQcaOwK=#n53x31xy#z>9qE| ziSupsc!=|D^>~HzZSC=KihQca5n@oo?;h&%sc}bZk7A|^>U3H?syN?Pk7b;1tH*7e zZ>z_K6!}z-H#t9DJ%)dtD&QackzF0n`L=qLa=xFBB0277Iqt#v5d8D_fgif|buIJp zTeHZ*ZTEA2t;ypYm&azNvH6l6oZqSQ82o@>Ky@9-3xmRCC|{)cy8_O)`HESbKT7BS zEmyvUoc|R)Uz2}j8vg6jkIDe)mf3lN5QaEz?JH1Xj4c_GB7jV94 zQl%fw*UjR5Kby@$nF~4pEGl352qP}MiD_*8;-NHUywZm<jSt!4Y^E+_v$VYLuT$&WNw4G^e?QoD7;O%`Om-B75I5W-t3C_3a@Y*!@-=89X zG^%|B=ig{du;8MMU9F>{M?+oNd_x9j|+jBhF#KV}-gb|o2(5RN<$I7{a-*d5bO=6u`zXK}vY zctGvBfy@87*-uXs&y;SVUP^M@mZqEyoS*Q>DIfCE{conYpZrBB=l=}n9=n=+Wk&mu zD~2xJXYh4OXW3aG!f`77QGJEmmFl#TdEJY14=?Huw-FaPo-fS8367)akK!}S&0m>C z89WzL`P$m;x-5|$_&Oyjf3Cb==J@|5bHXROdi`=U0=N3XfsDZI7F?|4CFNxVev*U{ zkP%p&gzpbzkcJDLF;zz3r%Ck3GQFZxDG_D_?o6VW_+1wKZVOH`)Z`;0uqGJ z18-nF+ra5pREd9)fv;t}%)nn}e71oP!F~tg(`ewwFuugVCo|q*;I)jeGVpfB*BJOc zjCUG%7vo(9{t@Hd27WjUo8<2?@bQcXP;WYv{^?h=h(6Q6FK0Z?b<3$EOo$)dQPcS~)z;9%{(ZDw_ zzQn-aWxT_{N5avP{HqLnJmYH&yq57!1HXpxE(3pn@oocujqx4>AB<=3B#(0Z%KpF1 zcqZ(W4uzL8o@L0wzd^qr0ujR1{wzhG&G-_7zKrn> z18-q`m4UBde2syxWxUhCUuC?@!2iv7w}Fp3K+4}^;33Av23Sqc=Q1vT+TPXw6^v)0 zU(%uUa2Mm*2L3GLMF#$N#>))+2t1D#`Zw@#j5iwixr{F{@T(Z_Fz~gEuQKqL8DC@I z!}0u;))+7RF~A_!Epb8u(j`FEQ`~u+T{IbQt*YjIT2AX^gKi@beh&H1Jy(?=tXT zGv00B?=s$F;D^G1NzMTLrLMQ}jAt5nJ>yvheiP%_2ELK;A_J#qtW<89fq(HpiO)9h z@r*Yb_&mm!7Fe8~BlUjz@A98F-lSG6Qd5e71qpGe_dnXyEj$k?x}mp_z*16k(_G3p3>W~jAvpz*V|<><5>n?$2i3! zI{lT57a90Hj8mMV)Bld~*#^FY@kRrudo$$6p9LTNPe!0qzjV$s0*^W8>Ld%#pF}@m z{v4(Rf{ZUS@Cl4xZs5}yzrw)JVZ6h@YZzC1Dpk1`Fuu~D?_m5U1E=S2B>yS{f0Xgt z4E#C9R~z_ijNfVC?=il{z%pr{0hcTHt?GmSNn{W-tJ($ z*q~p}c-X+7VZ7A9Ut_$CaiyR47@uX}gYZCs^r`kWD|rrKyvpF82Yj%$u3jjcKM-g9 zB)(SZEsQ4^SM)D3ez!qC49~I#Y3uU^oS!4`)q!f3hnJ-SZH&hayqj^F7t*2VPr@@A zs&9>fcQ9US;D2Sj&cKWCT!i@48~6>3HyC&id1qo1P`hJ`A=uuZc@gM&Kz*l8%hPGf5Z$8G+|4c$Wo# z-h#i7gqK53vJ@KYwR@3g(M?xs@kMK4&qm%6*CPcE(k?6TdF$hhRQO zhbouOGXgJCl5}JQew&05kP-Nu1>bDJU$Wq@SnyXZ_-hvYbqoHdB>V~1!&276SxhlK zTl&ew0TSSDAGm?>76ac3ochIU%m-#Bj#+33!uP{`l#XVZ1YQG<@nR5e6GtYe2jocl z3z!~Zk2q#B{(Z)O%=qsaKN<5#I+XmCW2F4^4LR>(e1U=Y0w+0FG9M*>U9Q9*V_eDq zK5&vhiweb|GLsPq(jMH%Xk^%O8y?k|H-(L|AKre|3X8~Cm3I3;3LP%a%UVW z%T@AU%J>D0EBQYQM@#Z6xmEfN;G~BhrdRSWXMF#WlE0FFKLjvDzlL!o{|ev~51env z`5NQjG4S9?lF#rjc;){AfFDZiw4^*<9h$#VzOEBS9>d;{Z3e!4#+@TOwp zNiza(d9Kw(h7%+7qbcT+jH>BfRpADU$U0j4OH8F+PKFB~QjUNngvjl4la*=NtHs7{8oxCC{+& zlFtW>EB#!|_;HA@=}_|QGeOc%WL(KJo$=X>D|uEhUT@%kWBdZfl{}{xOaAXLuH<=+ z@gtA)%0pKffxk)6_?r>u`e{8}3ZNYmjIDRwM=g0_T zSn#11d|wN`UlKkuB-^Es^{?7@4das-Ka1r$Wum0Njd5is%Nc*z;PVFKPaAw1CrLh| zza$weJ`XZJo^d75Az?{h#<-H_HpcHX_`JjT69%8tN+h362A|E0XJ>ikp{tC*0ZDq3 z_;3sUSqq+N!9QogKX1Vgw%~_Y@R1h$FbjUT1wX=q)2^iCBO{Py!ADu}V=VZWE%;X~ z_*X5sc(Xi7(2T&>Ec7Q>@UL6&pamae!E-Hmo(0dh;A(d5ty)IlBn$n?7M$M3NIo(G z-?ZT4EcgTqUTnc9TJW$1Kh1)dTJR|re3}KHZo$hf_)H58~AIC zHyHSSrBa?o10Tcqc?Ld*@g@UrW4zhGA7os8TSe9PuZ*`C^oLK8^2|5zsf;f$@JktA zXyA`9zR18oVf=gpFPcmFn)o7zsLAu1J9Z!`CMq=<&0ls;NN3>iGgoo{9*(D zT$$v5iGf!zzSO`MF}}>eZ)JSBfj`aor3U^HPO@La~*4ZMo+D-HZQ#%X_|-tXRFyu-jJl*@9zXW(-gzuLgBWc(Tff0XfS z4g4*}R~UHaOj+*t4g5OBuQTusjIT8CzcGHjfgf2R`QKpRlNrC!z!x&EzImkj@9m7= zY|y{J_$>zB%lHor{KV6xJgW?R8RI`R@cS6Q)xiJE_>T;H@)?rED^z`##B zTgtP}z*jK-pn<>6_<94+IY;vOrGa0@xca7-vj5kCJDXR9r1H;40^d(Ve5MX z5cn<5wL19;@KN$hg918)Gwu=iPZXK_wm7cV3H+xHuIQfvp6Q_O$?F!pNAS7RAyhql zcoWHUR}%hJf#2=mr}EhZ;71Lnw-n_ujMIpPev!b}D01fe5$~ocj!OIXKez1 z%E48+9}9f5gOBC29SewmGJSj@;mR%^8v7f_p^U;H47JZ+bj&A{1 zI+Td~TL*lUwogV3L&)0ae9$uwo&NKL>j0l;S@2xoqXI8EcYKx4?iBbd4t}KK^Btmp z&B0IPvtgBgFE@pBp9$P&K@+)vJTm_COG zgbt=ZaIuvCF_vFNoJRxq(pdJBHB1;59F zcUtf+;G+Uv+Y$9sIj|_Wly$|62zi$!E`!Oc+oy`LOo5M%--zNmV-NB)DaeUB5eE#X+hw#}a2$4qx{^j6m++Wu2U*9(1 zqXHi|^ppAQ{woRp$iWr=`>!JWV+U7$;E4{xdma25KHKy?!UwSz;qS5`uk32V|LxGL z`raw<42M3CDdvIUsDQhFL)k;~wS>F-H>NTD#VZJR_aP|xUle$5WTxUp_B3I8wq#!Cn$YBEbv1dJt({S z!A(T(KF?M7M*<(|(2rvNbvG0JVGjNk#;+B4a=T>SLiFx_2F3p}fgj=UQF!4Gi2g_i zFJbY+*jP|H$9YUjjZV z;O>7YWBRvmBi!BppvwK%?Sw1u!rzp}J&S)#xV!&h7V~)nQ@&9FcmIRZPt|I|-RJnq zPyS5c?!E|gH*w_sl<3`k5sJ@uf&2NZ?+JSM`L*gVFALn=N1^IW(BC;D*?pYyoff80y>1P533oqr$U?!F7vE*}Zp zeJ+0r^J%%C=-vGoivCW4mpc3pW%~PmLGPci)BbC#OC@xV!J-Xr{kf z;K}-2u#V{6{TQlVp9tLDk1>w^k+J_(*HTXBK#}|SNvBB+}-b?@b?8i z+o4x_4n0hKlG|mwz}Z33vC6&^I#a_~B!O zyZc5I{Q-~rx69{&j|#Z^Mil+G1)f~rp9#Fykw=a1k8L16?!FOap9PqTk8-{Sh2QRz zVg^SmW-$?ZCzL66dfAu$nU*Pbm z;j`gS5q_bAD>)Yn{Co#LiTPaiw7))A0r%6xAPc{M+NS1@R5wK74+^tA2ly{T;T3LpRY507jQql zy<@=-ebt}7(1Opi;CEQ?4=nhY*Zj-KeOO}v*5>LDZ$Tf=UVXFEcjn6 zc=n(D`Cn+k?*=|9klgQnX`z4Jg75zp_3Jwa1^C#9(}RHf)%Ua}e>^ZVT3>TwWn*I? za^}>+>4~zY`21)hRvOGMjx{#LDsf&FqP(2xiPGShiu!ncJQ0u9#?O~{X~B$1<0DhX zl}{$3VBYiz4YdtT6B_E96Vduab7{V~&K4|exj{>A-uT*RWsNQKjOutIX2~oljyBay zYKkthNlmd>y{*vkwJkP*b0;i{+U^@WB|0xwpNLx6 z=6@?zTidX}k~@|(VHdbiD#|Xj&}0h1MScq5gFz}Gbq!!^ph;PcU~pzrw7$79+5}Db zS9MJJ{CTB?u*}NX9IK)QQ7{Ll89%Qjw!m&ef-pCFUW-NTl2JAh)J2=(^_GSeWO>o^ zTbfc5%!$S4r6S0m6K{sRDJq^f$KF?@thu15udI$$MQiIC>Sd=+vS3;5bo$FCg8A`= z+E}W#$eYvDu)t!}qMX7xElstH7Bn=Z5~i>+S`|yAm8h~h+LUODwKS(vQekCvLuErP zd|E0^RyH(6Yf}&eb3su*7kw_)lt!)sqHK=WTAY~B!r02DcwKWtDn;d1TD^l{QBZ~c zlTH+(Ny8^NhKS}h)KczyYe||dNa1)=cFrJ^RaVDS8S+?S)?^zxv;vz&2TfJg9AecR zi>9rBXwPOc_%zlbTV7D6X;lwp%4U<4iI%4GS{mXh`=!)iT8C0l6^k`C#_Ln{reKhW znrjxNsqomUcwL&BN|Mx7%&uyvnwQoM6wZw|#pX1{ZNZFe{2*KkJWskoDHxpF&=hM< zq-*@Kb6YB_o8zg*ufloJczyGnhNgy8)|Nf5x}iCdPOMyV8!6Zn_QkE_rfHJAbd?SU z1;wHiA(2ov3QF0q1=S7pu|-ueOIRg%jIC}+q_M`rczsnoTA#Yt=M&MqR85c6s;Z47}1yyD!sDMz=$S_-(+ z^w(gvph`D3OI~S)xg5#MG03#mBDtoqO_ng7S`@F8<|m2L7*{YTRFZzU7$fQWFka+H z%Cz1ym@5fsWJ#wM4{6F;E3S!HtTvrF$hxO(ITT)(D%gXf>(a&nd9{e|Q^jXv(}x}T zm?bo%>;}R7x>!}brLIp?ieR=RPN$|EN!HMmCO8Q)VPi{EV{Iyh1#>0GzC<5+Oxl>{)Sehxh*#D3!5bCU#p@H5O|fWQDlb_VZ%!;~YDgLS z6x20TRz{oSsmv=FtdGu*p4*Ui2nJcIQDQ7cXv`8*HE*5>j8j!g5L7iq=cFLYM;wzn zW-gQzshb0A(wXg;#%OKKapWmPDinn20)D}+PgW%;`(#tujnT&Fq9_`#F{OO5Xk~R{ z%iOssh;kcaO)V+&QwPVnjkPVQEH;?k*suUWLK?4qSugSnLqN)QXtl@L(rB41Dn z(4Vw4Ha8&))<|cN<|LXU8MHJt#e5JcB9|;^oO(*RC$-d1z?yihNvjL6(pddGZmrxJ zQurc|j`B3jQIrO{+A=^XPoaCeM{haV-V9eGdX86vIYIXxQ;lP_EKNa4u#n1AgjZFX zyk32IGc=_IYsR-HKrzM>;qP4XS6>bxlV;;DT09O%(5||XFCvJGm zCNEWQQP--&6nfcb*OW!;V{UO{__{G#iLhBP%&D1yevz0F#au#mF%;2I-_q>J2$AS| z+T6L#G0}Tr*eI_y-i+Q>QqN#cUXAQ#6R~!sy642EXr1VDXHK1*O9nNzxGA~-Dh z=13(y7d zu}!+u!`WfrEnRX|Ob1%p>|GW&JF+L`4eqkM!96N(&MwQFlS6WlTJ_VL-ha=4Py@l;m4CW zrErhI+{i?ZDkF2E&9UH^$ao}?x@bN2Iy5EoGClhk5r>Czf{`gS=tp98jfq7OCsHN9 z9-1>_@=O{rAoxI)7tBL>v{_IV)zBnHkkI@Y<%z<`xcWtrs%Rn#OW{(-y0zp;+l-;p zDJ@he3YJ+ZTd$?DKbu=o|nX>f1TR<@b-Y<47${d)! z$#K)C)-i$u-Z4BJ2draI%(uHbhAZ(N?ifLyP47y_pkZsq01p_X>`yy{;*jxE>lir$ z-Z4BJ2draIxVyVLhAZ(N?ie`(&@rHx0q+>QGPm%orfCCU-@`&IFH&5HnL{uV!Hzw= zz|!0>w`6i!4*Yby49}&?^GLPj3Fo0!U#AqQ7Nql3&@81J<3#N7y2jf62kkRy?Jw71 zf@iF;CVCo&a2!$k07u42E38<2q}5#88tVY9Bn$sqg*T9}LDReVnPy@*b=T}j#8JCu zNMNxmmW10=Jlhx;Q*uMyJ!eZ4O@1oILX8c58Cu!#!tB z6oP#!)|L`au-FxA!tJ}=n%tmj&sh`2EuV@tQNcTFO?r^h=NKnN^Epd< z0~by01;d?CSn9!ew`dGSe%dO72x@Au6FN&hK_Z!nyhy(*mVJXS(pNpfy&g9e{c68OkxI4GXvY_`^r)$?@!Ze z+w}WuMyYm#N?ySn;mE{3LGdP0o;WQjtqq3oFIyebKw$N$>C=;q3FhVH7v|*<_w>{x zL{5HA;n>{#J`gKmvt8!WYFqnfq zvGK|X79;TjTuCKV6QmIyJ}MedG^0klBqLSy?ROgJvml@ zGxrSqa!{9a{V~b1$@23=sYWTH>0@VO%Kk`TRD3Fp32HdR`*8hx!KHK#EC&CiiAmPd zP3EA}W1N>43ArVP_8(#U^Bk>qX^G?gA=bmfw44|AhqE3ErsX`hKb))jLmcZ5vDc2$ zN{t>fR_~dS`SI9-5}%ILuf{H$jF(xQkt3}T#S?=$1(?S;cSr}6)I+DDKhCRf5grAO zrJjc7TGx)tAa-tZW3;|xL1|sEAU8LEY;JD$*fC?X3-j`V`N2H0*yK`tJNW(QzUIK3uBzZFwOYB`wc6*Ru;Z}*gN~0?tKlJ$KOdn9rUtugg7z`b zUi`pWwCk8$kpd_9p5oykfc0aLN^p)*;@ zshu3tQ?c@)Gg*~QF7}b#w~qd#CPPStyIbnxl?Y!jr>{uNb)A24ypp)!x%yNDdwG!= zF`B00FnhGG00YC?6nIy>w6B=E!q5~hWtA(7;~0^4hcZ)h#*puMiLN*=#M_kJd3s(X zjITDi>lzc1X>zh7_&z?CESh4~MB9jup;ayd;aswY{OM)17aW)II9-pG*AoF$(U)kZ z%89DTmlXM8<|+vkNh!WHsF9?aJG!;#U!d*Y7aY@qXa`^XidErtw#Jgay^4;3o2pMQ zVuv7K4BtSn#nP(0j=FI_^08+JeMKwKXb99)?HAuOqM$%nJ3hIpe#M|Ef)Af0O3Eih zLUniuHa3Dkh4iP`Tu8>NE@UBc{t=tg5Wy$D@NQp8X*`?egHy{RSk7^5$W=q%l&Ypa z;w=hSVXl4VYo+6pGYyp`16QctLb48`mL7Xx8>2=|@pda|0xuqfJgy$MU~#T85o}H* z8;oX5Q_IIi=*`K7s)+c2V1&#J^LlU_7eVJM=G9%1StW8+mQTMFS;4WI+IUewO*Dn7 zJ=VF`)!o`1(1g?-Cd!^5`h*(O*h<5VMH#X?7hupv0T@c7RqK&D^=n##!j_D=>N9>t+E;p6-x1S z9c}|;N5;_zMx9|GM=>gx`h(9~3ckag`Q<0iTZ+F)oQ3`#<1Gz}%y8NZf^AEh(v2w&1J|OUWRnmC4&r1R!DFmH;e-;k^rw-VDze6*F_ZYc!&ez28 zo#lq6fcwdC{aSpoS_0Cnoo}?6UlT5NP2Wz#rVl64ug{FSy!&~dEKl2%?s`uOd~BZ; zMRcuyR&-CTNIM$b`yvSCei4H1nKgH}K*tlt&chOc3=#%(MJ$v&16D<0*Og~7u?wp{ zsubf>y!z4rd{O1XXk;EmL->r&c`f+HuN+|ZkkT>q_2WTDq^cRuGsGv(S#pd=3*-1a zyjG1SEaGFCgsOp2Z4cEWcP@S&4-w;d74z(&a>wB3@_01#j^G1ouZ;<}467@5zoD-+ zMif8Wh~}xNUjY3e0B>%o6D=cRMnox9Rb^wRPn&Zt9=lM31q+>#wJg4np7mjT1zDLf zs)Bar>4Jy2%R3$yVmvIFUXZf?RpNWB!Bw&Cj3^TuN+hHs4kc-^2-y8_=j$Cre9K- z?O?vvLbk>xB_cebe`4-1P#l%6`C5xW;;8};OvXHchcQV(-{5fEoTET{Dre7(pAe-V zu3UV?ckg?UX&dgW4>FxtWDhQ#Di^4aD0^^Mfn&H%-ThbCLArA(Ry-p))+8{s2 zMbnkNP6cj&g-xI8{f2yeeha_djQ5^lBy;iOF8y}yp?ug{V?y>e?C#EsMC30C&52ey zKPwQage_8(q(x)y^f*;mh8NGBuuQvoPO5v1P|k08o3`*I3hDQ2@JZgec*Sgn`{BX8 z&N8e4r6pLR?&Gs%vY#u9A=e-Wh+*EG*gX7lvWmv{zIF`m($2KK(ks%_6OY;Kq0kh| zkDei#o>Ad(1FdV-#p*EGrMd0iI851Mmom8pz`;ha4A58bXnG)L2Yc(#A?5`w&9P>L zd-e11Gg5LG3EAcad$hSyO|uBE5}}3*_GWF zrnOea9uJfV5#-KaO|Ait-?8Z<$!qEHyH@r9?wP`xW9ni(ZNant|FqDaCL`2cohc{% zoQ3GWvHF%e?fo(Fq73cZkv|~y-%vN7P~C}6_qvr;v05i$^*J$oHA#N%QVZD!)+do! z(T}3+y=y!04*rqoUKx~QBrspR*FA`Ts0&vlS4tvtYWUTFy>U5N^xUKe;bs7~m&|Km zDfq&FL;bnf=qSc1@v^gWGkWMVZnwOTjeUmhVx@f1S~QJ(YuJp~_l~)y7-!{tQ-0+{ z&N^jCmbw{Kl!mQUa*|ph-zq~t@9QThcJGESyb1^(MAIJbf%x>D+yxNK=HK{gL_+~jFP3C&KmIYrXbE3Em6DSt4V ze>fN)PQntg*rr0S_Q_hpMzH9;z|~?&8n*bU5_kI#)(za1MW>Tv%1S%>WG^&7UzFml zb86B`{L(Qur2Fe@{huJEcnxU0nkbpgJaBJq^y|TeU0e27**%)_&Mp5}9!SwcZ0%VT zVm8;mTOUTjQ1-qsE_pgdx^muW_b5xf^v<1subXWl`u7QWll|!bz^7V7O+S@Swd4%= zr&{Q>gnoajWw#F7eGLA0*XM`OxUM_2gu8p6C!{fhpRb^o7vMvx;-eo%sB8NWh=_IZ zy$F0#0whUaWRb2@K1GpxMCmgN{RoKd1O0%1)sZ&Nsz8didie*Cp7?Q>w@-wy!OSn< zl&@1lh@?n!fXg={)A8b&H}>MXzXF^twngwy8(+-G@P8+!DpxU;jHlQnWr!e_z$>Gb z)iLpzHTeM%eKiOzNO8T`Y_ii&Y31xw|BTr#fBecn07|)YDQT7FKeTExUP=1aT1r=v zVuppC3vi77-}U0w{U3;Y=$%tM1j8SpIBjpg_>QeMY2J0GCqA`h`{G2gWvZF7`3CqC zYGyFz%+h!7`pksjfCqsz9qvmIh&M%0N%u{WXj4;kkyzxYjn&UfRMW}_zH!7;prlbL z-56283r?|69eyPQTrjj@zbJn2kH?v`D<~Lc%5$A(w9Y2O!pMY%dVE1CF|$Fu`96~# z>-xCMetl$xKG=kgFpkHxy)Pyd3)8#^iZAb<*Mb$pmWAX7_egvw>_dw{20G>u5evIH zdPKZavCaT*d@vs}IxffV_v}kueHgO-;{p<_|M?6)fc%H%R4<(2tM<-IYP#*%Rf)-j ze=+itnn8O6kdo&B4@>6ou=hD8%rML8hsGArcYCn&UaifemG?qr(2UjNrAz2h#UAj| z^qEwAFj0Ia5}Nn8P`$%(n~14WzaJ~{-b>e6(*qcaK(yGD+=HA7X`8hM)-|N?vZh<` znfLwo&kPXq>MyzAfm#XHd+_00`PEE!Ma{EjuAYU;fYBMul2?fO`K*zQLKsHc$3^NX zrpF$W7N~aelfm%B<|kKu8vj3Tj1`l9u^~>ZTd1bQx`up!i#qIuZj`pOIxl_*`=&3! zVoGCM^c4C^@j=KF38q8z9@zMncrAYLCus^3D!{-uhcXe0xFreyC+0Tz zDIbI|){m6Q?^C7uu75GVq9zt~r^3C%7-X-e4+`+-u~B5{UOO>DE9u|J7Vp~GtV9}+ z?*o;+`y1H^nT@zb7#Y6to2t*rkz_Z1M;oJgl2hL+{h`OkozJ#m^N_wiL>tn0JIwAF z-P3JH->suNmj8^=T?;u=#}hjn&ZJxt#m_moW5!-NMvDz!=7w)$sOF~;+G{-&)`%rb zPi(fE9xvmil+$Kli4x-@y`(1I4l8cNpeY^KUKm$-{D^$P1f}ZIe)1Kva-&L$9vc z|Jdih^zDjf{P=ZD%u>bH7+%YiA%D`7?Y*|?#o)v1Z2YkV`H7-b@v6D-(Z6o0KAyXq z!{13go@c*4z36{nHH~(z%PqRzm9#$X)zzDa)MKCSr&xi&Z@{_H zq~6B9Q&ssaRcv9Q$ZBU-aYJGmQ9T6~9wueDH}z`kvmu%O!30AObctw8`76<|gdFF04tM4S z7sU1Au?l)lsCeeQ=K2Md^ULPb4@*a8MjGSIjg_@yt74V4_|j8}_!TLN{);1s{;{Km zf1^Q+82IjHqOzKirkL1n!B_Z_yvn5y&GqlsUFg{W96($>1 z^Rg(5CaO`U`bmXY69K8&`TZzHFelzTZBBC~UYV>KzX&oJg{IJAc0*$nTUo|6#iHC4 zeg))VIUT>}Q0DxQLD}S--09+%6{a;NP+$Egu<#QZXT+uU`XeW zj;MN{FybjhU@b3K+@C@@sc#=EZubh@F9C9bfRI7=fHIn#@$pzC-k2b}l(z5+WtKit?mc~Z>lu~nOVIo#fzmpj< zy<(x8C1mk)>cJd*!q=rs!JSeG#^Yp3o0JU=A!swj%{2)C*sjQ7Q zH;Zo%$?u#)V1o)%6MRw2m#|z#7c)zI!-PN}kb{4848gyf2L}Ql_sXMApvm};E%@se zeCQyVLHt*1{3|T@?H2rf3tkJJbWoCkf4OvlV~GX7oN#sp9hl3^=_y8Q1jZt7v^eo{^o|DpxY zv*42q{AsqIZyER|#_KKkMFy_;TxP*OLIU4?)hM%k9T^in|;dg8JbsGM>hToy# zFKGB$4S!L?AJgzn8vd4s>vDdi;kuleZ0}^BI{z*Z#APV!gfa`Oe&GEVlR z>-pCfe3ORj<>q|em0vHnka1P6@}IY8^cN#j;dg8J1seXmhA-Ce6AyCB)#X3Mf|qKz zE`NuH>+)>UaJ^nHGp_2T?B|SwU3qjq^E6zq*LO8suh(BRT(8$ZE%?ww+;a7Lou=Ws zJXdPCUau95t9mK>Jn&GLzs~0<4cF^ctl@gSeyHJkz1CRpM>Jfo*N~C^@`N>9uh%rj zRlSt`Kc&&@^?F&u^?LnV!}WT7`wOl-dcDrI;EOa|uh+vGuFEs{Fqgkxul*QT^-}%l zLXG|sWGZ}--P< zk}HqS|6~o<`PW$R?`XKr{}v6``FCo#&i_3N-mBp{|4~`~@)v8k&R=QVrM3eN)4WH9orED7WBqG+g%^r)v1y8viL8{#OnEj)rg5 zaJ|0UH2gS?{v8dUs^RZyxK96`hO2mo`caRD=W2ZZrs1b)xGs<0U;eJqU!u|fL&LAr z@a-CYw}$KO`?!X`uhGAx;s4a|e`@%@G<=x0o~+B0rQv%2()FX$>vp2k>+PlcF%Abr zf7IK3v?k{cP0k_>|4_rv(D08myjH{Ye!W1$_4(kj8m{aA6b=7a6s%`_f4^jR|2zNrKQr&lGav8lOdH^b1HKY)yf5bg zeguR^KRFQaOCkJ`fL{#wAiyzQM*)uI;b_3eLOg>3p9%P}fG-C8IKaOEINtXSfa86~ zbR7@zOo#A807w6S0^nio(M1ps`r!$Hp9t}wKRgNWN(g^4;AsCR0KXiC{|4Y#e(*kKL3k`brvZ-P&j1|lzZL4mv=H5ifUkt`=;zVSItV`$bXNh6^?g0y zXF~XGfMa-U*UpCU)et@#@Mgfz0sQX(=Vx=)4}4v4f`WO%7Y7^Q-yr-d2>&YJm=DE( zp9{Lf0LSt_1@K`I9`ED%fa86?0B~$CupBl({8$d}0{lXV2X%7*NB?sX;8=gL{l)OZ zAw2r?ivh>-HUe-=Z!X}uVE?6nqb}wHmN&d#k3&48AfB%PJ{s`v0X_!sUjRN9@B@Hj zzv$wSc7HVB=s)uTNBgl}qaVO>H4f~-c6>bGi@;8dAIrlRq5LDB5Ah&AAq1ZYIQma) zf3e?-?Qab1#QqreW6@uI7Q$n?&IA0DU=NnJ%R+E0huHpN{$sijpAEX0uIm9W0NobA zrvQ%i7t@9LKNZ4bIhh7HrneAq>~CZL9PbPE&#|9?{quET|8$5S>(>>4e;>ln0Q^^g zW4mx9)Qe&We-7Z-KOYV_+FuIzl@QNjz|qdtfTNvVfa87t2H;mg{67YKCg8sT{A$1l za|1;ekDIOmd;;LJ0KXdW62NZ`!S4ec%hl%rN58~#7ksfj7=C+M4?}-G8|*9t`^N$PI^~t^Z(zOaOaC9!do9F&4#bb;Z6x4W-mtx%3-OGG z@CU%oX@Fl3;THgY1K{@oek0(I0*>_&`+M^s{L2vjCcpTsEq&=H4~KZFAbuPNVR^U$!dF9hET1vJ zu^m|r1tAJxX-vxXT*!g?F>j9rkY2=IBBOLEs2RM#*>H)|5vKa6N zh@bO>FOI(v@U?(rJp7(74v+riQNS_0Z~KVjJ1i$S9$ZFRw%wT$SYzzL{4W6<^Z!$T zH$i%_Uy9`f{XgOlLOhrc*iTpt@m~Vre+KsBbCxy;{}6=7=Mi579Cfk&;{3cULyK_n zT0-&LYlysI{AR#yJdC#ko(J1HK&a4#4jOd?+1J> z;6VYW@3=fX0Jwcl!T9F^AHo1#{PMSeX92zr@NB@p0C*1I4+5SC_}>A3QlJ`%aKB~? z_yO$a;5y_i3D5qP>#6m77Xgmr5rKnrJxt+;2rx)q*{p%|*Kv#i?Dvdgc&lr}cT4ze zLraT42XKx*BJ+)TfMfjmfOGf)2`_LE|N0R7?Qab@EZW}*`Hb;A3V61B!Oa!tsl5v1 z4dX{xkX|d~J>xbH8S3DFbTNK(@Xq|}l=qBFmIcUjfG_7S<=QE)3}F_$0r;`K1wQg+`*qciXx+Ht%Ltq@P`3sJI^)2BU=DJ7xL{zz|RBx0N`wY zsW^k7VlQLEAp9i2`MW9!KhMG65PX?~?-%?b2ft06%@zm0Pw*EV{1f7Y4mkKQ!G|7c zGK6iMfc67E5%76{e-iLzfKLMaPQW?;XBxRkC*XF@gum(rd@{td6Y$Fcw@#n!F91AS z$_wLD0G|Q)RKRNiXU|4*pzH9-!2JmkK&gH6v@{X^afX5)bZS2|p`G60TP5|Qz051f*7VsLtne!R3e}#j; zEO?iLA0>@&58w?D|6ag3{$�{%(RX{`0GRJ@J)hmcJRT{>Db}m<7{U{ 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 Ls*ci!m&^Y@M!o}^ literal 41888 zcmeI5e|%h3wdf~Jkt#@|f>b~VC|U)=oXO-Df~0MxO-Wj&Ndt(5>11+}44KSK=SSKg z&_G2R(n79)mY+9rsUi;^5h@f!4A(xXLNOp0`=CPb!{gT5T64MWeR-g7-dcOFJ!j9# zIcE~&{`dALGw1B@UVH7e*Zy(#*=J_5G0?npPDx3rheCz)!7(T*dxS&@2iTJNd% zTqtBe2l12Oh51gV<0*9fJRMJ^<7sp(r{n2xJcG`^0LL%V`I&J15}kh;jtlAhD|GxS z9nYfUIdH6?^K;?og_i*@AF)a}`suuij@59if!BY`KlS~##=-y9xanYd51@;d_N~nxo8m7KEEH5JqNlF2lj70e~zO_11WiK=voIQXONO( z=QxQB5C8g?!>VqrP`QOrx&80W|5RWC-d5~|YL0_x`=3RllyQwiM~UdxU>T-04vNF` z^<{zrd2fDMU~l74+eGL5g}XZ&=g0rq$_nyBC!pYTuIhd&8q_%WOQ~Esq;U{zq0^x& zrZlU;=rU}P!R%qkfK5>sIGkA^&f5+T3L7oImOzD7eMLLUELT`wShO1b;DyB99gRbC z&%|EUI2hP(jDgDC$_TLjx-qEUbC5KS{(|}jcB_7H0(5iH4_1kjIrG2$IA{@l;X)v) zFI@H~17eLsSL|-w8W=B74K5T;MlXT>HCRU5n4Q>)F_al=9DGakoIkyZ_A-^A?UR5# z@6EsLIW%@giteyc)VX~Ab-V1W$Q!#CjNOag*$cAq7Yl4V5a5PQ)2CaCTE?bp86E~# z@9$_lOSVnsC{gdmO}o6`T(ss2t93UWTnml36T0x|VB5obTTY3#94&A-wIz0Y=%QN# z69uWz%DbV|S!NmEbnU~XnQnaF*bnb>G7b2?u@~MwnR)PDk~!%>2!{)_uWF(-qKU>2 zECaLxx$v!Oy72?&qWo?yzx%+6D382Ae)q6NpqHXdUMJM~ZO{vKF3gBy_PXByrA{L? zLj89_j{ga-ad?TQ)d%*}v?hTJg`;g)8)rDmHb4Vy)>{Tg+19}5)8)|jp2auS3fSkK z{Y(L98%NQ`!PhLAwoyRa3Q%C%(~!&aEDSVV**2PmmJhzXXeUlwPc4AAr{|&QTo=(} zQ4|H9{sfB7nYk!l{VYqtN;wS*1F+bq@a<{T|17>~q9aeE@r7j#T>!|_xHUThHGXi> z&U%PFh4m1!IO?9aG_*Z9-7ODV$$=4d{(Rte)B$S2yujwC(2%DEQFE_wubPJgn;W-+ z%k>sO?^Cj9oV=(uU^g6Cr)GGtUCAFf+Jbq5bePwy!~BTE3&c64R%=|>>!+h?Wca__veYnK(rGa015T<*YuJ$sO-@(TTP^UY_S^~XP2 z>D#w|6@nFi^Ua+*Z@S5fheG$=H!@22Rw^%-+qf|pwBj8dcii#k zKU?u!ZfZ)e&%S-fAAkP&Ryta%`wvrwhV=9y2v&UO&hLEZm}9K?k43QJ9#2OH#*}?L z{pUY_^2weaD;;&~`rF!idd|gVa=w0BwqQ)f@4VCJd+|jpF7sOPKmF-@-@E#1D}L*( z&pdPMtya9T@q!EV^3FZ?VhC0`k9#~Xz4Y?SR{HI?dpy7UofXgJjz9jk+pM_9^NU~T z{)~!XrStfyrw$M6@{c`s1_Vn!mwW&H$w@1I#u-CHh3SR;ZJ!91{1gOTe=a9Shw|s^ zuW#R8UT(?bXw=7_8jVW+kw>HdBC>9#g~eB5?hGWo_ER(a>2|M=tU)>-jyeXG0s&><`C@x1^3U3XdW z#>SUl*2nwv&!2F@jW=59pM#K0TJa-Cu*I!7&fjmpT^RrAPxbhlZ$9#f6~{BZ|Nrf8 zM~>+JQN2a^qo?PVTfTtX19|^%-;OaW9ti01*I!R2Uwh3;KXhpSe%+tjwteuywry7W zqmLefV8!2fBbn6an_TWMfBBbxvC?z7*I$3?DJ#Bb&y6=;c%c=~<;KQdc)^PQ;SVDt zfB1tHA03^TD6DUxKV;vqbU z6%|86mtJbcbGai&^!ksCw6vUaj+M^WH#mL{9I(=_y6W=F_5PVm4h-nymB+F7==}#r z!^Vx4zNJfVxIv%KUU_B54t;(?Z|VJK@7`bhV((rne=Zk^EL >+2^b#>cJrp+h&^ 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 Otu9FP1#B$qJmrHp2QssHo-*v(cv= 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 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Wall.cpp.o index 0e4b1139a65d8ba11f192cab1923db9e8fee6924..7379d1a709c5e1907ff0dc99273b2192078f666d 100644 GIT binary patch literal 41096 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 literal 39464 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 diff --git a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal index 4cac77b..cbbb3a3 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal +++ b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal @@ -7118,4 +7118,1372 @@ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake-3.31/Modules/Platform/Linux.cmake /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake diff --git a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make index d4f3757..58c5af3 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make +++ b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make @@ -7116,6 +7116,1374 @@ TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLi /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake diff --git a/cmake-build-debug/TanksGame b/cmake-build-debug/TanksGame index 47ce6b6917e9532469b55dbf9fcecb601c2e1e02..64177be2f94f1b9cddb5234041c4faadeaec0ec6 100755 GIT binary patch literal 444240 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%0A9oTdYnQEJ7ZM5(w^gV&9dqfpq-6{W*sy*h2}+) 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 literal 341248 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 +class QPainter; + class Wall final : public QGraphicsPixmapItem { public: explicit Wall(qreal x, qreal y); + +private: + void InitRivets(QPainter& painter); }; diff --git a/src/EnemyTank.cpp b/src/EnemyTank.cpp index 5ce6743..4f66238 100644 --- a/src/EnemyTank.cpp +++ b/src/EnemyTank.cpp @@ -7,6 +7,9 @@ #include "GlobalConstants.h" #include "Bullet.h" +#include +#include + EnemyTank::EnemyTank(qreal x, qreal y) { setPos(x, y); setZValue(1); @@ -75,19 +78,17 @@ void EnemyTank::UpdatePixmap() { } void EnemyTank::DrawGun(QPainter& painter, int center, int gunLength) const { - switch (m_direction) { - case Direction::Up: - painter.drawLine(center, center, center, center - gunLength); - break; - case Direction::Down: - painter.drawLine(center, center, center, center + gunLength); - break; - case Direction::Left: - painter.drawLine(center, center, center - gunLength, center); - break; - case Direction::Right: - painter.drawLine(center, center, center + gunLength, center); - break; + using Handler = std::function; + static const std::unordered_map handlers = { + {Direction::Up, [](QPainter& p, int c, int g) { p.drawLine(c, c, c, c - g); }}, + {Direction::Down, [](QPainter& p, int c, int g) { p.drawLine(c, c, c, c + g); }}, + {Direction::Left, [](QPainter& p, int c, int g) { p.drawLine(c, c, c - g, c); }}, + {Direction::Right, [](QPainter& p, int c, int g) { p.drawLine(c, c, c + g, c); }} + }; + + auto it = handlers.find(m_direction); + if (it != handlers.end()) { + it->second(painter, center, gunLength); } } diff --git a/src/Tank.cpp b/src/Tank.cpp index 18f760e..aae7b9e 100644 --- a/src/Tank.cpp +++ b/src/Tank.cpp @@ -5,20 +5,21 @@ #include "GlobalConstants.h" +#include +#include + void Tank::DrawGun(QPainter& painter, int center, int gunLength) const { - switch (m_direction) { - case Direction::Up: - painter.drawLine(center, center, center, center - gunLength); - break; - case Direction::Down: - painter.drawLine(center, center, center, center + gunLength); - break; - case Direction::Left: - painter.drawLine(center, center, center - gunLength, center); - break; - case Direction::Right: - painter.drawLine(center, center, center + gunLength, center); - break; + using Handler = std::function; + static const std::unordered_map handlers = { + {Direction::Up, [](QPainter& p, int c, int g) { p.drawLine(c, c, c, c - g); }}, + {Direction::Down, [](QPainter& p, int c, int g) { p.drawLine(c, c, c, c + g); }}, + {Direction::Left, [](QPainter& p, int c, int g) { p.drawLine(c, c, c - g, c); }}, + {Direction::Right, [](QPainter& p, int c, int g) { p.drawLine(c, c, c + g, c); }} + }; + + auto it = handlers.find(m_direction); + if (it != handlers.end()) { + it->second(painter, center, gunLength); } } diff --git a/src/Wall.cpp b/src/Wall.cpp index f9da40f..99c7935 100644 --- a/src/Wall.cpp +++ b/src/Wall.cpp @@ -22,23 +22,28 @@ Wall::Wall(qreal x, qreal y) { painter.fillRect(18, 2, kPanelSize, kPanelSize, panelColor); painter.fillRect(2, 18, kPanelSize, kPanelSize, panelColor); painter.fillRect(18, 18, kPanelSize, kPanelSize, panelColor); + + InitRivets(painter); + painter.setPen(QPen(QColor(30, 30, 30), 2)); + painter.drawRect(0, 0, kWallSize - 1, kWallSize - 1); + + painter.end(); + setPixmap(pixmap); +} + +void Wall::InitRivets(QPainter& painter) { painter.setPen(Qt::NoPen); painter.setBrush(Qt::black); - const struct { int x; int y; } rivets[] = { + constexpr std::array,16> rivets = {{ {4, 4}, {12, 4}, {4, 12}, {12, 12}, {20, 4}, {28, 4}, {20, 12}, {28, 12}, {4, 20}, {12, 20}, {4, 28}, {12, 28}, {20, 20},{28, 20},{20, 28}, {28, 28} - }; + }}; + for (const auto& r : rivets) { - painter.drawEllipse(r.x - kRivetRadius, r.y - kRivetRadius, + painter.drawEllipse(r.first - kRivetRadius, r.second - kRivetRadius, 2 * kRivetRadius, 2 * kRivetRadius); } - - painter.setPen(QPen(QColor(30, 30, 30), 2)); - painter.drawRect(0, 0, kWallSize - 1, kWallSize - 1); - - painter.end(); - setPixmap(pixmap); } From 448e7284e4051bb569b94df730261d08703134df Mon Sep 17 00:00:00 2001 From: frankyshelloy Date: Tue, 9 Dec 2025 03:45:07 +0700 Subject: [PATCH 04/13] A bit more updates --- .vscode/settings.json | 4 + cmake-build-debug/CMakeCache.txt | 4 +- .../TanksGame_autogen/mocs_compilation.cpp.o | Bin 73912 -> 37392 bytes .../mocs_compilation.cpp.o.d | 5 + .../TanksGame.dir/compiler_depend.internal | 3648 +--------------- .../TanksGame.dir/compiler_depend.make | 3742 +---------------- .../CMakeFiles/TanksGame.dir/src/Bonus.cpp.o | Bin 45296 -> 45472 bytes .../TanksGame.dir/src/Bonus.cpp.o.d | 5 + .../TanksGame.dir/src/GameScane.cpp.o | Bin 304112 -> 432464 bytes .../TanksGame.dir/src/GameScane.cpp.o.d | 10 +- .../CMakeFiles/TanksGame.dir/src/main.cpp.o | Bin 31448 -> 31624 bytes .../CMakeFiles/TanksGame.dir/src/main.cpp.o.d | 5 + .../TanksGame_autogen.dir/ParseCache.txt | 4 + .../compiler_depend.internal | 1824 ++++++++ .../compiler_depend.make | 1824 ++++++++ cmake-build-debug/TanksGame | Bin 444240 -> 498832 bytes .../6YEA5652QU/moc_GameScane.cpp.d | 4 + cmake-build-debug/TanksGame_autogen/deps | 4 + cmake-build-debug/compile_commands.json | 80 + include/GameScane.h | 13 +- src/GameScane.cpp | 62 +- 21 files changed, 3862 insertions(+), 7376 deletions(-) create mode 100644 .vscode/settings.json create mode 100644 cmake-build-debug/compile_commands.json diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..d965816 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,4 @@ +{ + "C_Cpp.default.compileCommands": "${workspaceFolder}/cmake-build-debug/compile_commands.json", + "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools" +} diff --git a/cmake-build-debug/CMakeCache.txt b/cmake-build-debug/CMakeCache.txt index 5deb6a6..3b7e33a 100644 --- a/cmake-build-debug/CMakeCache.txt +++ b/cmake-build-debug/CMakeCache.txt @@ -71,8 +71,8 @@ CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= //Flags used by the linker during RELWITHDEBINFO builds. CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= -//Enable/Disable output of compile commands during generation. -CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= +//No help, variable specified on the command line. +CMAKE_EXPORT_COMPILE_COMMANDS:UNINITIALIZED=ON //Value Computed by CMake. CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/pkgRedirects diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o index 3ffcd0b6cefe0331e47a01fa2edaa7b74a2bb74a..88bdaba48e129b9c654c8039351092c8f22772a1 100644 GIT binary patch literal 37392 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 YRR5DXDk|3A`SOqNkRn$w$MF3BA8%r5q5uE@ literal 73912 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 diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d b/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d index 67306d2..0163e59 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o.d @@ -355,6 +355,11 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: \ /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/../../../include/Bullet.h \ /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/../../../include/Tank.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/../../../include/Wall.h \ + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/../../../include/BrickWall.h \ /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal index a53f98e..52143ac 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal @@ -2,3650 +2,6 @@ # Generated by "Unix Makefiles" Generator, CMake Version 3.31 /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/timestamp - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake - /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp - /usr/bin/cmake - /usr/include/asm-generic/bitsperlong.h - /usr/include/asm-generic/errno-base.h - /usr/include/asm-generic/errno.h - /usr/include/asm-generic/int-ll64.h - /usr/include/asm-generic/posix_types.h - /usr/include/asm-generic/types.h - /usr/include/assert.h - /usr/include/c++/14/algorithm - /usr/include/c++/14/array - /usr/include/c++/14/atomic - /usr/include/c++/14/backward/auto_ptr.h - /usr/include/c++/14/backward/binders.h - /usr/include/c++/14/bit - /usr/include/c++/14/bits/algorithmfwd.h - /usr/include/c++/14/bits/align.h - /usr/include/c++/14/bits/alloc_traits.h - /usr/include/c++/14/bits/allocated_ptr.h - /usr/include/c++/14/bits/allocator.h - /usr/include/c++/14/bits/atomic_base.h - /usr/include/c++/14/bits/atomic_lockfree_defines.h - /usr/include/c++/14/bits/atomic_wait.h - /usr/include/c++/14/bits/basic_ios.h - /usr/include/c++/14/bits/basic_ios.tcc - /usr/include/c++/14/bits/basic_string.h - /usr/include/c++/14/bits/basic_string.tcc - /usr/include/c++/14/bits/c++0x_warning.h - /usr/include/c++/14/bits/char_traits.h - /usr/include/c++/14/bits/charconv.h - /usr/include/c++/14/bits/concept_check.h - /usr/include/c++/14/bits/cpp_type_traits.h - /usr/include/c++/14/bits/cxxabi_forced.h - /usr/include/c++/14/bits/cxxabi_init_exception.h - /usr/include/c++/14/bits/erase_if.h - /usr/include/c++/14/bits/exception.h - /usr/include/c++/14/bits/exception_defines.h - /usr/include/c++/14/bits/exception_ptr.h - /usr/include/c++/14/bits/functexcept.h - /usr/include/c++/14/bits/functional_hash.h - /usr/include/c++/14/bits/hash_bytes.h - /usr/include/c++/14/bits/invoke.h - /usr/include/c++/14/bits/ios_base.h - /usr/include/c++/14/bits/iterator_concepts.h - /usr/include/c++/14/bits/list.tcc - /usr/include/c++/14/bits/locale_classes.h - /usr/include/c++/14/bits/locale_classes.tcc - /usr/include/c++/14/bits/locale_facets.h - /usr/include/c++/14/bits/locale_facets.tcc - /usr/include/c++/14/bits/localefwd.h - /usr/include/c++/14/bits/max_size_type.h - /usr/include/c++/14/bits/memory_resource.h - /usr/include/c++/14/bits/memoryfwd.h - /usr/include/c++/14/bits/mofunc_impl.h - /usr/include/c++/14/bits/move.h - /usr/include/c++/14/bits/move_only_function.h - /usr/include/c++/14/bits/nested_exception.h - /usr/include/c++/14/bits/new_allocator.h - /usr/include/c++/14/bits/node_handle.h - /usr/include/c++/14/bits/ostream.tcc - /usr/include/c++/14/bits/ostream_insert.h - /usr/include/c++/14/bits/out_ptr.h - /usr/include/c++/14/bits/postypes.h - /usr/include/c++/14/bits/predefined_ops.h - /usr/include/c++/14/bits/ptr_traits.h - /usr/include/c++/14/bits/range_access.h - /usr/include/c++/14/bits/ranges_algo.h - /usr/include/c++/14/bits/ranges_algobase.h - /usr/include/c++/14/bits/ranges_base.h - /usr/include/c++/14/bits/ranges_cmp.h - /usr/include/c++/14/bits/ranges_uninitialized.h - /usr/include/c++/14/bits/ranges_util.h - /usr/include/c++/14/bits/refwrap.h - /usr/include/c++/14/bits/requires_hosted.h - /usr/include/c++/14/bits/sat_arith.h - /usr/include/c++/14/bits/shared_ptr.h - /usr/include/c++/14/bits/shared_ptr_atomic.h - /usr/include/c++/14/bits/shared_ptr_base.h - /usr/include/c++/14/bits/std_abs.h - /usr/include/c++/14/bits/std_function.h - /usr/include/c++/14/bits/std_mutex.h - /usr/include/c++/14/bits/stl_algo.h - /usr/include/c++/14/bits/stl_algobase.h - /usr/include/c++/14/bits/stl_bvector.h - /usr/include/c++/14/bits/stl_construct.h - /usr/include/c++/14/bits/stl_function.h - /usr/include/c++/14/bits/stl_heap.h - /usr/include/c++/14/bits/stl_iterator.h - /usr/include/c++/14/bits/stl_iterator_base_funcs.h - /usr/include/c++/14/bits/stl_iterator_base_types.h - /usr/include/c++/14/bits/stl_list.h - /usr/include/c++/14/bits/stl_map.h - /usr/include/c++/14/bits/stl_multimap.h - /usr/include/c++/14/bits/stl_numeric.h - /usr/include/c++/14/bits/stl_pair.h - /usr/include/c++/14/bits/stl_raw_storage_iter.h - /usr/include/c++/14/bits/stl_relops.h - /usr/include/c++/14/bits/stl_tempbuf.h - /usr/include/c++/14/bits/stl_tree.h - /usr/include/c++/14/bits/stl_uninitialized.h - /usr/include/c++/14/bits/stl_vector.h - /usr/include/c++/14/bits/stream_iterator.h - /usr/include/c++/14/bits/streambuf.tcc - /usr/include/c++/14/bits/streambuf_iterator.h - /usr/include/c++/14/bits/string_view.tcc - /usr/include/c++/14/bits/stringfwd.h - /usr/include/c++/14/bits/uniform_int_dist.h - /usr/include/c++/14/bits/unique_ptr.h - /usr/include/c++/14/bits/uses_allocator.h - /usr/include/c++/14/bits/uses_allocator_args.h - /usr/include/c++/14/bits/utility.h - /usr/include/c++/14/bits/vector.tcc - /usr/include/c++/14/bits/version.h - /usr/include/c++/14/cctype - /usr/include/c++/14/cerrno - /usr/include/c++/14/charconv - /usr/include/c++/14/climits - /usr/include/c++/14/clocale - /usr/include/c++/14/compare - /usr/include/c++/14/concepts - /usr/include/c++/14/cstddef - /usr/include/c++/14/cstdint - /usr/include/c++/14/cstdlib - /usr/include/c++/14/cwchar - /usr/include/c++/14/cwctype - /usr/include/c++/14/debug/assertions.h - /usr/include/c++/14/debug/debug.h - /usr/include/c++/14/exception - /usr/include/c++/14/ext/aligned_buffer.h - /usr/include/c++/14/ext/alloc_traits.h - /usr/include/c++/14/ext/atomicity.h - /usr/include/c++/14/ext/concurrence.h - /usr/include/c++/14/ext/numeric_traits.h - /usr/include/c++/14/ext/string_conversions.h - /usr/include/c++/14/ext/type_traits.h - /usr/include/c++/14/format - /usr/include/c++/14/functional - /usr/include/c++/14/initializer_list - /usr/include/c++/14/ios - /usr/include/c++/14/iosfwd - /usr/include/c++/14/iterator - /usr/include/c++/14/limits - /usr/include/c++/14/list - /usr/include/c++/14/map - /usr/include/c++/14/memory - /usr/include/c++/14/new - /usr/include/c++/14/numbers - /usr/include/c++/14/numeric - /usr/include/c++/14/optional - /usr/include/c++/14/ostream - /usr/include/c++/14/pstl/execution_defs.h - /usr/include/c++/14/pstl/glue_numeric_defs.h - /usr/include/c++/14/stdexcept - /usr/include/c++/14/stdlib.h - /usr/include/c++/14/streambuf - /usr/include/c++/14/string - /usr/include/c++/14/string_view - /usr/include/c++/14/text_encoding - /usr/include/c++/14/tuple - /usr/include/c++/14/type_traits - /usr/include/c++/14/typeinfo - /usr/include/c++/14/unordered_map - /usr/include/c++/14/utility - /usr/include/c++/14/vector - /usr/include/ctype.h - /usr/include/errno.h - /usr/include/features-time64.h - /usr/include/features.h - /usr/include/linux/errno.h - /usr/include/linux/posix_types.h - /usr/include/linux/stddef.h - /usr/include/linux/types.h - /usr/include/locale.h - /usr/include/pthread.h - /usr/include/sched.h - /usr/include/stdc-predef.h - /usr/include/stdio.h - /usr/include/string.h - /usr/include/strings.h - /usr/include/syscall.h - /usr/include/time.h - /usr/include/unistd.h - /usr/include/wchar.h - /usr/include/wctype.h - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h - /usr/include/x86_64-linux-gnu/asm/errno.h - /usr/include/x86_64-linux-gnu/asm/posix_types.h - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h - /usr/include/x86_64-linux-gnu/asm/types.h - /usr/include/x86_64-linux-gnu/asm/unistd.h - /usr/include/x86_64-linux-gnu/asm/unistd_64.h - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h - /usr/include/x86_64-linux-gnu/bits/confname.h - /usr/include/x86_64-linux-gnu/bits/cpu-set.h - /usr/include/x86_64-linux-gnu/bits/endian.h - /usr/include/x86_64-linux-gnu/bits/endianness.h - /usr/include/x86_64-linux-gnu/bits/environments.h - /usr/include/x86_64-linux-gnu/bits/errno.h - /usr/include/x86_64-linux-gnu/bits/floatn-common.h - /usr/include/x86_64-linux-gnu/bits/floatn.h - /usr/include/x86_64-linux-gnu/bits/getopt_core.h - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h - /usr/include/x86_64-linux-gnu/bits/locale.h - /usr/include/x86_64-linux-gnu/bits/long-double.h - /usr/include/x86_64-linux-gnu/bits/posix_opt.h - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h - /usr/include/x86_64-linux-gnu/bits/sched.h - /usr/include/x86_64-linux-gnu/bits/setjmp.h - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h - /usr/include/x86_64-linux-gnu/bits/syscall.h - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h - /usr/include/x86_64-linux-gnu/bits/time.h - /usr/include/x86_64-linux-gnu/bits/time64.h - /usr/include/x86_64-linux-gnu/bits/timesize.h - /usr/include/x86_64-linux-gnu/bits/timex.h - /usr/include/x86_64-linux-gnu/bits/types.h - /usr/include/x86_64-linux-gnu/bits/types/FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h - /usr/include/x86_64-linux-gnu/bits/types/error_t.h - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h - /usr/include/x86_64-linux-gnu/bits/types/time_t.h - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h - /usr/include/x86_64-linux-gnu/bits/typesizes.h - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h - /usr/include/x86_64-linux-gnu/bits/wchar.h - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h - /usr/include/x86_64-linux-gnu/bits/wordsize.h - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h - /usr/include/x86_64-linux-gnu/gnu/stubs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h - /usr/include/x86_64-linux-gnu/sys/cdefs.h - /usr/include/x86_64-linux-gnu/sys/syscall.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake @@ -5018,9 +1374,12 @@ /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp @@ -5365,6 +1724,7 @@ /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make index 8f29692..e1baafa 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make @@ -2,3650 +2,6 @@ # Generated by "Unix Makefiles" Generator, CMake Version 3.31 TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ - CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ - CMakeFiles/3.31.6/CMakeSystem.cmake \ - TanksGame_autogen/moc_predefs.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ - /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ - /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ - /usr/bin/cmake \ - /usr/include/asm-generic/bitsperlong.h \ - /usr/include/asm-generic/errno-base.h \ - /usr/include/asm-generic/errno.h \ - /usr/include/asm-generic/int-ll64.h \ - /usr/include/asm-generic/posix_types.h \ - /usr/include/asm-generic/types.h \ - /usr/include/assert.h \ - /usr/include/c++/14/algorithm \ - /usr/include/c++/14/array \ - /usr/include/c++/14/atomic \ - /usr/include/c++/14/backward/auto_ptr.h \ - /usr/include/c++/14/backward/binders.h \ - /usr/include/c++/14/bit \ - /usr/include/c++/14/bits/algorithmfwd.h \ - /usr/include/c++/14/bits/align.h \ - /usr/include/c++/14/bits/alloc_traits.h \ - /usr/include/c++/14/bits/allocated_ptr.h \ - /usr/include/c++/14/bits/allocator.h \ - /usr/include/c++/14/bits/atomic_base.h \ - /usr/include/c++/14/bits/atomic_lockfree_defines.h \ - /usr/include/c++/14/bits/atomic_wait.h \ - /usr/include/c++/14/bits/basic_ios.h \ - /usr/include/c++/14/bits/basic_ios.tcc \ - /usr/include/c++/14/bits/basic_string.h \ - /usr/include/c++/14/bits/basic_string.tcc \ - /usr/include/c++/14/bits/c++0x_warning.h \ - /usr/include/c++/14/bits/char_traits.h \ - /usr/include/c++/14/bits/charconv.h \ - /usr/include/c++/14/bits/concept_check.h \ - /usr/include/c++/14/bits/cpp_type_traits.h \ - /usr/include/c++/14/bits/cxxabi_forced.h \ - /usr/include/c++/14/bits/cxxabi_init_exception.h \ - /usr/include/c++/14/bits/erase_if.h \ - /usr/include/c++/14/bits/exception.h \ - /usr/include/c++/14/bits/exception_defines.h \ - /usr/include/c++/14/bits/exception_ptr.h \ - /usr/include/c++/14/bits/functexcept.h \ - /usr/include/c++/14/bits/functional_hash.h \ - /usr/include/c++/14/bits/hash_bytes.h \ - /usr/include/c++/14/bits/invoke.h \ - /usr/include/c++/14/bits/ios_base.h \ - /usr/include/c++/14/bits/iterator_concepts.h \ - /usr/include/c++/14/bits/list.tcc \ - /usr/include/c++/14/bits/locale_classes.h \ - /usr/include/c++/14/bits/locale_classes.tcc \ - /usr/include/c++/14/bits/locale_facets.h \ - /usr/include/c++/14/bits/locale_facets.tcc \ - /usr/include/c++/14/bits/localefwd.h \ - /usr/include/c++/14/bits/max_size_type.h \ - /usr/include/c++/14/bits/memory_resource.h \ - /usr/include/c++/14/bits/memoryfwd.h \ - /usr/include/c++/14/bits/mofunc_impl.h \ - /usr/include/c++/14/bits/move.h \ - /usr/include/c++/14/bits/move_only_function.h \ - /usr/include/c++/14/bits/nested_exception.h \ - /usr/include/c++/14/bits/new_allocator.h \ - /usr/include/c++/14/bits/node_handle.h \ - /usr/include/c++/14/bits/ostream.tcc \ - /usr/include/c++/14/bits/ostream_insert.h \ - /usr/include/c++/14/bits/out_ptr.h \ - /usr/include/c++/14/bits/postypes.h \ - /usr/include/c++/14/bits/predefined_ops.h \ - /usr/include/c++/14/bits/ptr_traits.h \ - /usr/include/c++/14/bits/range_access.h \ - /usr/include/c++/14/bits/ranges_algo.h \ - /usr/include/c++/14/bits/ranges_algobase.h \ - /usr/include/c++/14/bits/ranges_base.h \ - /usr/include/c++/14/bits/ranges_cmp.h \ - /usr/include/c++/14/bits/ranges_uninitialized.h \ - /usr/include/c++/14/bits/ranges_util.h \ - /usr/include/c++/14/bits/refwrap.h \ - /usr/include/c++/14/bits/requires_hosted.h \ - /usr/include/c++/14/bits/sat_arith.h \ - /usr/include/c++/14/bits/shared_ptr.h \ - /usr/include/c++/14/bits/shared_ptr_atomic.h \ - /usr/include/c++/14/bits/shared_ptr_base.h \ - /usr/include/c++/14/bits/std_abs.h \ - /usr/include/c++/14/bits/std_function.h \ - /usr/include/c++/14/bits/std_mutex.h \ - /usr/include/c++/14/bits/stl_algo.h \ - /usr/include/c++/14/bits/stl_algobase.h \ - /usr/include/c++/14/bits/stl_bvector.h \ - /usr/include/c++/14/bits/stl_construct.h \ - /usr/include/c++/14/bits/stl_function.h \ - /usr/include/c++/14/bits/stl_heap.h \ - /usr/include/c++/14/bits/stl_iterator.h \ - /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ - /usr/include/c++/14/bits/stl_iterator_base_types.h \ - /usr/include/c++/14/bits/stl_list.h \ - /usr/include/c++/14/bits/stl_map.h \ - /usr/include/c++/14/bits/stl_multimap.h \ - /usr/include/c++/14/bits/stl_numeric.h \ - /usr/include/c++/14/bits/stl_pair.h \ - /usr/include/c++/14/bits/stl_raw_storage_iter.h \ - /usr/include/c++/14/bits/stl_relops.h \ - /usr/include/c++/14/bits/stl_tempbuf.h \ - /usr/include/c++/14/bits/stl_tree.h \ - /usr/include/c++/14/bits/stl_uninitialized.h \ - /usr/include/c++/14/bits/stl_vector.h \ - /usr/include/c++/14/bits/stream_iterator.h \ - /usr/include/c++/14/bits/streambuf.tcc \ - /usr/include/c++/14/bits/streambuf_iterator.h \ - /usr/include/c++/14/bits/string_view.tcc \ - /usr/include/c++/14/bits/stringfwd.h \ - /usr/include/c++/14/bits/uniform_int_dist.h \ - /usr/include/c++/14/bits/unique_ptr.h \ - /usr/include/c++/14/bits/uses_allocator.h \ - /usr/include/c++/14/bits/uses_allocator_args.h \ - /usr/include/c++/14/bits/utility.h \ - /usr/include/c++/14/bits/vector.tcc \ - /usr/include/c++/14/bits/version.h \ - /usr/include/c++/14/cctype \ - /usr/include/c++/14/cerrno \ - /usr/include/c++/14/charconv \ - /usr/include/c++/14/climits \ - /usr/include/c++/14/clocale \ - /usr/include/c++/14/compare \ - /usr/include/c++/14/concepts \ - /usr/include/c++/14/cstddef \ - /usr/include/c++/14/cstdint \ - /usr/include/c++/14/cstdlib \ - /usr/include/c++/14/cwchar \ - /usr/include/c++/14/cwctype \ - /usr/include/c++/14/debug/assertions.h \ - /usr/include/c++/14/debug/debug.h \ - /usr/include/c++/14/exception \ - /usr/include/c++/14/ext/aligned_buffer.h \ - /usr/include/c++/14/ext/alloc_traits.h \ - /usr/include/c++/14/ext/atomicity.h \ - /usr/include/c++/14/ext/concurrence.h \ - /usr/include/c++/14/ext/numeric_traits.h \ - /usr/include/c++/14/ext/string_conversions.h \ - /usr/include/c++/14/ext/type_traits.h \ - /usr/include/c++/14/format \ - /usr/include/c++/14/functional \ - /usr/include/c++/14/initializer_list \ - /usr/include/c++/14/ios \ - /usr/include/c++/14/iosfwd \ - /usr/include/c++/14/iterator \ - /usr/include/c++/14/limits \ - /usr/include/c++/14/list \ - /usr/include/c++/14/map \ - /usr/include/c++/14/memory \ - /usr/include/c++/14/new \ - /usr/include/c++/14/numbers \ - /usr/include/c++/14/numeric \ - /usr/include/c++/14/optional \ - /usr/include/c++/14/ostream \ - /usr/include/c++/14/pstl/execution_defs.h \ - /usr/include/c++/14/pstl/glue_numeric_defs.h \ - /usr/include/c++/14/stdexcept \ - /usr/include/c++/14/stdlib.h \ - /usr/include/c++/14/streambuf \ - /usr/include/c++/14/string \ - /usr/include/c++/14/string_view \ - /usr/include/c++/14/text_encoding \ - /usr/include/c++/14/tuple \ - /usr/include/c++/14/type_traits \ - /usr/include/c++/14/typeinfo \ - /usr/include/c++/14/unordered_map \ - /usr/include/c++/14/utility \ - /usr/include/c++/14/vector \ - /usr/include/ctype.h \ - /usr/include/errno.h \ - /usr/include/features-time64.h \ - /usr/include/features.h \ - /usr/include/linux/errno.h \ - /usr/include/linux/posix_types.h \ - /usr/include/linux/stddef.h \ - /usr/include/linux/types.h \ - /usr/include/locale.h \ - /usr/include/pthread.h \ - /usr/include/sched.h \ - /usr/include/stdc-predef.h \ - /usr/include/stdio.h \ - /usr/include/string.h \ - /usr/include/strings.h \ - /usr/include/syscall.h \ - /usr/include/time.h \ - /usr/include/unistd.h \ - /usr/include/wchar.h \ - /usr/include/wctype.h \ - /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ - /usr/include/x86_64-linux-gnu/asm/errno.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types.h \ - /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ - /usr/include/x86_64-linux-gnu/asm/types.h \ - /usr/include/x86_64-linux-gnu/asm/unistd.h \ - /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ - /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ - /usr/include/x86_64-linux-gnu/bits/confname.h \ - /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ - /usr/include/x86_64-linux-gnu/bits/endian.h \ - /usr/include/x86_64-linux-gnu/bits/endianness.h \ - /usr/include/x86_64-linux-gnu/bits/environments.h \ - /usr/include/x86_64-linux-gnu/bits/errno.h \ - /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ - /usr/include/x86_64-linux-gnu/bits/floatn.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ - /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ - /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ - /usr/include/x86_64-linux-gnu/bits/locale.h \ - /usr/include/x86_64-linux-gnu/bits/long-double.h \ - /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ - /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ - /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ - /usr/include/x86_64-linux-gnu/bits/sched.h \ - /usr/include/x86_64-linux-gnu/bits/setjmp.h \ - /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ - /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ - /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ - /usr/include/x86_64-linux-gnu/bits/syscall.h \ - /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ - /usr/include/x86_64-linux-gnu/bits/time.h \ - /usr/include/x86_64-linux-gnu/bits/time64.h \ - /usr/include/x86_64-linux-gnu/bits/timesize.h \ - /usr/include/x86_64-linux-gnu/bits/timex.h \ - /usr/include/x86_64-linux-gnu/bits/types.h \ - /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ - /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ - /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ - /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ - /usr/include/x86_64-linux-gnu/bits/typesizes.h \ - /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ - /usr/include/x86_64-linux-gnu/bits/wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ - /usr/include/x86_64-linux-gnu/bits/wordsize.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ - /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ - /usr/include/x86_64-linux-gnu/gnu/stubs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ - /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ - /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ - /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ - /usr/include/x86_64-linux-gnu/sys/cdefs.h \ - /usr/include/x86_64-linux-gnu/sys/syscall.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ - /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ - /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ - /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ - /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ - /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ - /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ - /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ - /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ - /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ CMakeFiles/3.31.6/CMakeSystem.cmake \ TanksGame_autogen/moc_predefs.h \ @@ -5017,9 +1373,12 @@ TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLi CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ CMakeFiles/3.31.6/CMakeSystem.cmake \ TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ @@ -5364,6 +1723,7 @@ TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLi /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ @@ -11169,10 +7529,10 @@ CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: /usr/include/time.h: -/usr/include/c++/14/bits/streambuf.tcc: - /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h: +/usr/include/c++/14/bits/streambuf.tcc: + /usr/include/x86_64-linux-gnu/bits/getopt_core.h: /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h: @@ -11269,12 +7629,6 @@ CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o: /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h: -/home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h: - -/usr/include/asm-generic/bitsperlong.h: - -/usr/include/c++/14/cwctype: - /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake: /lib/x86_64-linux-gnu/libatomic.so.1: @@ -11335,11 +7689,11 @@ TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp: /usr/include/c++/14/cstdio: -/usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h: +/home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h: -/usr/include/c++/14/bits/invoke.h: +/usr/include/c++/14/bits/uses_allocator_args.h: -/usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake: +/usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h: /usr/include/c++/14/bits/move_only_function.h: @@ -11377,13 +7731,11 @@ TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp: /usr/include/x86_64-linux-gnu/bits/long-double.h: -/usr/include/c++/14/bits/charconv.h: - -/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QApplication: +/usr/include/c++/14/tr1/ell_integral.tcc: -/usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h: +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem: -/usr/include/linux/limits.h: +/usr/include/c++/14/bits/charconv.h: /usr/include/c++/14/bits/atomic_base.h: @@ -11423,18 +7775,6 @@ TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp: /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake: -/usr/include/c++/14/bits/allocator.h: - -/home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h: - -/usr/include/pthread.h: - -/usr/include/c++/14/bits/functexcept.h: - -CMakeFiles/3.31.6/CMakeSystem.cmake: - -/usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake: - /usr/include/c++/14/text_encoding: /usr/include/c++/14/bits/locale_facets.tcc: @@ -11475,15 +7815,23 @@ CMakeFiles/3.31.6/CMakeSystem.cmake: /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp: -/usr/include/stdc-predef.h: +/usr/include/c++/14/bits/allocator.h: -/usr/include/asm-generic/posix_types.h: +/home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h: -/usr/include/asm-generic/int-ll64.h: +/usr/include/pthread.h: -/usr/include/c++/14/ios: +/usr/include/c++/14/bits/functexcept.h: -/usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h: +CMakeFiles/3.31.6/CMakeSystem.cmake: + +/usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake: + +/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QApplication: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h: + +/usr/include/linux/limits.h: /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp: @@ -11543,6 +7891,16 @@ CMakeFiles/3.31.6/CMakeCXXCompiler.cmake: /usr/include/x86_64-linux-gnu/c++/14/bits/messages_members.h: +/usr/include/stdc-predef.h: + +/usr/include/asm-generic/posix_types.h: + +/usr/include/asm-generic/int-ll64.h: + +/usr/include/c++/14/ios: + +/usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h: + /usr/include/c++/14/bits/alloc_traits.h: /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h: @@ -11591,6 +7949,12 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: /usr/include/c++/14/array: +/usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h: + +/usr/include/c++/14/bits/invoke.h: + +/usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake: + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h: /usr/include/linux/posix_types.h: @@ -11617,10 +7981,6 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h: -/usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsEllipseItem: - -/usr/include/c++/14/tr1/ell_integral.tcc: - /usr/include/c++/14/bits/localefwd.h: /usr/include/c++/14/bits/exception_ptr.h: @@ -11817,12 +8177,6 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: /usr/include/c++/14/tr1/beta_function.tcc: -/home/frankyshelloy/CLionProjects/TankiGame/include/LightEnemy.h: - -/usr/include/c++/14/bits/uses_allocator_args.h: - -/usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h: - /usr/include/c++/14/iosfwd: /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h: @@ -12191,6 +8545,16 @@ TanksGame_autogen/moc_predefs.h: /usr/share/cmake-3.31/Modules/Platform/Linux.cmake: +/home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h: + +/usr/include/asm-generic/bitsperlong.h: + +/usr/include/c++/14/cwctype: + +/home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h: + +/usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap: + /usr/include/c++/14/ext/aligned_buffer.h: /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h: @@ -12279,8 +8643,6 @@ TanksGame_autogen/mocs_compilation.cpp: /usr/include/x86_64-linux-gnu/qt5/QtGui/QBrush: -/home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h: - /usr/include/x86_64-linux-gnu/qt5/QtGui/QPainter: /usr/include/x86_64-linux-gnu/qt5/QtGui/qfontinfo.h: @@ -12289,8 +8651,6 @@ TanksGame_autogen/mocs_compilation.cpp: /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainter.h: -/usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap: - /usr/include/c++/14/bits/random.h: /usr/include/c++/14/tr1/bessel_function.tcc: diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/Bonus.cpp.o index cd491e804a1185ac68b644fec1f259ebd75fcc3a..ee1cb75e9e6e3f7edc8481d037196177f5cab6e7 100644 GIT binary patch delta 4313 zcmeH~|4-G|8OJ~8Zm7l2wL@qQcY+a0D^skcT579&Q&PSZS52y=Eq4XmPW;w{W^12gC;H`&`ow7o9~a>GCJ-$|qd(C6tm@X!=_h?L|B3 z4NZeCDsYAL)s=STE*GuGEa|YOAs1bagy*HNDcR0F<)XvbPP*h5HtluM-=LcG8%@u+ z=tf*1y|~KGJ?o;+V4AdTwN1~t=t4xjAboWyHXU%$K4g<#*YtNT`cIUTE?Z;gUU1P2 zgh+p_>5z-IV1o1$O@HsAUWkp-SN4=$`4bnth}4a8UBp_Oe(IvHYyTfy{)=l3qz*nN zzCbB!|A|qCu|VIM`#=7HcG7<<8hPKXttHsLNs1&(=dXL(FcOWpxtR6Z%6Wi)hw{hI z#g}XAJyo;A(!M^%EHxgRi+NjL>Q7P4b-z|I3sMau!AP5n$$=qWL-5MrQfR1Y_aWl52)bcxbOmA;{L0?J8?m9A6zYo-6CbTUM?6x)>MqeuHMN-skx?P8?^N{^vE zJ6BZT3jM=M|J~A9u{l=kM8ak%jw}6VrQ=aePm$8cl)kQXG^XkIE8TBt-_%Cyv++ID zBixr+L~Y^MxXGe?A6#^)^7H=c5$;IR1LD)@PcSmV;dA}XQ}H}idW2W^EC2fY=O?_t zdk;uxz{D0Aag1~Yu0%(RUWgp&`-<}fg@tkeVZ({Z7%WIl3flrCV8B!ZTx` zwieU>GgbZaP6;F^P+vxCl@c5vEpgCn2Q5Od zR(hR#C_#Iz#LZfB-p&G!oVReVHrKb+Q87YaW~&?Tz<*d`|UVE)wyouJs^LMe= zK}&Fnw8&BMLkBIyZPJ|%dTJhxuan{}JX>e==}?{Y?r}txVWLiAxXzr{pIZH9*!`KR zo4>P54q60n{rvt+LhxJ7tDoPWmI|kaMIEG8?+&)av-lMu$WOY%zi}+?~_Yeo! zks@~VIQ;DBhd9KJKJ4K94(?VRe8DFYrZ^L{f5&QyxaxO%2a ze2@ITDo@}j#``M881m0ni95J@w#w5D6ntDMuH)**RUYF56r8K{RCHkc+$b}f`akn5 z3ZP(M)Uz#s$n&F~KwxP6e1;H%cw{iwTfzT;tx-sM5&pr|kvDUc!+0_s#|G1^#RpgZ E7x^fgzyJUM delta 4264 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 literal 304112 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 delta 2008 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

Kt=1UDt3NbbVqw^d{&RyJK{%Pwa(08M@bd zV{aH7Ip}`t6H(Mz6RZAQYQ`xJ{e9?O&;Cj1yP#JaCo>Ld=#kgE^WCCHKwod3D|P$Y=S$C(5g_xOqhC2h3{9wW z8*)FrVweJbDs-0+-M)Tzno1^y`ce2hSJbI?Z7}*M=v~lZ@s(qgoGPQYLVp1|rd?Tg z{asr-^exa4N?CW^hdZJFt55%1pugv%?}EMq`sdy4yZ)}~0QBw9y~fyl_p9l@+FY$i zo8~)V--eFI!*cwt=VS9-vF}6ox<8ojklpRmekXLZe_rixf&P(C`@5hQecC?&{X?Jj z>v19Z)TjMX&<{Yr$G!gn`v9BqX@!36Xz%fBhkiNqlil09e5p?8mqACEK=KokAPm z_30x6{hxgF9P};FaeFJb@A})x0`wiwz2=}5!#W1^aqjJL4z^=2B482db(hk8%f3!r zr`L&Q)ESRDC!@Zzk8&I%K#e$n}C|1lw*hu|R(cpPhX%ZLBJ{VZNU^cv?@ebvoN3eYp^y8qoeMwO75MUl-4Efj zv!7;8Np7#%mm#Rrjyjme||?UxsJEvEFmD3Hrm( zz2cYxeI<0fW|#M4Zu$IN4E;Hu_SZpw6uQ^E+YCMJ)BaBAU-M~yKlCSk+Be^4zSgIG z^F8M;`?Nm=`ZGT5FNWR;-D~{TL4V3e-wb^n^!4uX4Lsw_wVlvUzQX(2Za?%v(7pQa zkHxJsee@>ir$hI8Hk<;zKlIPJ<8ygIi=iLsv3&&Ftb_g;_U|tD_GXT{e6cO4Gr=du zUC>*gdp+MCfPS6N_Vr`&{N|&Nf_@EjuQ6zaJ_fqi7_>vbz+-ze2A$B)g6=m4In-%K z9k1h9fWE{>w{RO?4BhLwAp$)O-RnLXgZ>nBujhsY^sUfubstB1ZsZ^p@dC;#!#uXXof=8B#ATY9G0gF54U`l!PWjQ8oI0eY)XA100#)LD%>_q*e; z_qFsyYOc>o)cF{7yyj#Y`k$eD9nUQEKl$i+=$}Gwb;saZXDUJ;I^KKEhVhslf$nwP zjY2=gXZtwxV|?@^^dNMv{Yyg+`1GF@{RH>^xpMvT&<|k$z0S!Z^iO=oFAP(4FZA2o z?Fa0I2Xp+Q(9cJF701|>qaKI8)^GozukhKwwCG;@mxaE}r~N$ih0wjmw+MYcbg%sj zUy1iE=wAC5g0dtEcL(0>EH+VPE`={)p*h3pprT^fYv@b7Yd}UdM1D^p!qium*ZNbgyH$3HlP~M`M4TXGB*n;11}s zecIm#{RSVs9~K`c__W^${UV?3CqX~QM_&ki0CcZ8xCZ*|(7op1Cg|ItpY7g%*ZSrT z=T& zp;w#ZCcaJ3=Ru$1-rn^$jXR*P_s}EQW*_tqpjX_J&Hd7q@7n)r9HR-|`L0dSFNR(% zM$^X>=uzl?eYB&_LZ3c5p{G6iFypWV`ZDM<@Yy*JWG9Ti3;I^*4^-&oyy*kb&$!C_ zeXf2Y{?r=Ofe4Zs>XF=isx`hOEFY?OUO@_-x+}eVWhqozOQg^!`q*Ezn zUiZ2L^cSF?;ojcm8>VD?uWNY*`s>*KIQRBfmgi&+x{1&0UR)5p!M(jJN5`6s>nXO! zR4DIXz0fo%@yS7d(`Wkv^qoH2Ti4+lhxok4FCzMBrhlCuuJ22TL4OVH;}TMi z&)iEcvyV{(cqZz6aELl9P^TBpWxsYdqRt4PI%d4{sAJ9Kn}4cBQ$FTG#ZZZ^S`_8)cTPQkx7;I32q zP$^cU7oqREzWTF=*%x!ZY={0p0Q>U2VdZ|zJ!e6n6pU%7>3W>^3%svAQ=o@h4|@8; zi=i*U_CwK@voEf{BV7l5#|^R`tMfjv%;|qK^b393-wAy%^oLCQRkq&`{ZXIo`%gvg zrqA|G(0}W*{S@f$`E0)!`iA-5YxnD*e+s?7dwlG#ttef0H$(pzdbN2T!8RK(&y9XQ zJ_k=bw>-vnN=d1W18CzQ>I`!CVcQ2Kz5WK=KXHt_-a|$~?*ZNG+TIGix5qIybFCfv z3D7&-{pV5`0T z-A32*Qsa<08G&T}Ew>ns>HY3{<{WpO!*SGk8g;y4NkU%<-7A)~Y=5X&HlyChhlpht z>RfiCcPs~>H$wM{rT#{H`$NUjjCyO(j^DVnq0S$CVp#$G1D{wn$o7Yd#r!*X7f_dsMB=kLC^1QGj+_r1O6=P+>Xz|-{R>+=S9GN(X0m_H4XJpr!;=5Oa8EFqZRt! zpbvImi_LYkzWnT-LLCcp8_RO8J}z;ta~bI7-vg~S_aoRO2mL1)Hyq0H+_u*o&Uz=&HtP5ecjL(xOJNUrkx?Em&NtsWK&P~SA1@xw?H3>c1|$5o`<4G zfaXGPgudRboAalXaf4?qaP#j9zK%M6`(ysi!B0@fYk$nYMYtdOq4wth>NVfw9dCUC za|ya%yfM_tp^jg?Gf`(h>UhQ50X>j7bi5l;ZvyIhjqi5oW1;)STST3=QO7Ude$x@p zbnkc@q4$P~2 zZkvDKauM_g@Hu!Ij)2ZvGw)n~zgvezggojU=WfUKp3wmPE$CkF0b`+?e;?TEUB3C>yf+8^s?Uj zW~|3RKhLeZ);oqkUkSb1_0AlN7U-SOuX1l6uy?}fbD?jC?sffG1$~dl`DnJ^2>nCo zeN6j$eQ~|-Zik-t(9K-f3;j*#cUEj~f4^(M^?iN)X2OrcIa2MuXyRyu-XHpj?si-` z5tE?zgI;ako9!1u?*rXyKh{7u|3-N=eIT~q1pVXxiT&7xdc%G8;{fz#pZ%!61lH$N$6h3V>k4<(7ldFa2E3Pp;sGk zbG!yZpX8yN{b+_h8v3F3V=n4FjCx-Cu?l)8bg%u`2>qpb)vqBYj!w+)4D?s=Ie7W$ zmDjrG%jfw%w9{}$^)-nIw(W;S+hx$_;&a9IQvTlDj7byfyp1|u*ODpFcR7doBPQxEA$=C_UoW`;96PjxzCK>X6O&&8K>Hu zjX>WC{hmWSM;$<&*HFjnyr`dzYpzcpqo6-^h&~di^R7=HDd^jM`p7_k;}CspMV(K5 z`q&M9uTLMrIq-`P(MJR7^u;yTYpljX{|NJaPsQ;p{~Hr+&|ksv#?rQHKG+Eg=6J4v z{sDBa-xd-|h=$E*+x2>Sk zJ5n7kcCSPCdiH66Zk}DLU9Tc&vp?q87U&n(U>tvWO8FSno>zL=Gh;XxZM=u~r_y~w zV+`0q8hsV?29I|=qi=+6)=SWOxqa7j$9Cw)L-(2^d!c{cNAHc7-Q#@pA<+9l|Gc|@ z`Fny0nE5xk&3exh_#E7WD4cy<ABOIA zp5&!{uj5>V{+!SD;d!`jL$CIn9zp+6=qA3jJ3jNAZ7)rh=F%k8*@rq_$6+D#Pkmxo z1ARAiuerDh`rmxE-vNCubgwbo2mKE|+xNS}vVP^EH((&91lqcGk@xXRK_3hKBKLT@{SWB3_-vnpJ_R~X?{XZHuM+_(K<|R?_g)lCVqV|v zJtqf3KN=rX6PfK2XDa>rk|Dy{~mm&^JKe=WgGQaks|U ziaLwiy~m*)`W)!3?lxSxdY#bM`)t1j`a0;`yuZ5I&L0buNlMWBCLU}^gdQ`=&wP?+jqIWR(t=k3oOP^rK_x@<(?fDPuUdLz!^f}PI#$|(Sf2dgUsQ0!{ zEao`wL!Hwf_4h#fFTvl&p-$;NMb9sJo-*fg6ZBi5<8&^ce>7*z+)SX}Yp8dEyPnGv zOF`cVeZ5;ZbIRq3b)nAC$Nb~nhB~uQ$1C1F(38*)6>s=nyvL&63GR4Y@kXJ)4&5)_ zNvPBGxPQEhQ74HyUh%Gjz6AQA;?1GnTd3z1ZvlD^x?jA(c3g|r_{ZCTI!jQ;E8elt zJD?vb-X!YfQO_&hH1xNjd&OIil6}w{J#;g-``w2e zDCl^s_|J3O<&%s;z1vW)+Bs|DXocPm{X};=uJwv`=!>CO8w<02C-nKyz4l`Z^n{0Q z_G1_H3D6I|Z*^e&hOQ0WW zKenUZ4^Yo*KlVc30o`jqdgEr2hwil>L!iG6-D^Kupl|lj&3?>p7 z_G1%tYpwTw?127vk2oUObRYEJL2t!p=h=yJCidf%z!+HScsZSpf=;IF2M>Fay^XX$I^w*x0_?=v$$mW8p`2$xp8b>Vm%V>FV!kW?rqqyxxTESKxCn(7W7*xsS@fac1gmLA`$K zSo;%*H={tsst952|--(0O0&L|jV{m)CLF0(}*9ul?EueaA-c-0TC; z2Y*AZM|zxPJ>JB*7jd?t{ah{L{C2PMd@^}a{-W|iOR z=62v60{xwgZJc>7&sJuhuYzvk8Q|7kp5{i`zOP%C`?`sv6LFl3?cXqQjHfuhUXEiQ z+R47^J+A$}i0@l~UTs`WKfz^qkB7dt2A>12e#|@U3VU56f_klJC-zPMeB~7C?0&6! zUW*x%4D|Osbkj!;dLH^a`0R|SIq!4!JGa5z-8In*Ly$xNP;1=~`Y>SKZ$5R_gi^KE z_L@uZ`N=@&*;?z>KrehQ)S_2qpS~uSL5^6Q0UX6tS|Lw#^(=ugjV;lzS{GH8vL^6h|o)YthbJM zEQnva!lsMvnu~vE`ucfoDBIh5B6u;DtAnB6^tL)fui_AXsV?-?QPz&Sk$CGoBJ}Q2 z)|0)?#)bCC(8@m6PmcUEYM_ON2WwJ@?ae^wlc4oS^RMQ*3XWyBM1-wIU0JQ_RNoJt;d5ld!}X(KHM7m@F**9_Wj># zLQnUxR+`4Y5(xdIkM+aAAbdk+Z3uV2|EO)Tte*x$n~%1-&E_wMLU_k}BNY1hXlq{x z)xO;$^j6sVagWe9!&YZc)Y#H9wB{J=$2~*cVQY1rnL}?L5&Fe3*1Jc9-a5wmYA;mz zL9fu)`&#ez3a#mDJ#pl#sPcaA*f088Yy12)SlW~S_ai)WI`-r1HKBj5wKms;vbEOV zYtF#F2STfY){g_Bzt&oh)o!#8%YUWnoDVPnKM#do>}5UMqZxk+-Xm1#Wo_>HGc@(w z5wWivY5k%XR!DKM|11CX8Gv9Hhw$%J|Ii$7Y<=`plrPtWcGg&{%yBo!{BxCr{&THT zQ`1BE^MkB3MZ}zsPoG;eXe?U2IrNp9nuYlANKNQJYHEH|6MCn{+Gn==dLZ;lz}jKD z#-3Gf(^XS*KlsBnp^iY!j+)TVv9D&EZwEqK0@jEBo7-SVhoCV;^k$9qf$W2c`MjFJ zBO%-udM;4&UQOtOK+OT8z7{z4hXL#7rq_+N$9}KY`WJKN*+G}${y)5(`^Z0iyxEy0 zHJE|_RAc?rgsXu$Gvw)0YmSdXXbU}2Q?uGs*-&$AW$jYk|G9c6&Oig3YED=euy)pj zmIo}15kCL386Grq>_zZvc5Gx1@0 z&FoabT#8Gm;r!vaSJd<`hOE~R1O7qdb-~bEA?xK}=$j#HcW@xcGd=9OJY4uT&DsY- z*4x3*-k|l0D{9kMslO`c0;JxD93r#v|Kc#=T>IY|CljAJWH*Lp;%xn|kJ107ZAV=E zr@*E<>$|m~LQm_DwIO`&zy#@OeLwhu5kBn^T3Kgx^)$k_dxoB?vwl@)@7*B|*3ipP z?SYyRsh-w*HT{3z16Rur1Ml^)R)j*|>tUwf#vay=(3v1vbAQJ0^%;dn)On!|LF-Gw zNhNaPC@6Of|14;Iuckj{_{W%O{}Qxbk|}enkyAD1Sz>3+gslPVL30trt;!1HKQp;6 zpKvYyZ&`Shws4-5evF>Le@jm|`1Y9QtE_tmEW9Uq%YcysX5KPmz>ooVEWpRRX52Mz z;a&J`-t^mzbnD#NGj7JOi*A{}VD=sJK!y!%JooGocD-|l4udv*{>^Q(7v6I7!n@|1 zO{U*Ib423+tOXtZIXnV~N8s=X93FwgBXD>G4v)a$5jZ>ohezP>2pk@P!z1wDH3Er8 z?3N=^YCo~4{T7@UW|wnF*Lq%M=3;q^{(@bOdBUrv&EqS~n>TV)q+VXihPAf7_N#W8 z?6S-M+yCFN&5oe%?f;%g+GIT5e#~zFxX0~so|J!)acOw+|DXOh$Z_J={(QTu$~`G`IKy-Hu;MU5W*)fs_i87BoRWc)_TxXnF0emXQ&%O0!kd8T4U z#;;Sx?VZEpr$bY<+_tK6{5H$@Rjqs&9&!Xyx7gQF9>=r?&v@`xgmZ_nJ1ei#Df&G} zzgzPw>*pS~ug|?|Y(7d#?&t9D_6V%`rG0+vl5z+9Wb^Z}lh@Nb{X3rz8@^&6hjsO~{q*LuUj+fu#58B7G^tU!(b;3)3PlC@=L^nCk z=128EAMC!v{BCm2%@5LONyw`c%6_Hht-*zm&&HsfBEYWO4hG zj$T$8>L(R@N-5o14R_f;1jk-aj0d5;`cqCy?cA ze!As%-Or-@{zj9n|A+jJKM($I`N_$7$c;x+Hi=0Ymogz`Qp%K+X(=;OW~IzYnU}I4 zWl>7=_c-P!ET#GT8}k#DGA3nQ%7m0jDN|CWrOZf~l`~~dQbweVN*R+fE@eW>q?9Qs(^6)n%u1P)GB0I8%A%Ck7o~qGBT`1C zj7b@nG9hJB%9NC8DKk=LrOZj0m$D#bQA+DU>0io-lu;>TQpTlBNSTx}C1qO5jFed^ zb5iD|EJ#_D(kgu+0Or4x5hBvaKwWX}Y$hnO}hYgLM zeeMNz_TjKWLaJ_Q!x|JwIqv2v=DJy99cQ)NZTB0I3dp&yTHjn(1J==2cC}QLA|kv% z967?J`s_np0bXOBY(->$O?>9(TKrdI9q-(yN)Z2R$A6|@^|h3*z=s;Ezoqv*@e75=h~FeUPJEg01o8F4 zlf-{4JVkt;@HFv$m@uXBCw`&uEb&(1IpX&T&l7)6c!79Mc#-(;g5DLhGhhwv2f{}7%g9>I%T>H0%FCOk|07U4PK zUlg7vzFv5N_&dUj#6J;kT~ImxeeptU;tUf%Pk4m*RN+zL?ZRWkpAjA>{-*E*@ehS3 ziTB2fx`{JI{9NH_;!}lZh~FX^{DrQGvq*fbaBF1c_}?x( zO#Ct75#nzMj}qT4JVyMeqwRR&#G8aCh~F$cNqn{N6!F)Er-{EOJVX5N!n4Hd@jzn6 zEl2zd!t=zZ3oj5~ExbtlTf(giE64u>;bG!E@u+0ti4Y$qJW70;@EGw`!sEm@3r`T= zEj&s5D12!^Y5o%*COl32I^h}O_X^Jv|ElmD@gE4!6aPqffp|~6@Ra61@gc&kQI+FA zL3o(>0^t$jPY90^|E};D@!i7X#QXHK<4h255}qV}lkgPr4&iCyUBWZOw+hb^-z_{x z{75VSn(@pNKU;W#c#H5N@jHcE7gdh`TH#^hZwikPF9?qk?|GaZXN>q+!sEoR5}qJ_ zr|=~4$Azbezb-sY{1?JA#4Rj{n(@pMKV5i^_+`TL#BUc~ApV%}BJpnuwf7YdINzfpLc_)_5s;?D_B5`Rm0iufMkY2sllq?Z0D-xA(Ve5dgHh+6~f_LmYLF8qGtQ-r68FBAR%@mGZ}Bfd-ca^gpvX2;V( ze1z~X62DpagT&LqA0qxw!dDRgSooKSA3xBJXC?7Fgg;FDS>daQ=Y@Zn_=wZ(_E!^s zUic%#^TN}_&p5+w=TYLTgg-|7ufiWEe$AP7J8Ot<7ybnCaSe9;wZzv8f0FnqgY5e2 zh(9CzE5vicpCZ0T_|wFX9BjAWNqo5QXNXT0{w(pO!k;7FB|Jm?r^25ne)?H&k}!Mc#inrh3ARu`hS7AuKyQ_>-xWS2^z$Yj=!$|hl%U@e}uTM|3``I z`hSeLuK&l0>-v9!xUT;viR=1*iny--r-|$Oe}=fO|7VHo`hSkNuK(wW>-v9zxUT;f ziR=2mHM(;Ab^Sj~T-X02#C82YN?h0fW5jj+KTcfN{}aS@{Xa=u*Z)(*b^Sk0T-X0I z#C82YOI+9gbHsK1KTllO{|m%*{l7?D*Z-|cE5~2g|HH&}{Xarn*Z-r$b^Sj^T-X2O z#C82YL0s4Wlf-rXKSf;E|I@^E{Xauo*Z;G`b^Sj_T-X2e#C83@KwQ`Vi^O&P-)gQL ze_j6%6W8_s2ytEij}q7Q{}^#y|Bn;b_5TEMUH?xK*Y*Dtab5pU6W8_s3~^om&l1=5 z{~U2$|IZWG_5T8KUH>l<*Y$tvvdZz-_5Uz&UH^{|*Y*D>ab5q95!dzqIB{M7PY~Dj z|0Ho;|4$Lu_5U<+UH{Jz*Y*D_ab5q<5!dzqJaJwBFA&%D{~~c+|F_HohU@;T>;GZm zy8a&_uIv9%;=2AHBd+WJapJoEpCGR5|4HJy{+}YQ>;Gxuy8fRbuIv9<;=2ByBd+WJ zdE&bMUm&jQ|3%`u{%>7gIsUr-A11Er{}JN4{vRc->;Ez0y8a(0uIv8^;=2ByB(CfK zDdM{RpC+#B{~6-C{+}hT>;F08y8fRhuIv8=;=2A{B(CfK*4WDN*Y*D}ab5q95ZCqp zC~;l?j}h1P|2T17|4$It_5UPsUH?xJ*Y*E2ab5q<5ZCqpEOA}`&k@)4|2%PB|1S{N z_5UJqUH`YPs2qP?{|^(__5TQQUH^{~*Y*Dxab5q96W8_s1aV#ePZHPl{}gdu|4$Rw z_5TcUUH{J#*Y*D#ab5q<6W8_s0&!jcFA~@Fe`{Rj`0M(An7FS0M~LhCf0Vec|Hp{` z4_P0G3)lDkkAzPmzF+th;yuo`-*a1ue@=LUctrS2;^zu)BYv6ixx{Z2o+Q3V_(I|x z!WR=?BfOn>m+%zvO~N~fZxg#kb;K_b-kbQxcZp0iK~w}hq(Hfw-Hw#b1rf9F>fcXKIS~)>SNwP+!|oVpCqn6=AFdV z$DB`mnY6QjxcZn2iK~x!7jgA57ZFz<^KRnmV=gAHKIT2d)yG^yTz$-YiK~y3! zh^vp8C$2tbfw=mZMdIpXS}m3DgX&|3iK~wpAwCG38~-s%+$?_?9wRSJb!tB;u@u0Cd-xcZm{;_71-iK~xkU0FH)>SKn9tB)BW zu0CdzxcZne;_73@iK~y9Ag(@UlDPVqDdOs5rirVMnIWz|W|p}6m^tF=W9Esgk69qD zK4y`)`k2;)%JEkpGfZ54%m{JyF{8xQ$BYqIA2Uu|ear-L^)Zvg)yGT`S06J?Tz$+8 zarH5?#MQ^l5mz5GPh5S>0&(>*i^SE(w63ZgfAulL#MQ@)5LX{FN?d)+7;*J6SM-SJb!tB;u@u0Cd-xcZm{;_71-iK~xkO{^S$^)bW5)yIqwS06J0&(>*i^SE(v?f)KzxtSA;_72Yh^vnoC9XbZjJW!kapLM@CWxz#nIx`0W{SA_ zm}%nbV`hk}kC`Q|K4y-%`j~m*>SGp&tB+YEu0E!9ZRPl@j~OPeK4yft`j}DT>SM-; ztB)Bcu0CdhxcZn$;_73jh^vp8CaykahPe8eS>ozr=7_70nJ2D3W`Vf+m__31V_K6d z$6tNSFmd%UBf|B4UwzDh#MQ@aAg(^<5aQ}%Mv1GB*+^V{%qHUMV~!%OK4y%#`k2kc z)yEu5Tz$+I;_73@iK~w}iMaZhQ;4gN*-Bh}%mi`uF=rB2AG3|P`j~TxtB;u^u0G~M z;_72ACaykaJ8|_fQ^eKB>>#c_<_hBKW3D2uK4zM@`j~5otB<*kxcZo##MQ^l5LX|w zi@5rj8;GlqxskZ~m|5cLV{R6%KArlQIpXSLZliY8$J|a_eat*@^)Yu4S08gHarH5G z5mz6xKwN#y-Ne<$+(TS_%)P|b$1Doh@lhXhKXLUjt?TUTo?ge)#|#qRU-CCkwi@Jn zrL=zEbItnR$yQXj_Ion8`Ch5cH|&K>*z2XA4&j%7YX9COeE2ZCelBMNt-ntA{ZxO< zaJ&BG-`e%fdaL<)UHH&F_V3EiYP9S3_+2G`M)(K9e{RdxuZ3^^*apf^KhJLGvESQ# zy40U5e4p^e!v8_|w|0sOD7}9e_+Wg5s+x4`aKMP+kT-&+(Lc9J?g=;(0M%kSE{gv=V zf3@4kVJ-cvyU4E3?VoV5%{Nee_0#L8*z=bC^pl9IpMElN_0vxwu6}xixccd*5?4Qc z0CDxxPb02=`at69r=Lz-{q!@4tDk-*arM(1h^wDIh`9RcgNdu3eim`{(}xgOKmBat z>ZcDSu73JC#MMua5?4R{T;l4d4Zgw&u73LY#MMu4BCdY= z1;o`)A4y#O^b3jSab6fdWfbuqU$FT_#IF*5G4Ykczd(Ga@EGxM%x?b@;_B~@Ca(Ve zrNq_WZzg_E#BTpG;_B~@A^x7!znr-G`(uf#zkdaB_4mgSSATyzarO6Ghz}oN$A2Yp z_4g+bSAYL1;;%|OapLOlUrk*7{fWfY-@k^q`umfJtG|COarO5n6IXx#I^yc@Pa&@U z{`JJw-=9ic{rww=tH0k$T>bqUiL1Xqjkx;zHxXBVKS5mm{prNj-=9HT{r#JXtG_>! zxcd9I5LbVH7IF3WZzZn&ej9Q1_h%DVe}4{f_4jWhuKxa9;_C0;PF(%{dBoMbrp#Bad$&ClPDU0?Z}ywkGJ_h#byd@@!zKc8GdT%S+I z5!dIF@x=A{q=mRXpIk{?pHC(b*XNU~i0ku7oVY%pTuoe`PbL!A=aXxQ>+{JZ;`)4Y zEpdH5nM_=tPp%`b&nHue>+{L=#P#`PDsg>2xq-MopR^L!=aU+{Jp;`)4Y6LEb$ zNf6iPlj+3u`D6xheLlIFxZba464(3nEyVSHJ&U;BuWu!;_v<#|dcU4cT<_O&i0l3O zHsX4}o=aTs*S8bb`}I8HdcVGd_!PPSCW-6)`cC3{zn)KA@7D{6>-~BmalK#PMO^RK zi-_y}`flQSzg|pS@7MPb*ZcJn;(EWnm$=@q+llM_`aa@%zg|jQ@7MPe*ZXyfxZbZH zAg=f8WyJMzQACI_`k0)H;_nmw^;!ZvuaVH;-xRZ}Z+{woy?&RYU zck=OwJNbCToqRmvPCg!SCm)ZvlaEK-$;Tt^`PpI#?KK~pRpft^%;*Pu0G>&#MNi~ zJaP3I`x956@p$6uGoC8V}!W+jHeP;pK$BKb;>I~wV2X!WK^)VZWtB*N|xcZobiK~x!7IF14hY(jE^K9bk zV-6**KIS>Z)yIqyS0D3S;?@9roqrf{^)ZJNpCa`ei7yj=9&zu)yIqxS0D2d;_73LCayl_rNq_8 zY$mQg=4Hgy#~edkeay>=tB*OBxcZn^5LX{_9C7tA#}ii{vxT_&m{$^4A9Dh6^)as^ zu0Cd*xcZn^6IUN|B60OGuOY5J<|N|kV_r*Keay+k)yKS!xcZn=h^vozJ#qChrxHIs z>7RF$lluBRpg!hS;_72=Bd$JXUbwC&==X{gh^voTB(6TDH7iiDE}=eVn7I0w5#s7& zMv1GB86&PfW}NsKgkgNo1ab2^Z+MdUQsF7$&j?Qw|Bmns@%M#iiT_=Aj=1`mdE)A0 z7Kp2lStPDLrgbYia;*!gj~OPeK4yft`j}DT>SM-;tB)Bcu0CdhxcZn$;_73jh^vp8 zCaykahPe8eS>ozr=7_70nJ2D3W`Vf+m__31V_I#MSJb!tB;u@u0Cd-xcZm{;_71-iK~xk&8{4O z^)bW5)yIqwS06JDW5$T9j~OSfK4yZr`j|=L>SLye ztB;u`u0CdlxcZn`;_74Oh^vp8C$2tbfw=mZMdIpXTDMh>zxtSA;_72Yh^vnoC9XbZ zjJW!kapLM@CWxz#nIx`0W{SA_m}%nbV`hk}kC`Q|K4y-%`j~m*>SGp&tB+YEu0EzU zw{rZ|#|#r!A2UK+eat9v^)X|_)yIqzS06J$Tz$+WarH4%#MQ@46IUNILtK5#EOGTQ zbHvrh%oA51vp`&Z%p!61F|FGx$6tNSFmd%UBgECmj1pHLGe%r}%s6rNF%!hq$4nAe zA2UTdS06J+Tz$+uarH3^#MQ?v5?3G7npZjg>SKn9tB)BWu0Cdz zxcZne;_73@iK~y9Ag(@UlDPVqDdOs5rirVMnIWz|W|p}6m^tF=W9Esgk69qDK4y`) z`k2-omE*5IW|+A8m=WUYV@8Rqj~OGbK4zS_`j`pg>SHE}tB;u?u0Cd(xcZnG;_72& ziK~y9Bd$JXp1As$1>)*s7Ky8mX(cPiUwzClarH4H#MQ@)5?3EHCS2e5)yHfmu0G~i z;_73z5LX{FPF#J=NyOF1oI+fE%vR#+V&=V+li}>nIf(}W(RTgF;@^*A9EFP^)b`L)yG^zTz$-S#MQ^_B(6SYhPe8eUBuPL z+(2A?%#Fm=$IKE}A9E9N^)WXSS08f=arH5C#MQ^#N?d)+ZN$~b+)iA5%sg@RF?R}A zpH6+u0&(>*_fR|PW9}ucK4y`)`k4EOtB<*#xcZm}h^voj-DzK!^tz!wW{|l0n03U} z$Lvj9eax_M9Ut{E`x93mGeYgCk2#R|f|&h14+qn>gNd)FDE+)Byy;P!<7+5NKf8p_ z7q0b>xx{W~Bh?=RZoZ!+Cf`reB<&~@9|{}#CUUXhPvJg<^* z>p#ZkS3hHqn0`;leBlY<4@v#+2OmIJdK3_o~ie&plV!{5U%aljJNA^JGX$F zdApdtSLacw&*S{Q@UKhzN6Yw+Yq8tkEF53IQ~JpX|DEu=g`ah$T|berQBp^KGqg?RT4SJ}!OZcKu^tu-nmomkS># zT>Jf-@N0!@zq78k+u1H$`~65bAFt>{yZ-pER`&b6@TtPJ-~QLw^&b|l{dNcsbXAUX zaFSjB0pYDO{*QngU!#%E)1AW4BR=R_yPaQ3JAG^--hr^O*28!q*Ew_By-%Ncln_jsJOY6aNT`^Y_BfCw|csyPdVtj>iA8 z@SJdsfB5xw{KZEr<4=H__#0oe_gCY8N%#ce8voF#cKvpVMZyvqZSYvqt#u zg=;)V&9>{;zgij3W5UlDuKj)@{4(KsUfes!Zs!Hz8vhT3Z=rS~x7qdIrgmNten!@g zN89y= zuS=_hr-=Wf@Eq}vgj@3ir88xaoG+S}I7qnNyJhLWcQ%-~<|Up*T=No#5ZAoKvx#e7 z;!xt6mv|0w%}b0D*Sy4YiECcsFyfk*IGniVB{mY*yu|Z}YhL0A;+mIuK5@-UY$C3C zi5C#pyu^{jH81f(;+mH@in!(_UPN5;5-%pMd5K>ju6cM;;%~k zQ;2K6;`PKeUvVmN%~!mExaKRi5>KCI@7ImQHD7TWam`n}iMZw~CWvdk;&kGguQ-Fa z<}2PzT=NxY64!jiTZn7E;w<8tuXrnQ%~xzAuK9|yiEF;%9O9aTcprpe+DQ-}Bs@ucjPMk3%~wnl z*L=kcam`oE64!ji9C6K8%oEpq#R757S1c0Od_`+v<@js9Vwkw*D@KTGzG9TP<}1dC zYrbNfxaKP+h-NHD9qnT=Nx+#5G^hT3k8)ny(lpuK9`);+n4*C9e63G2)u97$>gziV5PHub3pR z`HCsxny;89uK9`?;+n6RC9e63IpUhHm?y6JiUs1DuUI6m`HI#(mE*7ZieciKuNWb& z`HE5Eny(lmuK9{_;+n6RAg=j}N#dHXm?EzEifQ7Sub3gO`HETMny;86uK9|2;+n5m zAg=j}MdF&TXf3H6f6Z466W4sj2yx9NHD9qnT=Nx+#5G^hy03ElHD57IT=Nwp#5G?rN?h|5W5hLIF-~0b z6%)eseP8nxXA;+Z#Wv!auQ->u<|`(NYrf(_;+n6xn7HOEwiDNU#T0SPSL`6J`HCxu zYrf(t;+n6RCa(F4Ylv&U;yU7*uh>ak^A$71HD9rdxaKQvAg=j}8;NVaVwSk(D{dmL z`HGu~Yrf(Z;+n6RBd+<1TZwDF;x^)%uehDK<}2ojYrf(R;+n6xlep$9?jo-FiUs1D zueh7I<}2uj2@Xqkm0{3zFa#X8}7o@%~gZ{nJ-7$&ay ziv5UdzG8pkny*+-T=Nwp#5G@WAaTuCY#^@ribIHNzG76kj)UeaHWAl+#Td1t`HIcN zhhqKHH5LZ(qxpxo3hxj;vZPwp^TOYx`o9pqpXwhA|UqsQp&q+|ECPn|ZsL@)iFg^?96|+wJzx`^1jtXc_;16y7ZST;YxP z+4b)dj$tqTbP3-pT=VxDmfH1~(fHpj{I)+-_WSR`mk8H>XQM$guU;0e{k|`JK+$eT z`@Jb;*XQH%ity*9zV7e92kiP;;o5IT_^*U(zsD@I>reS(Wxs2M^YQwP@PC#1+V2g^ z?RGvAuKoV2@Xvp0x3B$|>9)wH(x2z~m1arK4?6c$1Je;M%Bf{59{T?gq`fmx> z_@4wf*S*OU=SRY?BYx4B>~;qH+3r{4&kAo5uJK>A(vCkv@!tV%;?GHajsH#I?+e%X zFMrsspZZJX`0oTa@lT;R&s=5m>xnM~H~sFCb~OG!3h(h(yM2v+>6h*J(-eOe+_bYq z>TCSn!q*7b_*bm9>yO-D8UOK**l|v!INOBZK>WMlrr)*Fj>bPMZS$OPjsLsgX8xoo z{y$3n#{aP6(fDJJ+U-mbuJQj!_&%!N|1rCMpTF7d=yf|GyqpCj}972!GJ1>x5H_Ir@l@B6&nPE7bvX-D%F z=Lxs>qMWaI2XW0;OcK|8#XE^>zT$l1nyEA#T0SPSA2lD<|{5EuK9|~ ziEF-M2XW0;{33D9SA3AT<|{r#T=NxI5Z8RgFA>*##g)W0U-4n$nyQ+(lQe735s%=wiE48+b)>i7R|L4r}{2=pVcaunf_x;bOW#PNeKIhDtGiT1s z_w0)GidPfIfA94g;yERHzFbQj>l>SiV}0Xw#E0f;p6iKEHGTu}`Nn4xf7|$t#Ie3{ z4)N07TJBB6A2WV4@zus}A&&Kpw-WEyNAurCe2nqA#Ie5dcH&sycn5K;Z@iQE`<6dJ z9P1nJB98TqcN53@#(Riked9dhSl@Urajb8gPaNwT?<0=&jSGlledGPavA%I3ajb8A zfH>ASE+UTgjSmvX`o@QdV}0Yp#Ie4yg*etXK0+Mp8y_W(^^LzEj`fX;iDP}^W5lt( zaS3s(Z~P^3tZ!UO9P1k&Cyw=v%ZOur;}gWOzHvEmtZ#ghIMz2lMI7rJpC*p=jY;BI z-}o!ySl{>zajb8AmiWNCvafH>{43+R#Ie3HL>%iIONe8AV}v-?H%5tLePf(B);Bg0$NI)*;#l99 zAddBoEyS_DF-aWj8&kxwzOj`!);G2h$NENZTCn}GzA=Y5);H!7$NI()ajb7FA&&Kp z5#m_i7$uJNjd9{w-`GSP>l>SiV|`l?jG zgYA#?jXA`zzA=|L);ETTV|`-@ajb8Q5Xbt)C~>TBj1$ND#wOxe-`GqX>l+iqvA(f| zIMz2NiDP|Zia6Fcwi3ts#x~+u-{?&bwm;T4<`BpF#$4i9-xwl}^^GOOvA!`v9P1mS z#Ie3HP8{nSn}}n5V>5BAZ%h!!`o^^FnYSl<{Wj`fXk;#l9%iIn~7t6V}dx=H?|PR`o<)2 ztZz&a$NI)r;#l9%iIONe8AV}v-?H%5tLePf(B);Bg0$NI)*;#l99AddBoEyS_DF-aWj8&kxw zzOj`!);G2h$NENZMzH;{zA=Y5);H!7$NI()ajb7FA&&Kp5#m_i7$uJNjd9{w-`GTa z`ffJ=CqB=3g7^yKEyO=Go+OU-jVa<--`GkV>l@pMV|}A{Ww8CRzA=Y5);H!7$NI() zajb7FA&&Kp5#m_i7$uJNjd9{w-`GSP>l>SiV|`l?k9!S=`c#vI~U-l;JFvA(f{IMz2th+}l;@S$NI+iiDP|ZD{-uE{E#@-H?AR$^^Knp$NI)L;#lAK zIdQCSTuU758^0!w^^M+DdcL6lV0~i`;#l9fJ#nmW+>toeH|7w>`o`UeV|`;U;#l9f zH*u_Q%q5QXjr$SD`o_M*vA*$8;#l7pB98TqMaHpy59=FCh+}=@36uxx8;23c`o;)x ztZy7m9P1m$5Xbt)vxsATW0W}7H&zhG`o>D)Sl?Jp9P1n7#?d}l-#CRh);Bg$9;|Pi zP8>dThH-g3=x_M_mMe+Fht4DpA9@vW_|RFz;X|(`4j+0Aarn?{iNl9B6NeAIjyQbi z^~B*rZy*jII-59r=#9kTL+22O550*veCW-@;X`jB4j+0earn^Nh{K1@B@Q2YJ8}5X zJBY)F-boxjG(j9b^e*D?p?4F9550#teCRyl@S*n-hp(JZ9KP~C;_#IVh{IRjPaM8- zA#wQ12Z+O0E+P(J`5!b7e7UJ-gj}V8ie3bY!%kvB3@REy(!%IF! z9A0t>ad^pJ5{H*uN*rGDapLfj%ZS5EK0zE_ayfB$$tQ`!OFl&$Uh-+;@RCX5@RGkG z4lnr(ad^pRiNi~-APz729C3Kb=ZV8hzCavaawTzi$rp*kOTI)LUh-w)@RF|(hnM^{ zad^pBiNj02MjT!;MI2u8b>i@nZxDxJQAWG~|IlDWp=*We{X#Nj1Nh{H=ph{H=piNj0AiNi}a5r>y-CVr6Y zzVnF*;>Q_pAwJf4k~q9%ia5MvD{*+qHsbJ--qm_s(4O#;ImF>5bBV)ChKR#UmJo-R zj1Y&Hj1q^Jj1z~KY$6UX*-RW>GC>?(vV}OjWRf_%WQsVvWGiua$u{EflHN7J_J^0u zAr3E@OB`M@L>ykSggCrpggCrplsLR(oH)E>6LEOSX5#RY3F7dQEyUp^lf>aAQ^esV zTZzL99}X-9A2`OIJ{&Vad=7Zx?uamOXd)Vm&_#& zFBu{ZFIhqyUNS-)UNTA?UNTM`Ub2Zeyks+Rc*z8Dc*z#x@RCX5@RBLw@RF^>;U(LM z!%KSC2iqTBGKV<4WG-=d$q;dP$r9r5k`dzYl2PLDl5yhjl1;?nC7X%EOD2fJOSTY) zmrN3emrN0dmuw{tFWE*MUedcE*#7X6ImF>5bBV)ChKR#UmJo-Rj1Y&Hj1q^Jj1z~K zY$6UX*-RW>GC>?(vV}OjWRf_%WQsVvWGiua$u{EflHTlK`@>7-5Qmq{B@QncA`UNE zLL6Q)LL6Q)N*rD?P8?pci8#DuGjVvy1aWxD7UJ-dN#gL5DdO;wt;FFa+la$UdN&5! zA6_ztIJ{&oad^oPad^oR;_#9Y;_#AD;_#Aj;_#A9#Nj2IiNi}Kh{H>^5Qmpc5{H*e z5r>y-B@QpyMjT$!n-gq*c*z{%@RGU2;Uz=F;U!Cm!%Iep!%Ieq!%N1A!%H?1hnH+N z4zC0+Ih#1V+Bn~h63UPSJ6mfXTRm9;XR}+Vqe4jYHWGiua$q$LcORgafFZl^^c*!>6 z@RFYshnHMS9A5Hk;_#B*O?uv;f5J=lAPz6NJ#l!+9f`wB<`9RM+>JQAWG~|Il6w<} zm&_#&FWJ{Pyc@h^h&a4t5#@oGJc>BHWC?M2$w9>7B~Ks@FFA}jykvwpyyR%&@RDPQ z!%Ln;99}YN9PI-ySxFpTGERBmB^!vtOHMJ)UUDjNc**mL!%JR39A5H5;_#9`Ck`)p z5pj6Qi;2TaHW7!Hyo5Ns&l9v*Pmz+)H@RFAkhnKv9IK1Qx;_#AJ5{H+Z zNgQ7CD&p{xvxvh>UQHZc@*3jslGhT4muw~uFL@ntc**OD!%N;k9A0uZad^oaiNj0I zAr3Ej6LEOSn~B3q-a;H+@>b&TlD83umz+x+Uh;P0@RD~BhnKvQIJ{(nc)vdS-2N`& z@RD~EhnKvE_`{ZG9&vcddx^tK&L<8pc^`3j$pysWCGRH=FS(F7yyOGK;UyOlhnIYi zIK1RT#Nj0$CJryzLL6T55#sQYj}nKM`~`7%$;HIsB_AUWFS&#`yyP#5!%HqD4lnsQ zad^pP#Nj2MAPz6NoH)GXlf>aApCS$~`808O$s}=j$zKtNmwbjeyyUaQ;U!lPhnIYg zIK1TZ#Nj1hAPz6Nl6YAMUedccI1hxE>_Hq}a(m+Nk~zlV(cmR>iNi~Vh{H>k5QmqH z5QmqH5{H+J6W>X8)Bl|c;_#Bq#Nj0q#Nj1dh{H=JiNi~#h{H>^5{H*;BMvX=-J-_} z?F=uOLmXZ*mpHs+h&a4t32}JI2yuAHC~D?M^e|X6p;_#BW#Nj1F#Nj1Nh{H=ph{H=piNj0AiNi}a5r>y- zCJrx|APz6tLL6Q)NgQ4>MI2tTl{ma)8*z9^@3vt3!%OB6hnLJH4lfxZ4lh|k99}X) z99}X?99}X`9A2`CIJ{&tad^oDad^oV;_#A5;_#9w;_#BK#Nj2|h{H>IbA#;@RH5M;UyEq;U!y$!%HTK!%L=!!%Maj zhnH+44ln7s3yN$Q|KTNbh{H?f5{H)z5r>y7Ar3DYAr3DYB@QncCk`*!L>ykSnK-;; zf;hZn3vqbKByo7j6mfXTR^srIZN%Xvy*q;K4=^5{H*;BMvX=-5G3uc*z{%@RGU2 z;Uz=F;U!Cm!%Iep!%Ieq!%N1A!%H?1hnH+74lkJ?4lmh499}X>99}X-9A2`OIJ{&V zad=5D5o~{W$sFSFlDWj;B}2sFB}<6IOGb#pOGb&qOU8-AOEwXQmuw~uFPR_?FWEvI zUNT7>UNS`-Ub2-qykr}3cuDWBVEe;M<`9RM%q0#l86plZSwb9MGC~|)GD;j?GEN*` zvWYmnWHWJi$pmqD$rj@9l1bw5k}2ZwlC8wyCEJL@OL}()+aF#shd8`sE^&Ct5OH|P z65{ZZ5#sQYQR48DapLfjO~&DU;3cOMhnJi|9A0u3ad^pQ;_#BQiNj0YOdMWvE^&Ct z1aWxDdBou*7Z8V+TtpmRvV}OjyNfjGS6Fyio%5#wkdc*!xu;U%M#2VSy*IK1RE*As`Ayn#5pC8;_#Sv6NksVhd4auJmT<}_Y#N4oKGAc^FHG6 zmm=6*kWAP6WpJx1F;_#R)#NW60M~K5?K1v)O z^B2V7F&7hu$9#-9JmwPO@R+|O4v)E%I6UU##NjcQ5r@Zof;c?pa^moqPZEd6e2O?c z=F`OCF_XmMF@HrI9`hOE@R-jMhsRt&93JyI;_#Ty6NkrqfjB(oO5*UCFA|5xe2F+b z=F7z4F<&7LkNIoj@R+X>hsS)4I6P*GI6UU-#NjdDAP$fDCUJPoRm2x{;4yROZS6l7 z#k>w4b3fwnn0<-EV}^|5`6@hS32}JL2yuAKC~ zV@8R?W5$WYV>S_o$807JkC`A2kJ&;T9y3WC9y3K89IjNbBM!Z z<`Rd;3=xONEFlh$86ggj86^&n87B^p*+d*3vza(NW`a08W(#q6%p`Gm%oK5W%vR#? zm~F)2F}?eO?GKNcLmVD6mpD9Th&ViE32}JL2yuAKC~T0q$4n51$7~@EkC`M6kC`G4kJ(Bb9HbBV)ahKR#smJo-> zj1Y&%j1q^(j1z~)Y$6Vi*-RWBGeI04vxPW3W|BBOW{NmGW-D=c%r@finBIfI_J_yJ zAr6n3OB^0EL>wNogg88Agg88AlsG(QoH#sY6LEOVX5#Re3F7dWEyUq5lf>aMQ^esh zTZzMCwh@QN^d1VfKRjj*ad^yJ;_#Ru;_#Ry#Nja`#Njcc#NjdH#NjcUh{Izx6Nkr4 z7{~oSJmx&&@R$pT!(%QY4v*PF93FEqad^z7#NjcQ6Nkr45{JiJK^z`)C2@GnSBS%7 zrijC1t|AVPxtcgU=KI9qF# zad^xSad^xk!()yn4v#s8I6UTA#Njcc#Njb3h{I!6 z5{JjECJv7oH;(p!$DBeO9x6>)gXS;XNnuO<$U zc@1%R%xj6mV>T0q$Gna>Jm&Sp;W2L@4v#sTI6UT!#NjdL5QoRSi8wsw&BWm`Zy^qk zc`I>v%-e{=W6mWGk9j+Bc+5M9!(-k_93C@493Jy7;_#Sv6NksVhd4auJmT<}_Y!ZE z=lSk=@_gd(mG=>cuUtSJzVd$J@RbXR!&g2)9KLc9arnvyiNjYuL>#{IVdC(WEyUp~ zA0ZB3`6zMt%3lzl)<@fOG4Y3uKSmtBatU$x%3l(PuUtwTzVdP6@RiGm!&g2*9KLcn zarnw7iNjYuMI65JY2xseN#gL8zakD_`3!OR%4dngSFRuqU-=wy_{!&r!&kmQ9KLcT zarnv?iNjaEL>#{IW#aIauMmf?{55g-%2$cQSH4CZzA{A|zVdbA@Re^6hp&8-IDF+Q z;_#Jk5r?mQn>c*sJH+8DR}+V?{0;H@I`EZk7LWNSeC6lF;Vah?hp+Tng7BbBV)OhKR#gmJo-pj1Y&f zj1q^hj1z~iY$6U{*-RY1GC>@^vV}N&Ws*32Wr{d_Wh-&`$~NNgmEJFc?GIm>Lma*` zmpFW7h&X&@332$!2yytzC~^48IC1#OCgSjw&BWm=6U5;wTZqF~CW*sWrijB=wi1W0 zY$Fa|=`9YnKYV2larnwy;_#Ir;_#Iv#NjI=#NjKW#NjLB#NjKOh{IPl6Nj%%5Qnd9 zAr4=eBo1GhA`V~KN*unjjW~Rz_gJv~;VW~9!&l}Khp!9~hp#Ll4qq7|4qq814qq83 z4qw?s9KN!dIDBP-IDBObarnw4arnvD?`NLD@%yOS4N1#S4N4$SH_9MS2hucuWTj`Uzs2dU)e$&zA{N1 zzA{A|zOt1#d}SMP_)2eSu>IjHbBM!N<`Rdm3=xN~EFlhG86gf|86^&187B^3*+d+^ zvY9x1Wr8?-Weaim$|Q04$`o<<%2wj=m2Je~E4{~q?GIm>Lma*`mpFW7h&X&@332$! z2yytzC~^48IC1#OCgSjw&BWm=6U5;wTZqF~CW*sWrijB=wi1W0Y$Fa|=`9PkKYV2l zarnwy;_#Ir;_#Iv#NjI=#NjKW#NjLB#&N$7U)ew$zH$n2_{s~3!&f#Dhp(JY9KLb} zarnwv#NjKOiNjaUCJtYDGjaIJxy0cs6U5;w=MjgmTtFPYauIR($`<1Am5YhPS1u(E zU%8w(d}We2eB}z_@Rcix!&kmS9KJF|9KLcDarnyB#NjL7Ck|iPN*uoOL*nq2Yly>F zenK3+vW+-=<>$oVE7uZ-ul$-ge5L0e?8t`m3%+uD#{IDB|#yCC1S{@RcVJhp&uK9{9@9#NjK) z7-wI3I&t{QGl;`io=F_O@+{);m1h%&uRMo1d}S$d_{u18_{uWk@RehU!&jCQhp((4 z4qq7~4qrKrIDF-J;_#J~#NjKeh{IQ&OB}v(0&)1tYU1#f6N$rD))0rUtR)U#87B^3 zc^+~2$~xlkmG#8oD;tQzS56`hFWE>OUUD*Vc*!Zm;U%XMhnGB`IK1Qq#Nj0`Bn~h6 zbK>xl7ZHb-yqGw=WE1gzee`+$CB(-VpGF*B@>1gPlGBO9OI}7CUh;C{@RC;$hnJi| z9A5HD;_#9)iNi}?MI2so7IApVtBJ!)UPByS@>=5XlFh{7C9fk6FL^z2c*z@x!%NO4 z4lj8lad^o&#Nj1xA`UNkGjVvyTZqF;-bx%^@;2h|l5>f}OWsZ#Uh)p&@RD~DhnGwc zhnKvIIK1TD#Nj3HAr3D&k2t*Ky~N=q=M#sQypK4%Jma7LR!pyyPn4@RF;E z!%Mar=kHOr5r>!bmIv?S;3ad2!%OB8hnEZyhnFlN4lfxY4lfxc4lfxe4lmh69A2`S zIJ{(nxN8>YNn41&YdlH(E8{8R@RF^>;U(LM!%KQk2HPKAGKV<4WG-=d$q;dP$r9r5 zk`dzYl2PLDl5yhjl1;?nC7X%EOD2fJOSTY)mrN3emrN0dmuw{tFWE*MUebFi*#7X6 zImF>5bBV)ChKR#UmJo-Rj1Y&Hj1q^Jj1z~KY$6UX*-RW>GC>?(vV}OjWRf_%WQsVv zWGiua$u{EflHSw7_J^0uAr3E@OB`M@L>ykSggCrpggCrplsLR(oH)E>6LEOSX5#RY z3F7dQEyUp^lf>aAQ^esVTZzLIJ{&Nad^pQ;_#9Q;_#9!#Nj2A#Nj1V#Nj1diNi~_5r>!beidwgc*z{%@RGU2 z;Uz=F;U!Cm!%Iep!%Ieq!%N1A!%H?1hnH+74lkJ?4lmh499}X>99}X-9A2`OIJ{&V zad=7ZnPB_FOXd)Vm&_#&FBu{ZFIhqyUNS-)UNTA?UNTM`Ub2Zeyks+Rc*z8Dc*z#x z@RCX5@RBLw@RF^>;U(LM!%KS42HPKAGKV<4WG-=d$q;dP$r9r5k`dzYl2PLDl5yhj zl1;?nC7X%EOD2fJOSTY)mrN3emrN0dmuw{tFWE*MUea3;Y=3yk9OCejxy0cmL&V`F zONhfuMu@{pMv22q#)-pAHW7!HY$gsbnIH}?*+Lv%GD#d>GDRF-vXwZzWE*jKN$7-5Qmq{B@QncA`UNELL6Q)LL6Q)N*rD?P8?pci8#DuGjVvy1aWxD7UJ-dN#gL5 zDdO;wt;FFa+la$Udd~;jA6_ztIJ{&oad^oPad^oR;_#9Y zHWP=JoJ|~F@@C@jl5>f}OD2fJOU@$>FS&p?yyPO{@RBXW;UyOnhnHMR9A0ucad^oj zad^oU#Nj1Z5{H+3g*d!qia5OFD&p{xtBJ!)zE2!pvXwZzt^V zk^_jtOAaIsFFA-fyyRfw@RG+7hnGB_IK1Qu#Nj1}5QmpMkvP2MP~z~C!-&I6ox?LmXc6bmH)m zXAp;%Jd-%QyNmpHuS1mf_L)x_Z?ClZI3tRW6BSxX#VGEN*`@;u`3 zl6A!4CF_a9OEwUPmz+c#Ub2xmyyRr!@RC!A!%I#j4lj8=ad^oKh{H=>NE}}B=fvS9 zFCq>vc`o4MJ_eWBEhqqz;s}jGpx3hQLjT&>beQMXcU7o!?Z*DM8U!U*g zC2tAxuyB{>+-o&K)ZU&X-1C0qEw%bvdT)mCJ`#UNSZ5Ub*c&ek@4fYpy_|$5zxy3J?r|}Dmlvf$=bFcF4j}O)-Vth)T@`EkD z#dx1fmG5l)FUA*dqx>hv3+HS8)~AE5kWD~0bW?Obj7XBhvv#lLFp-`n_dBqc7d~QkGy+nn(N2Qm#ZFkEPGJaH}@&eG|9s<-?+4=}!h3srddVB~ ze8ll8wfLd|S}xlELgQn0S6*r5K4$!-y*2+4#$PaAIZERXHvU)P>Dqs%2R*U=8*WDk zcgN*j>sQBE$U@=i^1NX2Ej_ecoOhQ$qK2R^EKc6?F!zQ!*w{%E1{FZ9Lxo$+sNJUP|k_xXk9 zxp$HVqTR}j&snR1J6rs8c8CY^PRoD zTQ$#NdOCS8Se`!L(+c*q5B<^j(W^B6=lbGpvsBC7+Wl~WY(KU5LBl|-%Z);%t&{4u&|NMNH;C`KB{Nf9=p1m!;)p(Iz zf5AsA(>#2gogv(fOEazuj!QRL{H``nIMDL{(fE~9wA@L?OPp{NV2^M?1f1{MN0N?``@2DI9e$dr9-pw|6Yi!Ihp{UO&G7R`X6igf1M%E-+jKbS95~~ z&an7CucWU}nQ(U;6V{)1xA-SB#Q(+O$1K+U-PhuK|623p?4o>seeqs2KH08c*smO! zSmN)N!hb0e?&>qy?oSbOtMNViX=3!}`!eKNW$_D&H6G($uh%qx{5j>vTH)Uqf95|5 zaNK{C()fc<(D-2%UuOK&LzEw2{Bq;Fr<6yG4}4wo9ANYIJmU+De{1c7dj4HF_T57L zm#yB=JTEn9{`c(7!;OE~M>+BgG0x-sOyO?an0ckf7g(P87C(^Mf15Y8+-Gt%{$h*Y zU%1N?e_y%X_IpJZAG7NV>T{zXZy#>=(qi#{-C6UX|BP9s<(_$Qu-qlWcWw81{PoKW z{D`;G#}DxN&ffKMe!J~REykN9-1Wm(?KsNqjKAIUw$58Z&3XYTG5(Nn7e98b#^vja z_mS~yzEaTB_*&yDPSym|jQ5m*(Y0sIYz0${=L>i9rM|PY++N0y7VgRo*?kAvWRdX` zY(Ca#@h=#kX~%bh@x51Tp3Chzh4Jka5geb(Hh_4%Rk=@$R3%^&tOKG*n|Zxx(q{4wKO@2mNbH2#Y5 zsO8zu_#cI%&W8M#@BP;Ea^x;8Y0o+F-VVak#Sazk+F^k8Ph20LGk%fHD|%U?fxpxE zaknZs$oM4Vf46>!n%#d(HopJx@TLPd2{t0FAG-_$!S6 z=k&&GGN3l6UDg@1JWEB6bZXyAL_ z)7Mcxw-2{_sT1znGtcfjuwVBYzu&HdXv0s9S3j%uLHy(oH4i^eUTXY#8=ujiKQlh> ze9Z&i_fMMV#AV7avAUl5XXX4H;8NkJTf5!z7W#Z=Z>2q7#eDKP%agO4<{xJt+UXTBtEzfG>htlynaE<1V+4BL^`7Go4muddPEYH2h@93)> z$M+w``F{M|zoc)6CBohD9eIi7LAh&;uNW5GuOmLz_z$f8QSK7sx7vQ8o_{mG-1_Yy zR{uT!s(B85GMImo@pBGRj&b_|ECX@Le_t9T)r^A(&~x* z9rw5N?Q@H8mnU(e=9l99ZP&l2kIxhC;^#JNeAwcTH-7n{%5lD*mm$w`i+{uB6(?Gr zwZ<##xZ`@)?;l$3ystFye=L5G@%(eNTQK!-)r&P*nJ}QBJZL_g0iULvLi z?qvL8i=S!plQG6W{95yTzK!O=@tyyT@|OLT<9f9Fx4K{3zoZFfTAmW0+dta9)Cza? z+|Hi69*6h-tNb_{pK;!uCOqB#-jRX7X?b{F(MRT;u3UZ&f1mJl`Jb|QZ#&)J-L0N| zWgKzG@!W?L6zk#fh6{J+`%?Q}{0}VtY~illu|Lv0_A&1%xEn@k%mHlz;cB}cs8OHbWx&5Qv%Lw7F+|O=NSY+>&TAm(@6g*|T(c)hl zrR5%P{Bh&#DgJ5v`cpI>?Hrc*kSq7@M&$*TXC^pZ-~S{$T|0bF?uXOybA`M7B}Zz0 z#H5UmvvKBdD|h$pHGa9Amu{13t-l>;obN}@5bloe;iv2QzOBW(=gY3#Rd)W$WzOGz zZJfu$@5%V+;tO`wdakhe(~PI=yufv*&iIafH2y}5|BG=R=f5$|zGLSdwA}aUc~0E; zN#uhbGR{70h4HU#Jj8tCE#uqE_~$m%|6jsg|9s{HB3H z`;BlMQ_ZA*ev^Us+tK#d=ItZwL&wVfuxtO2&5KaaO5^<8<1XQ@{$I}0`bcs9w%FpE z?RXty`SW&i{bWyX&79!%Wr%QB?uk|(++RFrJb$Go{vXTpiagJC@y{Hm9P^xSg{NzW zLvl3!Lh}na@8%j`BIA(T_O|@XjlcW0^0SPm#6!4p7o4jc_3R=2HC?#}3U~4E)@%G| z%X60Txi(LD)cADcyl(AH<2?WQz<9+anjdvITE=}>Zd=vw_={K$oRph1^4TZ#*65`n#-!3w~JNcAnjjugW z12IqjRJhx(-`RbQ{p_IE<9{^&@Skfuj>`byF21J?U?JP*Gko5z0qn202zTev77GFZ= z%Oc}_52JF8^SpGR+#kAjIMU+L47kVg~-8aJOIc*J?EO_Zj1$gXN;$Jj=c!S2582_G}SFZlI+5Q$Aj~gFQtMOxv z|Hb$`TsZ31F5LT##h>twmW%7x;RkEExlb!k+J{~?zE;L9x8eEN z$HLvXmp4N>j(d+ol#iLIyh2~R-F>uH)=fE;ZV5_rE9mT!d?FJt)9nN{@KR)dH7StAAMKz zKVb34$o0nM+119w1C5U|&i9D}CT!*9dh(Q=d~VF*&p%!Bqn|%yd{&im?C-WmXt~#q zQjYx{COqB#UTE<%q=2-XhQQ+;*tGc;^{kVaE&O z^VP;bzf9|c`O-?`J?(z~Ud!`W8H4_N$D zD-@tF<>YIAe$H@+@Lb)Mz@LLH{_ra_&r$a7<;HpbaGUUS{p2x==kEdST9Ce<~4j>W&Bq%uDA{5y6dHj|Cr+E z8^3&9F#fN`2lQ3m+w$)&*P(R#TP57(=lRJM#uFE49<*Dl@wbmvj(PRYKh->qCn(3f z=nms?xvshm*QsZW?|!Co)NLoZPPqE;y67t5h_PMrU*`CHXYZjkn&)_X^GVCom{gAT zto@nh-?2&go)&+raCdz9e)d6&=kE#4ln;v`MB@kWdx|0OKk)$_4LxAC2}R^HD(^sMnkFDh>~e&j&S!}Hrl)ABU7$Dzun&A?-B0mU${i`VBGlrVCDRMsI!HqYlnFjzgo^e zw_%?Ds_|20{Bs-T6}^tr{Ol3(jE_D|<1v4`UwFE5|LpUfz0p@{e1Ttz=WQeNvvlzx z;ckETJVoPwYVp;^FT6tec;k-<-^GpSp{;$=!+6r-PdZQIYm5(<^WWtke!g-XuQ|q# zY*vo(WP$K>_58x(@0R-{w;|8&Lp1*ad377+Ipd7;`m39a-#uO9asQGszRIo(n0NI& z(dsYbhue)LUwtzYqAH@gnnC=qLX$-m6ygV7%=s=fCT3J(elQb!Vz@?4un* z|K&-G|JvH&L92gJMDy_XzHc@@KNKu?t?{<+E5|r_=*ikXU)uM)=IGnrDB-T2bH)er z#Qpg8HPpY~W$|~6(0GgktBqG5th~%V`h{`!3-vN?x^kC1rt$qPzIK%IV{LrK@w&=5 zKezna_}Qa1561ap<=-yY$M~WD|ZJwju;2>jURBK=IL#D9yh+` zIpt`#1IB0`ey-Txc(sj(MV4oZ@#8H&`uQs1Za&{MBRHS`o$z$^-}7|sZ@q5P`W$Kb zk1{^*5d~}Qf_J9REvVhge-4;k`&lYyTs^GlbXuM77XKj$Z!f1I_&kEGwY_=VdlKgRg0!qc_? zS3cj_n>|D0FR}Q2&Q2dcFatkDxGQ)5MVbfm(hH1#uu?h3y@Suu__yWy@3uTE_eA5f zJ>@tbtBju|$H#5pj~M6qTc1+R&+Ff=7oO{92>$Vq@O16-C(E<%_F68^)31yVe_wfT zOV>N9t@i-q39jkmNX(zW~ zet4nr4|*s^`~OaOZ<#M`-=r57JP-ey#qW1fus)&k^!qh21HVzY>nC+@Y99EuG`U?T*wuXxm$ayX*T!Kh*k9vI*bQe!SlVfj{20JUy*{qF)uptUc*^ zU2A-7Sj)xpgolh@PVMt&8fn zOV=yF^=L=APP_bltz3))mkD?A@p&4L{(O_ghbC&d?^*uk#-BMvd71HdjDMV`9PQS# zQpy2;Vg^f>>ama1(`0okFF|{K7m$eq(vX#c;zHAShaj5Z+|EnDFG2_4MtsL|AHO807b=Yn2 z7bO$6lJD1S_&oL`;cmb9`hJgacN}YIe!k4&AAL^q<9;fyTJ!Mpy|{3{|18rT{g*ut zywT#{x95`>w;wis@)XUFWAuILH!jbPwnJDabC_^ffA;{8-qo{C`M1)K+=lty8OD=x-n$L^c$@Jrwo{Jh+bzcb{giU_pWoDLe*XQL zZ;bQ!Ss=&N)$>p}@7*@l|I_n6Fuq*o<8H(J{6~|tedgSwfxpogZ-3z~4}b6ANaG*( z)jSc4pC;VRW81FLd2ETk?aj9MBY&b`KZ}3gIM4U?kpAk*edAD#$GqqmQIGoaUbg3wQN@ zLi(xOCfNsO8Q*6w}8q<^QD93->#m!9-@4Z#Sb(d*;+ZCW4O<|_#K{Aj`94w z%awm{r1EX_#e2m#KZif&3XNaBuLhoL)I2@ydWyEXQ1~v=KNI%5Pw-Z^Tl{BsJ-X3y?J_fcI}Z}>+Nba}tta}! zV&l9Hb9IJ1+g+u3uDw+YthaK1W}N-YdB*vBuU{BHc)ZpJ=S8nsdOn_D=Wj2|e~@rj ze}2x^?`q{ED>Tnii$B*mKks@+xH~SqF8X7OUn1kH+i-p9bB*SYKB@d+%YWFl%Ks(j zjoU6Zezo!A4p)xj_&4Lv7YF%4&6;PXah!M6#$P>H**C1AFbB-6D|Krq(hot2CI{l+-^ zqv9L1o;7wKf&07bj8A(+%RSmJ-SZwWe#slb{VkZSdD`|1@kKPR zIP*r$vzzsY-d66d#(yC9D{jO2vRJrl&jek+o)@03J@=fW$2TeChuenwe|la&pW8p$ zy__yQ-F;A_aCbg_PVIc1arWTDZ_;>v?$l!ZU71I?4Rvl6j=#67j@RpEYah99aN8C3 z<_P0Fe;a3fN2@2EpIj>3wOa|T)4p1`>;Jso><-KGhFy2ipOb#PRifR??=$d!3-{+6 zR&I&zhPT}N(!*A8+418Z)Al&7T zL^K|4eunYF7nGyj{&1Vde|2^+e!yJi%imIt`?4S3uAIMDb*6D%2YZw8RaSqjBU)*E z_HLSgg|*L5?$G>a9Iw2$@u+eBeb-xrV;?Qle|b6s|Ci+%VB;{>^BjApmOFEamOI^& zoojsFXys^!JB7P`6_VrQHW`-v?OC7e-`oG$Gokr;Jylq^drn(K>j8e|^F6)RD{S6t z$%Y9}x4-q4|A7Xr2>R7K#!s+u598;@#*aKvG@1Y#y=L5zc85PX`!@D*9 zgCmsVIpI%@zhcihQRgz@_}~nCxmP)VUp{X97yr>f%uBB|{;C~tJa?TZ-1UdZ4*DPmzq9(1#fNQP zfqma`zQ(VVd63&MJ{%$3)t`SSbA<8VPtbTA-zCOBo2DH3KQg{kQh6WU4e#{(H2)78 zgYgODbB8O(_2~D;OROC*Km5}8Z_n0v)F-+?^DjR^`CqNvw}rd*>9cLHeg5rp3u^bW z*ZrD@=O zj4xWD@o4`c4@f=5OZGA^X^%0yGU4v{p7^N7<9xi{_}?E>j&W&+MH;`$#9)0U8fPDR zzi`x{U2}S$TKx02U;Ar1Z{dTQ|C-(kFrWFtc*5pC;3W@fJYT17H(vdc<|(kkKQeyd zA<8k2+U{Y^lcIJz#W+82X*T}+aLt4MmNLHlD=iTBYaa+t*A6?jr02thyW?`yzM3EN z|7zi`zqMSg<8X<-?Ol)|&r_C%&!caQ^LoF&G9I~dYcAKsW31h(jI)Qm);Ry})(@pW zxjdd-=fPxt%{Z&c8oA?iX4ge*XE0@vSSh zJ{V_SGhWkEIj%=PUY!1T6$^L!JNLNYew~*g{#uLwGNkc%&i|V6*)~oNv3>rJ@p-2Q z>scV@rz@Agr*@<9LTi7!o%WtI&d-asl6i*9!@t*er12(cSGV=G`kZL|(njUDE?+C$ z9pAnGqTK$ososMY{{@YE9~xg-rSZ5v7RYti)rbFk5XT#TRi1;o4d=ym!dbbz;`FHT1ws`&>s&{>EA8z-u-O}{O{U^d*J^A|}t7ik(?dD(_kLRQ?{lznTnA4#e*9GB zxUStJ+}#(fy-MdxKeSz3Z1D-Zp7u8WmhpejQGog6N5+rZOY@9(1=*Y_slJx43YbI6s#)3w{T7SG=sYWS6wd+7wtgLZhsIInNq z_8E=e<6VtMS%Zx8?;Bred|oeY&qiy9n}p-DhWwWYEuMd$_f*stM%dk zjzEiW*Kd<@|Lr#1M?7QkI~*3=->qcaaqYiPU*+g02ODqPEf`;BJZ|?j*q4ih?_zap z|MIBCv&USWA^t0ifA>5s7x{nwoYwQW5z5hjW(h}3`*NSQ_><2K*1z}j)^66XFwdM| z{Phbo{uE2rW}KhTyXP9N-Ik8kc+4Lz5uUC-cUk<=QZKjRe0fy{7MEwrG0J;exx2oo zoPSp&&p7|iK-@V04*6Ba`8njh#`$+4zA#?+j@AeJa)QjWT|M1%Ww)XI-MVVWpR(%_ z;%^e}=CPGD?#;LO54X}h7{{JB&hwDBjUQ~|{{hxMpBU%$$-`dO`n+%PSXWRc9Cfo4 z{!5e3clNfuM(cy)lCV6BUsFE9KJ@x4nxFr>B)k4v`LZK5{y>W_GtR%8ccpQj?>%Rn zpC_+1&cBQM(5qVRPw9L)OzNF(eNe{rvUAFpKv!0^LqGKEk0!T zk9%4EkBuMvea&--@dH+AxlKP-j{ZNw_`r*T znsC?tZatCPa6j^rasHjU_xwCoSi6^REPnBUnrD!`_mkCHZqFMO;J)~1;jY{ko9Cdv zoo4(U8He14eZR*z|Gr9_asEA%gMOps9@gPviObeyiS3e;j8Bclj5}eB5mqC*Ar0$4@;=Ir{D6!qFyH zMgQe5!reS`DV<+yGsNfoPV>*L*ZfCYvZ2D$<*%{$1=ngk+TlXupV&Bw?`{3?_nN<` zN#k*RM;Sl$Y~}E|mkUo zUn2K~ZnM+I8~UNxGX?4AvKWUz2 zGM{oA#(~p}^Lp1A!cmr`@LyiH_^oN3%s0Z_dWk5lm)Pge`aQ}P`n}M@gs01Yj&QfX z{QaXdK2rY2FFZFyG8b--=-Y}sEmKmWemUY{uE|9)T8_=!(y9$fDp zHC}&8uzh;|Eqy)D$-tY0yW==Vo~yYH{q0lZ{Qca${;u)k#|6v1*!T`H<+fbUd)@d> z$0)}Z$?c8qYB=fE>HzR=?DHqPsO zcKtMcyB(K-&l2wPpJDwL$M@FHv_7xAtOX9z;=PxJyZGh5R)FVDga4Vn+*^gac=x+0 zZo_%8+W7LYa+JH@=Nix7CwkNP{Z=mGfA%kpzxFcCgZu6k!d-iQzLkz|@NOUaT=%K{ zpL_mW^Bh6*+l29E8{g2c{wmz%uaj}eZMcr?{DtPZu%B|w-|~&~c|G1Z|DNG(#;=SA z+vh{$cYmw3e@|b$Z-t{x4EZm|t=0P6Mc18`#`*jH$NWd*`FB5lZhY@YwLVy%Gv7F0 z7m~tV`|y81=uL~~^~1mYQp-K%6wQx*a?DrCr@X2h*RNB*PQSkw33vVN&m%Q{nl;8P z#(8|$;Tw%#VAmtLhtKb)^jxOUtWk zYhv{hSy5X$zPfg7S#@beLv3AsY1yPHUU}`rcy+8HR&jVJeMITFs+y|Ovbwsmsim=+ zhPtWVxVo~5vC@i36DLlUkF@(&sYEseLMPUi*O$5?s;bKxs%mQvFOSE)(ldq^pWG0s zt7A-?c>M z3KwfbWv;Z}l36P5zn`V@;jk+q`yNP7m6)u%5e|>8E32uGm(@v2q~FzkqZ-E#E0%s; z9vhpnq5Yt6o^;Ks^Crb6XYN9NV1C(olQJ~BCJMQLiDh!uWH_*XSV7tOlj^btjEz-| z&lXTPwyIw0n`Orf#%4ZOw66IQQBz(St0=3USX-k*!UjE9ce|tZ3%P*Cs#+P}vR0|C zc5;SJ?Uz$Lc2ZsS)XBBA*(y_9URDun=&(lRm1T7eb+JkH*&3<1yt1~uRz}QhK?UWt zb!F9A_A8t(5jErFoQu_UP_H5vSzlG1VG#3Mp?`T@)x`SRYz>uPo^f>WQxsLm`O{HV zTucXf!u?#(_}c1vyromc6Lw=|XJXuf9u!WUZR%PqR{av!UOqY&!1=jl~XtrI= zbE)cMWgYH-e?045hwq?w=#lp$J29#>Tt8(UYEX)>b+KP*Fvj65A( zl)~Y0wRN%jhK>$?|8bMbE9A)-P}T!mR4G&YsTHvd(<(nl|H|5i4tis8RZT@zSxxq{ zzR(4Y&vpn3sv2wSvW<`h9gU7f)n$#b8o7PRa)iSD5G3bLePx!&;_9-=H60#`yy}=t zG-Om9H!kbdt+?7vxH~vs!y!MaqieI~>fkb$r@7X3$PRmpX6>MFS`9mD7Uas>{WPe9 z&J_;(P15n@qMycf;(C#%ksXen;d~8rSC)>NB@mi*uaUJO7OU>4JLtZ5c;uw;iPWA|+V`pX`1s2+w`A2_?jk_lh9i2mA%iO8Cg~jUZBKt@ztx#1_(}~fj zcw$veLwQ}SY+{zClA!vAsdcqkr#?mUB&WQrzA9Vy3WsaT8q3bD?eG#TVcD({{pAWR zcZt~!Z-GBC&bCv2Kt)~I*epSXGLOkVXD-%=?1w|rbkuG8#mlN=>jv^HRVwxaJDTwO z={nV`{K!uAsZhKuUN*H%4qiNK{bFV1m2r8@m?bDb9;=&__5JLV#2ew#Fim78edOA>7JGHFi>p*>3MMbqtuCqUCDD3zu8LBU1rJSWQi~$+<*SH)fr%_3!vLr?@jWe;U-mbsRxiui*LhHJP47 z+C5Hvrv~_9dBon~9H5^(Vb0RR`3&-UHQnwu770e1|JFMyDEzP zm{i_SHMTl7BvQU%OmQ%#v`YL=+Q1Ex4efNcbdejT6Uib?*V!5l%@n>t;!J_*_q<*7 zsD^$LBS+G;NmY4OL-kZ?&v9jwsvAU7i3&o)mNpLY=M7!?fL^fL^@$CR)~JSXztRC> z$V3R$$@$vZrs>4zxQ*l^#ePx#ZheOWGk&@&O%jo66qSw~TPjbyW2H5s=}O0z=`^!T zY2@TAEU&Dqt*I?;ko%z0^W~vOLFo`Vh<@klN-n8UJ`TB9LlK`tvSoMYc~{c=V`Eo7 z5Rp^K8Odz@M&FdDX)?%%L#3l+^5h@UA#%QU^6ctb3hqrAKRtQlE08t?S0Ex$+)C-s z_B4STB$JV5WURcQvnkt$cj?gPk1o?^z+L%NnhvUYv@3@5`~ggckE&W3rA9Rr_nshLlUwgx!^0#-_5WhI%=d zMwR&|)TnT&HuZPNI+?Rhc3E8)x2)}VZ-eW@hI0fN!~++6y_joUS2|T>s6HUhHp;k| zPM&0eNFA5**OeQCoLdlhMecBF#tGW{0eje6g<|$pt+xta{8j$5+M}{_brOtzn3+EM;w)=$6z&AKG zhRcaCzGjktD$5yN!vkBB2w*qS#?n}Wb&|y;iCNf!v6XBq5l2)hl&dd!iC`i z*@yPKVWp%!ySllk4v&MI0d(O6Nq^YV3}5!?W$zeRxRJ;t=j3LMm2QrxZF_K zD02asi}U=VtBo}|^Tj63NoALX?(3BsQTlgk(lk8|7tn5N((=qZmAUwCYtn8joqJOI zYh1RGC`}xvYJUaHmMTpgr_y^V9pHBC)HGy%RQvr zM4!?yZvEgtsH)s$8I@l;TxMAXr6XhRzECzkqtjNPds1_SH)fPhTg{D0$d${w%jJWr z{oTuOfS$bI6;7IX=(N)#4QL--B z{i{e8ZN^8|PL}n}_77Rf>;FSiom4hua7}Dtm0SHRsq!a`ipz?Cfwdx-p#QI*uULd?HXtU?AIz#M6jva)i>B)!8h79T6n^M zN!9W!YF%sR0jz7T{0Rfxx~$X6s;k#U$;W)Qu6xMG99Z8F#R`rubBpd}rM>DW?UbydBbZ9{4d<`qoP)9g4|fQHlaIQKP!de5!!_n*>Zh{y}om&W~*vVF9x zPyhPTiS}Ip`HI214~C0RiOUxPVp@bYb^YMR!NZ51Qay60jI1HKvdFUK(s)DNkmB|2 z+_1r;LU$KGc(8n-V(_TKQYld$FUYqeDoU&5QG*QI+3rxfR7^i9MxJ@<%yfv9B~vT; z(_Pd$vt#~lNqFht(WRq~cmEq5a@7rdwn!VrKVAQSYLoQ))u|>4j}*Bg>$6?YLH`&n z%~)P758BopjbMMt_fN?*UBw+Pci4*k!#1c)`VJq0?^0g&{<(1 zVPZFjM2gp4Hl&YtrLh883jD#Qiy6YM9+7bWlaH?}i&s{a*Sm+qLmFc8n5`=n*&xm6 z*c3|BZj2}>Ev=2$hr^|%^4%vHK;)V_Byf6W7_+)OV&%K;C;uNlDpV@+K=!N7FLH=< z?7^c3>L?~-*XAC_Tz#w&+SjVnZQu`YgWUjkqWhl?a9wHOEaOD*49|YX{a#q3?Q{%D0BSsBy zop!@R{hhi|S1M?SdSH0)sAK;>I&b9hPob=XtEin=T2@{js~0_Pe%k+9shj1bJM39H zPgfdslO6SLs^9;agPvu7H$0g;Jmy>Q^vbi-Ys*zZ<^#h=m4?%ahEe@X+f4=KA2P%1 z?*=Z}#*Xgdz?9{Xb>$R77yS+m*S$5^sCMg;&-7>A?g3v{J|))`Ui+bWx|%4meoD~Q zkEW?ZyJTI>7O{zWS3j4g7RWT%zv1@3Qt#hz`!j00^*&?xP=75#|3P(SljYgQ;E_cq zN95t1TrR4r{M%`{$&tVLH^}a9{tZv(KI7)`&XRZOLvGI9BF(faH9WMRh! zpA2MPmmpZWW<}EOu5D+7D?Y+Un(H*0;}Olafko0qM=d9IVy)HcXE zy2+cQ7jLox)^)s1R>HcjvdK!YgDdwo`SG%Q;D zvBR6Xv4ah?mDR z1{eDUHoC79IhVJ-6bT$rCHAHJijv3YC*cST4(ySXERN27+2JHTK=N?keZ@m=3Oc-Q zcGxk3gL(HHDH*>vZ`Y6lH+SEVA~##-aJ#o=XIE;yUFcSwPoyLU*Do2_@a z-P$j#e3q`=MHJEX|X);rwpefQqcJ;zjc*Zoq2d?7CVC0j0U{rzvn z%5OjE^8@*H!Xaaajg_wj$wf}yb`Kb;Y8q?H{jY!2$y2OGF@+sWRQv~Gr6<~>AU{!F ze!C|X8=p|-W!=?ClINt-@v(-|c&-1`lcpTn4F0!=-GrpHuImjTl`W3d==W#F4H=WB zO-DP|ed3__Xc<++;EUUV7wumZ31+sM;G8m8ON zi;bIQcF(zK^QJ9!VuZW>#0X^UwiCn6`8L&wvA)Ke`NZ&-FmB|D;VxSvyZM6Q8hcA$ zF>K1X#ZHX8Za*;s8N2PoaMRsQbz-cq@n$|T^6W9w#!RH7VY>aq*qD2Zz|*vL^TN(g z3+3^mn-|LbTh_VC?_bH!!Pd*S@`rYqL2n8MN5o5wDsWBPPHJ`bmLl5&=>klewRZj7 z@BR2QcK^q6x_s9ni%{Jy29k(ljnz3DC)076rFZkpc!MXb^6=3;&CT?TwVR$K`{S$s z<3qJmgAYGt-?QBq4&S(bW+@MS7Df_`CL|_LG!O&vCLGzIBiGx_1WQrgC(U`|H1A+r{z7UY-3?K$_2{J&&{ATz2uB0cpylrJUWcWIbIWnHyyj zHoohua%Y$JD;a4jnYQ&MN0ytz?r#3zD$_1@N_;&d&92F_>2}{#3AW27JOJ)A-q-^m zIX2?~2rlH@R0kl~E}QTGxB+fs4}j#@j0YgNR&rAvfMC1$-!DjW)&vHG_A^#FVp+a} z<*y}AlP=3hD|a31*5JDz=TGxZgER>P_1h$0H|Tt!8$KwMF((qA+(v(hZ*uCpR zJ5iqhSkk`#5fpG6{q2JeOAlTgy0Od1^`INq5~taZv>jDS-6EYv%5_h8)HT!E(eLtg zl{EVs?4@o;zx%qFjUH%%m$Yu|HgXl)0^LSR-6Gva%H6!(#_i}9>^8v*aW{4wx%O^> zZX=~`k!~a9Zr*O=cJ#YJ}hP4xo?4LR7*FyP^MLYU7 z(05APy@$_Dvo`6;v%X2T#M#r~*C9G_2>jDW+6j8G`wzhXiWA7DYFqXMTEG0OTTh@s z+U`AmZo;`qPoVX6-x4Pf)&OT*9p2d!NZM)BoIo2l~P zE_RoY%?)*9M_WJl-poDC-Bon|8t6{6FXrn0!<;SE*ZiqYH}o~hv(bG`a%`SKZT&QL zGxs$&|J!nX&6VzM-?mg=^JfL!(AOl-M)x(zv3dI1`WfA3?rUzUwB`DmEB(9nHC}t) ziLunCRap*c*VmGFqF9@%Y|{1Qov#L_+~2kR|UNrid*K|-CG;gRK)nUNl!t}2>^jfcBMhE@76-90|p z3+N3XHY{cqXe5wYh{Z^3h82hnvqNHuSg=M&utWkORy60{`|f+so|!!}kBG|Y=}2{# zhkxw%-u>Tm@7;JqV==i-f@>tc%mz1~+}rcpe0p{@n_;$r`;ZzDv@aCNyBl_xpv+R> zDUVW-ksh5se~S*S$A>9*2=K-g?tfgRm_xV9hv_6+4ThNc*zNC~yu0`g4a1L<C3#|N1ugPZ{EFl{w95QbaaNXSm)1Qyy@c1hkxhz`P<%0az*(PJlP?+=Oxlt z$3IHDUz&UW^6=DnxESO`BNSs z!SZTFo!feTZ+C+u#7SewJ)RV}4{Gr1fp7>`ZMaI7E8O>f_VF5>_f|7rMBv7+a6SI} z823u8XJ?}nbDZ91DSd+xojBX`w1YMjW)Jww5r3;+^%wbsrfks>XlggkhoAT>bmp~> zldcwne6{Rpc@cN~>vl1QouEuh%&bT+u7@Ac74IT@pHI7!KHrcm2$~O%uh&wv>-b^q@tjr-Ykw(s&SnBGeUxN^43pq3(`P!Q#rAGsb z2o8zoHKb|_&ai`SlbHg{PAhRaI_B+8mlH^vbcxB!DaJ@-%PY)Lma{skduXl$zFc== zrhmITLQ8zhW*hfT`qXvtsCz&(g%*_aPqc-J*+R6u#{bMhN7pMNBK%v>CrLJ)robwW zXwWk?H7QU_v((!KyFfn5daWU~NMdfG=cGB%>4{FKx8zZ}Bk=k+`RWS&wP_eBWZ3Qr z&9FS$pvl^Nw-91F-LjwGO$Kw!ft(y*KxHY&r1wA}uyY{hfC{Yy@>+Z2n0 zCZ%8}lvoy&ha1II!I_{msETBBl$ql*u=aL3F>3{R=kfMtx6f?JVs8&ye}yjr+m%d4 zg9KcII_iZWDurrw8d!;`fJoe~+|CI}gWhrHWVQ7=`vfPQKRCReOg?=*7++^yCp+Bblo$Ob#>FiwMk29Ju&gVPtxl7TNOFK)7GBILkt%V{9 zrhM->>~NDWyYunv7UHOXe87`{521Cp=|2SE$I=Q#*fC?f7#QBqNM7xpK=#cRmU<6_ zSaD>MEUyMMRCfw z>}nSySuZf_oCdM(aECK7j~}S#aogxda+M7~q+{&sr2l$|MFDvgI>rU$*03aA5Vl}X z@36VU7Af0NU{YZUbG~E;4Dn)iJtc)o3e$Z54Vrw} z(2}bq@p>&Y5_3wTH)q4aG)p=NOx?a3OtN=qEFnTF*$o3$M!&+{w!J`-EeN=y>(%ul zWAWzpSvJ)Y3Ye^CJbOHBrNj$6B@{sL;&vWTJcEYL*Mu>kzSPqs+nRn`9mS{*V$?AJ zovS&7VYsf>e~mdoV#@W2_&lo(Y#+w3jJ9BAs2iIHUa>YDPSHuzDFq(V+XZYLU-eeb z7+%*3^;~U?A%eq?U^M>GU}Bh1FKJ)^ZLm+zFK5#!G#q@ta|~5qk}NTNbi8|Vj-b#Y z**-B0c$U9MM2^nL-pmf!14~18+t#l<8)nlC{AVMT&hl~u*!j^Mu3jeIhf%M-e_b?5 zDJ1jcG%v;aB_P+G;Q6DiRq=gEDLD%p--fiy+M7aOE+&b5kVv-d2`GG#>|D)A{?Yj1?oBquIXb~5zT_X!cjhi&(a=!h|3tkjFx#Pzxb>PsQ!!rS+sy>s$0a89#(TuE`?fXbs%?l*07IbJi+UKBI*A zY3Z@5?5IN~o=Q*V^RJyHLHBKa%!3i8Tff00EkTsz1y8fw60s*kcc0Ja<4>m<)ajJt zBR#f1#L-@F^Wr?)YX7XkW5cA)W{y~=?&9jC+ojmQ%*SIk6>|KuPPcGSksG(b_AZ!o z{hjIzJl!S< z(bcz`<~=3^Cfk1VFQjfRgthTamDr`|EghsjyPq_p0RB58Z)-U$&J89LurnNI17kM6 zt_%$Cd(-JwAFPC6Y#@&|g@ovhV8N@0_hE4N&KL`jx&em)XC0RC;mO@va zmspA>pUv@q73~#PfM8pdp;Z@jH*N<`1rcaP_l$GbDJZZgzFS<|sn47KdD@2{KQ&GD z$+_CPp3WAOi5+1w=e*#l)VD9NUI!?plvt&E^pdumAKs!cGRKN=$qLSmKL*nyMdU~r znz&`>q{NhAdgm zo3r@sOE0Q|(Oru>2Jj1&L_g-9IULq7_ zdC$cru#|Rg@zG5XXJ9!`qeYm6BSJpTq6I0}TF$Gz#8Do%$ptCoiIUiJkk|f)3;*HF z^keoHHQrP$A>%Hk$`LPAwSAf)*Yg$*97iL%#%-(0V<&sd>-l`PSS`CYp?&OGjGXIs zUs+3L@8oQ?K&YSmVNN>~Q+S%{-{Fj&?zM9olC2Nfr#{WJG2Z9F38hWR+a!_xD1urS z1}FPGnhtA$YauX}uX3>FPY|;j!?$Nk0^xmfpD0*{{~WS}Q3KuWTsPSg>&--$nK7+* zQt|t4v!fy&s^>?n5fa`e6$gkM3EVJ@>w;B4(Dg3@XJw6x(6Wg)6-GJsAe@K*yS|8| z50nhgdzCi0e(ift33qCnEeQ0-3MA=GN7-Grv=MNMy4W{2L9D#H%}_$@AprvzGx+1< z?US=?<&yqZr3d_Df-P?Vl0-bZU9hE`Lk2m&le7eg3_uE#iU)ZWjhF_Dyi1m#m`(h! z>Z5ekNUG6$4S*MgSSGuOV!?-@0O|2;m0x1u(Q5;{1oZN1Hqy<(Z5Q&CxuhN?+?oJ| zGnkHMlUE3gVi^2valr00LG*gxabkrZJ*40u{9OGlWarEe}la8?DjlgjWhN* zMJ(I{D$xDhGka-rM~r}_+)>CL!CEGpFKv(<3c_c^9c`J&h%}fjNQ&=Df~pJC z3qJ<(vPY3T`{}EcfHldsJ0}I+P3Px$s4;5NQ-oi{V~K?5g8QJMv(+aotS+Y&#R1PX z8%Qk#^&Yb&->@o7P?&~&&$0a^`u4ErM+h-svv*GD54|^1n!Ym=zbEpmlH@&rrxGYJ zF%6$;B}L7sT!BvdW~G{D4XG@#)W63ZR*Os(1SeE(m-OyST4KP^C;7BD!Kc`N^!}EF zF*x>NF^=7#hr3j8S6?h32mhK9n;L!RuXcwA7`(X7$MDFFhvU|*yPuxH%*U6=CcAyW znT)>;r4+UGWh0(b+L*9Nm0r}L0UEGUJkOm{37(QD-_% ze}U6rFg#>#q)2iNJlm}zWKhf094#p4ScFkXv{`0RTgp?_92^Y|FfpC=*Jd+4^Bt>D zaf9(^=eyJ=bkQGR;Ib8EroREGlQJctJbORA`RorOF;+S&u2jHNLq+PtJXH#*W_ZCGHP@q5Gu&wM`7tr?$EwQ z{|G;+q1+NMAR2ymlY$VZ9@X=;5yeKd_>fzcKXA&;0TMreU|~ zyS?Qh)wnQiyR`5AEg%H1X#e>OrB`Ex=67PIX*gh?J;UL(!po|{z2sOLQvhi>x{JUb z0DxmQS8Kv~pA0%WTnyeH>etqwa489@4S=j`$0qf_j25Ke zjGiwRgHI%MdaIzoDcL-+U-E`mlaXdjom&_6c$OxsATGU2Ho^JVNN-Rv%H7~1zex~uNQdLWa>?Z#qSigcKJB#u zf|7ZrzKi1+TdiZ%L)T%X!Vq|}E7k0-Y+Zvv%21Fc zliJl1Pu7?}fh0+`E@u!%@2;V4Ipz%weMFxW{ShYwO%m+9S6VPUOWj8!D3y1!xlhKIArO=B2oGr^&zb|Zx7pFPjG+Eoxsu+@SC2z=a}U#5{fI>b8oZh zwJ{8~9MDP%VS-;+9fFmG_gU-|U`Q$G6`)msVTRtFSD8#M)P0|JXIbG`fSMQ%ghuLpg3EM8;!#-G>M8U*TOpmn#QV2I=tm-~@v zmUK?2CM8Fk0hCXHa!&Jpf9N@82?Wo0btQl{=AC9Voh zTnP-S$lwI}g=^2EtmLslu)$FYvIBS?TIZ-!;&KTZgT=|B8Q=){`1=L0yUb2HpS$id z%==UdFV6k9-=JD!s zd-1;O7u>m^M8qb9g?H;$ZEED zq_`^`4`?SimgyPj*x}HFcFfwk-n>a;JVJOI6lVPZd|b7={a^&Z@ds!sEHD9 z-d<&tuB^0vzOmm~1JRJP3A76J6O7RUlBjzerAn)+uOy`r!6R)uJQ7U8pdvomlx(gj z-9WzE8}wV5dEwyi(^8Vu@bv<9qc%6}P!qNenGmB?kQ^jYm@N&Svt|WKE4L(T)#*Y_(#Q2^|&*m2e<|FOsb0 z?2ZkvDxpfkqPe!BjjTr3F?zq;`=j>pngqTnWriS*Js?W_ZR-(MGiaAYol9r8)NJhi z>Iy#AVz!{x6O7bz7P=4_i6cSjKo|JFlPsQ-Z%?CL4q_M<2gbdGrEyLhSnh!j%cYiy zKLX2BKLuMq;6B5ULekTJrjN`s1zXY{Va^-n5?s@IX}Q8PYLSB>&Xwm`K?! zt=9q;kGr>U_RBe6?m;Gb$w0gBZF88Z!r77jiOCM&J_d9oT?iqq57RS+PSi-Rb%e)c zaK{ae$(|LVSkjnVq zN7GyQL&!fbuP50LU%h;Z7znp@Uo(tXtMBSr0+EA&B|4jD^TF+ubV81vSC_}=eX8A0 z&m0Mhbgv<<+8Zfo#ZHDQfWeSLv%?SC-0l>C8r$D4bdvq99JOlE-D8tphU(&nZ=$Gn zkFy2A?;`qQGRrCz;@TX>i{B%Km-f&WLa^F&4t2qde~24@C)F&3He;wChb!r)uS>k? zSG1j6XA5+%rz)#mucl2twx%r>WqS9WcAk-7-}`NIzCR5?26&W1Vtjnv`{W7fha9; zqh#A@s+9w6q#fDX8XxLNlJS%5$t^0ku{&HnvTSIz91QE1LYJ~ zd2+a1EUSRLxke3S4$BL}JY*eAv8~R|kgqCJw`cDtD?lRBKnq!jNPU6ISC0Y$&=Ox& zA(lAF`58NG_zPQ7z``5$_-ZsdbzXL{vH3kw@^qzQBf^@XntIW_njNGHFyi+t67p zfBK;exB0P1223-DDDnCpC4S!{YOm)}D>6JUs;2GGPl&#qR!a6oE%AhhL$sY74~me; zzH|Ov=_;*P0iowb%gL_^gX8g?tv5dJ;n;N3voAR;<8dmWW8bFS%3P|}Xb1-!Q6G1^34kGLpC^QWQ5kGq(8pfIH zPR>?_+Y@^O5bV(_OEAh6o%>r%N&zP#bV`r@ULWE@M>MyUK0r{C=?c|eJR!n3-%^Lp zh@Bz28)ho;=xW!!hhKFP*ok_M9))d687g3JjK(@m&=Cu{UjZN+S20D4x=)T(MlXQ+s&?(aq^ z8!Pjh@jXexP1xRDa>UPs4eGfYsud+jM`MIGYuYA<5Ov4G=v<{GI zJ<4%4X=x3fw8kn@)QgeoiZueyJ(AB9S&q2MAjhlyiZtDDEm0QyJNwKO400Jx^l_$v zZ7Elh4muEhlzA;;K^yj#s!q|+gR%z5Vo4~0%(XB-Wln>Bytsntd{0H;GCQGl^Cas% zCtEPUPJxNZ7GGli9IK5@@BM{kwX%9u!VaFab}5O!p)(cn8B=w7YO-QzgcTb0j;qIk zz_XIpOXtr>1(%0}kjC-0!;GiRiq0v} zMpoE3Vz>4b)-`Y&=`JFKqyp4MhPhY3-h0!tgg>vwnI)Zk`R-ylyhgLx7Z^PlqS}-U z&b1ditLZTR-irS8RHg20y6MduwofS?D(R$V7-Uz`-(qpa))Ff=a$+QG~kXmJ=

J`ee~QTQ1Tc#pwO(--M*|k#SaCN`Wgy$xs*~hPF=a8= zFwIEkV)(>}_W1KbOw=SI5fB3Z-NUmP;PHnvvk0SmE$b0Wm#S{%&!H44%`yl*EAyb^ z`#=--(F7a?tT*{Evm{wMIlwBl&tYm9tR@#&ON;(KA|G%qt4|&nceLl>^sk90bDS$w zuYqOI;$}q`nd2<%v8s?+hn2E_N!%C~cZ72G{7ej#Hk|8r0qYiOMRIuTFxVuL(6I|u zwcxFU16-t1FD$d*;Tjd%1Un?nK8fRZcDRu)DX3Db#zL_lj~052#dd3i`y;xeu!3~T z*bFP%3|>SfS2{!Z+~uV%M5Q%Zp|gnguWCw@K32TSRXi}ynQ=u-0&ALSe!c30!=>2f zGct8CYj4%$}IcXGQjr%nH z2=!USiM9hcWs&?_TdUNn^&IaCo3mCjip8mx&mM*;-qP?s7u$-3&>?bM2t80t1=;DZ zX$77p75*@?O8 zIXxxF1@dn$Vqt>*5)`G)?RHC@Yu4`77a@o?qODQ5)XI7$x0qa^4O&m*SH%^dTnZ1e zFKl5!428wKx31S98yn_x#B|b|e6hM7jDsFTFt8tN#qL`RR>Dh~yx$ru-gocveCLF$ zLeILg0;PxqxldCUEFE9e=ebG@iDb?wQeU~HHj|$6FX5Cft``4Dsdx`n;s)TP=rO!C>by$C#)+d~P}t@b^t|ZG;TO3@ zf|9KpZnsHYB#CtNAp@JxKQ0{3RpFd_tq~hZhf7(}*_DT2`VO!Y(c1!<$hCmnVilZ= z2l{OTmH>m4q;N4qTq9uOJL0pe6RYWHi2?8!P%_R)l7@juOQ&nb>fwO^Y_LYKp4wE= z4QSY5$=>MGbTG+>UdutddDM~Nj4v7btjfh+%U-u$1V8tK zID6<~!#z%ndJUrcmDFt%f$4{4G&4jwQP)wj3BdMrIi?f^1iZS%v^H2$-)iKrH9jl( zwGwD4woJ2xT3-S}_bRX$N3wd4nAHHC!o}xwCuRH{SJ=I{9;0cN>Do$nTgY@&u7#sn zy%Y;ZfRr}h@v-1IZw%l`Zi{%>yo`BGx zz$Qjo1!+&uwvA_WA{*){L&%%ID>%RgL#y79T_EI@%r zOn{qRV%&-6)ryDqAVa#3_S+J9p*V5PZMP!P!2JMwM#zTQ9ida%d=n6N^#!ry_z;3DxwY*+GF*sjnzi)0koGOrnqJb3dp}C+uHxs>mMfI)>`Axks-FP={e9=k13H9EcH_KChe_V<>QMzgb@o?I>mIa1q2##oJm>pKcF?5C#qHE3;LR}c&R2S{6z!u7&W zN*gJ4vr=Cn(}Aet44VoJh;2-`bDaZsi1HHd0gwC5m}?6QE3M|oGBja|aTu5$3=ws$ z`#&2l&|~vCAZi_AiLbN83VmV6^6`toqL2A@L(?u{C;U`d2Js$OaliA@j>Dy)F-sco zX@*T>IF)cURXhN{5xVPG zk;UNl1v;Z(E*LsRdYuZ$z~o@4QlOXnOA^?VRLH@=P#)H9Ce-Y$@<}$skQR!bBSp5z zZxBR1%im82cSq(L_&9wo`B62|=n+R= z(2NL0kxSGc`T1?yx&soEH2lJL{_>yak`Ydu*gP zghmqp<>_&)l2AFAvjtdZlhIYnSiXS(*|AnJ8GHwahYL$P8jKRxhY#!+Lb6))9Vcr8 zYAx^T;-B)@+MK4<1`96izI{SX~Sje3|GY3THQ;zU`RT>!qBjprE%CXXQa3X#o8HW|)8 z*$8@m-_4B+|P%xm*koS4MY*68(~2n%?xF52}f+oxjNbvWpjJsiOmOh0QmT z!bqw9V0DEZ(GCXLfXVauh#~H&~pS+&sTt%}%pg_tYlUmZJC#?r}(eK6~Zu|$A7ZEtWrEe3y+GAa_XK_i&t zL|XSz3u?VHrw6&^G`Ya2@q#%>e>pkrnKAHID}pC9=~B`pj5T~<5Zp#upPrvuS9d2I zUc0UleZ%Iiv2fSK5Vt%l*s`Wm47yNo0RY8~AcKfgxfAB>Q$^`{t+u8osILLzH003? z9NV0RtVv>(W=|4lYBx5};Pdf#He{dyT!m6?&zd1vfij>8$hcPH6oGBcY?dCi=5u{2%5CtrDW>0bfwv7f5O)J=%F7{XYmauG z?U2IpO{Pa^5KoIQC6G#5FzR#`>m+d9R+$r~Wn*TCYtaIH9pA=!8xP(& z3kuR1Xvl2~0CC$05_uTag7SWxG6#(Gp(m|zth5sGwP*B|W`sITU(r{&Ry@=%M+=kp zh;Q0Cl7}WDVzjRM-QCcAN3noSP77~d@zCABxtHdaCvl~UdaZ7qT_it&ik2eJ7> zfF7lJnHoF|p7&r%5Fo-nP{7#>|CtD2Xe?0<%o-kLPr;(L`TX zT%c;s*j=MU6{iM$&Q}X`1s>$9rTjVTQANC`ElN=yEDVeMWOI(%ZHif~W}1!I`AA{6 zoSv7?QBxcpdHjNEeC?F&{;O<-Dk}KTEDs!GwKAdOS^&gO%U*BN0s zofyOeB^dT@%MXJGj58vyZ=VVbdFCCCt;hr!+I?urReG^p`h3=ocV!=fLISrN6(a~E zvaWvhk=3WneW|9c&HOQfdEKJaOM&H`|R%Pv!LRa;8jT5QV#&!CRjadAM*RxpK(s18lp7804|$@a&$ z2wLUkpw$zN$^h{T5r{4#NR3=v4?hql7`7ikLnWIpG!McbQ1(TB6K->LVueKw?XE<| z5P~I43m|_^dI|Cbl5lm9NjfpV?0vgjKzu>LV0b6ySJI!;*(#+HMR>tT{78q7asDBr zTo1C5+-#fM``f-Yj8UWxH8^S?$4K-4<&uEe1YhLlHQgPag@Kv@?cR;<{xS$j1(DWM z)lWn*euI-cikd5oZPpJTCYZM{3V=5Ott!exp&tfa02iAuXuIuoeC>q{$P_4;c?#?B za~PuYJ;$Do@~XI_I;v22TJyy2)^O(PRJw^Rs&c{a{0IvJ$Kq#!;Bx3Oi!zO1prcP^ zeTCL=98TF<__I-L{vt+TZ{4{`uOR!fG9?T9r`hF8ltiq+Eg0AdlR~(i+kVk9Sq)H# zGajTU&7qvy`3%h%uQMvoG0{dJ54k4bQ^sID55gSD*4fqU_8asP8)Co!#u*!F^z_i2 zh0%?UhSytVN*^i4JCywoj;^V)2vOIrXf5gL><`>Tx#z6?A*W~yG$)E_#UK{;%3X9< z^L&K%L2#lT!YcuBpF~}S7C|~JWEX$aZ>tfz)bO?%u-gWdOU0;WSl1~U9kmXuA6r4k_H5?Rwe~tFg>0tQr8Zq;r8D*dlRi8P(sLGcKF;2BIu-;A5>GC3> zr`fH7-GNpL^hR7@v*THA@QQP+8ywfLe09kqC0D4=c-G=xNCUl^-Ql8o}CNBI~LJ4YNUf07dfekoCBDjYkP{<0OrF{T6APu%svOHDYLEseYA7py>HnbTXjJd?5 z$#8s*VLQo*YvyLvV6tajrSt4=#Z8U|r}PPY5bd^V55l_C*esFtFSzC%2n`JI z8-7T~P=OOOfz=P@ey?FYgp*w`(>7RT!!g-(O~4>mIN9JucdN>(3KPV=E=ZuxBBvLk z)elxqRgIpL{gYEL+-&knW}MF!yW6|($FmF6aa!AlI>ddM4Q@V}4sq%G$!uz>&d69n z_c0HsiVr~1KrFgu@o7>TUEVCU5Ghmp5I|0Zr}t?L*{P|iutkYp%)~3n^%@FxfT}UW zgv-`$jL#|zT@Q2m8Pi@5MS5X7Q1~jnM+JqOcPA4gOud~|?S|i%1Z8}`?jbAPzWLMc z3l#sovNW~%2I!NT{YA`(m^(5T2`5e5;;%-0&OEMW|?3ETW@kVIpGIUz(k4 zF+f#;r{ODQICWh>bvP%=5rRcp*@HYU7K2Z0!of&=zq%@*pPzLOIPtZQ_A0T#VRkb=<2ef6X%$&v2E!3%!`CDqB{1gQlw*83q{!q&BY3X-TVF9+pxz!Kg^&J+(9|7Og^2VI`m*tP421_zv-f6#0ju zQfLy+5Vj^~annCf`&0_+it3~N9b4%`_Uj3Pc0P9jHg=2<2^I8=m&t9Bjn#VEf&;}7 zowx->Qm=rTRSHzR;svT4Ozgjq1B3jsU6ebiL8YbC-;Hxm*aL&&E_vX!3q*a40ODqk z8$5ir8ceZk9aOT-7N64D0wovFeDEm!PmpRvRZyNSM9CGNpYuvFkeBtez2-d5L?K-i zM0|bswB_nzp)`U?G+0R2HFu_Q4izG5EZF$|xFU+MX0P+{Sg;nP4g6q9c?wx4;nrq{ zvumVeU!p182ZbR7T|6pBpOsfO!b84a?$#E!Si+44&y;NTmbUYkW}Hf^9@|q_U0J~T z#cy`~V#n?D=z7YLOO9-q5Qc}kj~iO|C#bzX6+DKw z=sfj?`wrxIT)MTo_X1%z2f=-5DcD?B65sufs<+6J0I7$F0pu?f?9ml@GNFy10U`=9A7@TD*R}_f}CIL?$EQg4+a{m$+UxijY zpnkVpGZ_|0dNBM0Vaji2E(`n!I?$ei79C>p^L043SFS=CM+ITQp1R$@1R%4IJ?G*<8q14tMNl%R30;b%ZN1Jub<1hpuq1&cYM|oP z>G5n%y0Es_Wi5Z+W06b3S_}hL|6&06NrxS%BubjSoXy6g*)5Zcm+ORCmJOC+uG92( z++MC`0LCe8Q}CbBy$mR%EBo(vp3moF)D$>vjbFg-hE3IbGilDma(UA_!;8%9A~HyH z-ycFe_9RUE2I|$^VS{SpFn%ZFCL4WkoGhi>*x}8{=;3`reGj^S`Q9}5B;rw6i7WVh za()AaJtYG8*;)~UYWAqEOn=jLIi^} z{6%ZRk6h7PB==CIi6t7L&j!LHrpqrk+T%~rksaw+@i7EI=OvjFFUj0{>qNuR%?+VS zObcW3G3+!KtapG%XqFxD3s{b}h%ppemeRE*gAZ9MnR;)m_E$V@x=YARyGc2Fw0h!LrJmj zsxtn*k6|rDndfI__v!DiosCF0q7H4646ng#$i@=BCB&>)O$w}Wzk!s9QP&#;Xmlxd zMH)5c)E?Ua7}m;U#wj&o{hKZ-xNob7tF(Fi{Ju44WP)8cmLkz4?tNEHNz?>r8u~n7 zjq3(uZIh)yk}Q3HcbB5O&~ipa+N)3L&1Qf`BLVT$!i&EAa4dvXYc&^`Zjz2xh>cK?Y%0F&W#_YqUklhiIWY zK_PGNyRPj4d0g=9wHUk{*-AR5c9NZac?@AB03-ws^JY>R0p#14CdbZMH1WT}#Vfra zn>X?tI=1|cqi1Cl$@aK}BVB)Q@m_jXc)>=Ma45@rG}r6K>!@MT!svoQiM{pU)&SUu zZIPzQa+T7w3bLalKKAa6CnMtyW0jS)R78TG3L{KWCHwmx`m#Y^5&)<}1<=|?*Wwm= zN<6wCNNFv!wcRRGCk>|s`L3&nbs+CUO)citR#|K>i4Aw&g{!N0#de8^g+Q={CDXT= zrXj^mOdjUZ3$XbIZAKUdGpL=3AI#v=Y6zo>8h_t-H|kOvgs)4w66i%EasDId3GhNC zR3WJyvoxqQyhv}vnI64Hqv;e;v9fFH8Y3a8^VJAl|L28j&U*V=tvu=g4Lh76_|y)L z-&11FFgD&(cbV!*oA({}LPBOJk8t?SGxV`}MzL8x>`6v3q>J^t>YG<#+`-B;Pa%c% zc@{&9NqOIK)r#_MN5PQ_?$+IWt2nAw5|V--lL&i9>*#453Lz$&IsW?+qsP(LkIOnV zyh-1h&#UH8s*|#(;PSU7MtF2{3||egZBs^NCckt8XCIz)t!oM>Q305)X`H@v-XJBh zD}DND>JWYmM(j~XSNrLgDf_V@c%2rYR+73s!um#Q_bL@&7WFaYzYBdOo9Bo?9u6i0h;I(hINGR58bP#y z=H8%Y1B!ADnpBP;P>FEFdJbQFm+J#TU_sC8tC6w5p0VTz&4K*+pE@lRcpIt zhFwXwZW{#hS4%KSb?uPw3>K5*oD`Bv{yA8%MOR!U;_eBXH8>T=w@Gr3?b^!a(f@|{9I6I+97Fu`PG?v#JO34|W?hVx(f`CzgSiDQe zl}!T-kS@O#vNsu4kGnW;itf~OZeDw=@n}>C1}aII&@5J+e_aj@@u74g1$2;$do)8t z-lRzQ?^EQ;fw-`W)H=js+1bx)&BTbRt&m!zA3fycprUxL>4eeBIp+FvtS?4_0`Otd z^l`c)o+dz-nMhD-rjr0HiJmJ2IZ%BQ;9e@RY}Smdf?q$H+U|C!dem9ElEp;i04A@v z@zrg>!X8T`FP~f-S-lrVkDw0=62GhARgjl(aru3~p9Bl3C6`5`u`w_fb_t3PB~ z0d`8Q0BtDRNW@4kl|?o~Rt}Mt+8gD|`3z+-EI`2kmSYi~A@GZ!DC}%u7e#VuR~%HE z^TmE|^8amb7HmgJ#YT3s;5g98J-YwUH{<-Sn;WL4Eo+Z$ky#tC!iJN1*cX{N-iy$= zg~u1A=m8r(L6Gmf=Q2}tYd9|0;x-{=HbDql&Rn>F)3=!220ZvWEU()~&}IcxBTZ&E z_9U+UNVM+GLpnsg5SEbMdNpjE-vOawRhn13RDpYb7M9}JI&nk#HkvUqMD1jkK1Jv? zXrnj()S7Pc;?x8KKbvRTLFl2@z`-0~L!_tRU)VW7&T0%>jKtSU%tiqEC9l@mvd8F_&aLLTWEPPSp}B1>rx%FHaRLuuC2RLYBXD;bDw4)F|tMbblb0p zfbDi^6AnEAOCE^p`6uoQ$1|^J8&Jxzi>aGv0f81c!wjuMbysPiRTs}D$CTLd4>x=bySaGDt!0Q;drZU-pvEt$>GB_Q@q-La!p#~Ma zl_>rLYD6Pxe(FLae=0}VBrfIKYa{pU>D(6+^iY|v#x}fn5_>W>?{0- zV3gf40s*Z~rG1KcyWH`!2bs)_&)x+8q@J| z3KgjTS7F#iHlEoJN3*{X8e(h)YwR`zDyj9xtP@GH#h=h8Jge~cE@z8d^oV2lOT?Lp zl!Sq^ypk}R+A-411D?B?+c8i%^q)PQaWS|Qk-Z-T@rx~;?6d~n6OBdE#1Zmios7nZ$U+M^n9#qP&b z!$&gvQ>SZT^c9S8Vj}5wTrjJZ`BANXE}7n{jf(RJotkWRlNi8?*9iCcX?!*-5?#q$ zF~UL&7MEaL*DY6|5!8{LhR`U7OyJn%z^aBk)+)n#Belh_n^)-ryMD18e1ORoS)7Oo z;q0}V#`QGr@ZH672zdVJ1q#Q)#I`cKFA_mz0#J8BCGOkBW?Iv1EMwdjd?Tz)pq8ow zZDtKL_AMC_#RxDPxCxnlbO2v*_Eh#@UGEjv7iM-8@31`XTh8sZlWvjZ0qjpC{`c>P zO>!BKioLV$F+>$*e*W;cuqBHt`)IOC4(vf*IfYE1z$nI88%YV=NBq1WhAhh^#uW=G zl~`Ob;W)zv7!dP|hF&G?V$r<_1PGJixO?>eW%tlJ@ej6Z|qMq)xfso?{irTI+Il>pM$%}v{OyrDt%1huoDuCS;3&2x*6+~+M zC>BoXQ$>IjRVslczylSkTSPyv?-9*kRm>%o)9ra8LWXy7ks*;6gA&lhl-wQH4TaVq z48_Zu0l%PjO0Ag^(Q>|xf+BMon#%S0>0mxbA`CMcD9qKpp#ne_tFe98zz}XW8i8+n zKUAaXGMac!^u#Bk=DziyL_$XH_p>Q?FtA}9Llaznlvx*(QiwuE@jQu|7ScUKM;%k`Had1sHLvWOru#2-$Jxc>E8k;64 zZs-%zQ8ZnVs(Ppy;#r?&927d^flFh32mnmx@!v^;cs2#q76{*YaKfia_N6eV4_3Dt zt+LaKx@^goDP%aFt@6uHFvU!Hf&iw~_cV5@ji{OJ*g<*(?P^_$4KXb8XDAiwdJmPG zzw9qz^rj!s7zS;LOeWr;MUxI&6+qzAdAwbggtd(jlCf&DcW9(X*3g<+fjDITo7bPcBP+CM+g2Hik5a+Z=(Kc?chgri z{KlErK%RO+ro&QZeXI%94;p!a(Q*PhfztZr3j{$Zza`1;4>Y3s-^%2h2WvSt%&6$I zLhqqGmid9(Z8JX!bdanocw_5f zfUGm-MdVvXSUggyhTLFT-l7%`>}qN;CXiS1x z3CmgxezZv`C*LZCe+lPy56~R6N0;R~siB}{F;P${p1`~7Z_VP!iZbO0y?LpP;k9JKx^C^uI^PIh-QQ3z?`ex@xxEpZ%4zAhVhI> zuMT~E=Aso9)0N^Xt3Ec-BH4QM&}3_2;V`6%3jonLdzG<$MKw~@ii+|3r^YEHzrJD; z$eLmT!wK@A2)Nlo-deQ5y0=^{1@rc}7U)!ZjJ7Wa3iRUMV01H>4te(e~p zGCW9<`4OUnCKr6(s|KE{Bog>u>+6x$anM=!B$K=ZRjyTn5vf7idXHvsFD7Ufs+edf zFhoJn1`^HgFJUc$KpA~YSv@$&uULk&b_0zBWr?*(sJLYFBl8HkoY|oYob>@_lcwUq z;}U%>Hh4iEl>~X(d+l-yV5%17Io%7`1m)>6CEnkHGt^%IMQ-^1;Dj0?Qwh4=<$%u- zutTZ3UpeSvFOlvEzAWgZJ)R^b&Aj|a)0Q?3sc`aj4kYVcoBPBzJS;cYw}t(Kg4^P0rb+$~v7RfWhE~jB~OMY*!^vsL62&p^&Lq>=sfWnnGk_ zO${U%)3Ce93&~Jc%YX;=U$3-$BWT5fe_0<>13{!xP=N`sEw>cUbKf>T1VO* zQmeSt<+P=7@a@seEHyn3P>@!zTp}hJ;{rgZCQRuPGY0@Non0-ir>4P2i88pyN|(}e zYUH-jT=$IL$EkhY0KSt^2gOQ0QK1$+3L8lj-RZ7&$@2>EC| zJQ({&OD#Pl*>VXBgR9|_tdPD!``mh1^;UW~N4iQ9bA`sf?8J#saXKl=9BYL^*Ojw4 zImL=#z3rwa!!atn&d4Kh5mr=CVNErNBS3 z_qnn0Z24&dM+C2{g}h$rU(?wtd-i^M{cMijcNp~hY2%sw=;AsbkA5Q`Z9HSV-F$<8 z2#tHS@oe;Iij&IgY9Zg;0F#FnScNw!zQZJ&0UcoenvYj>Mzn!=hCiRZpP4^^=i7L; z%I@$M$f+E^o>4{9#jjIt(tnYBe;V{kahS?n5iwB5eo2PjGqW2pp zkT&n;sMAM#Ho15@ph2*5DgB!+M|X=W^OFrwFNZ()CN7rCjc3EzWC9Cw+4?+e*edU_s{YEkKq4${eNkW*VkVQ zeow#k|Ml?Z|NQ*tGd=$I&GGvB>*mLQ+`NYOe}>QhEdH;@{||G#zW($t$$@_YFLZ4^ z{;$f%8-EwCbch~*^;hHzeLeYs`Js6U?|+ETf9~D?zuT7|>g&(U0eb&>9ethS=l{<; z{x|=o9Ivl^b3ENY{a^22ezmdj_wfhqiJtHG{+4{BuXhLXUazmm>+}C(bNmbW*~YJ5 z%OCpsdw<3qPkR|2|J(SCZjtVd|NXT1O7!Xf3+d;d;7kAbFMcY&*4IrUPVe8Zn!ok+ zcktdnzWHC(@cV~*GT-`F&Nnb+U_r^OR|QGC1c?}Oui_dm$-`WoJ^ z?!TVqKL*GDTXVd=ZhxV_l-Kb7|4VTE|NQTAeSQ6J|Dbq$c>Vtx9RHsuA^`OD?oStw z53m2f@ilF+S+$Kfw{pC`eo;J}dCmXmSFm~h@ndtmzRvw02Y{};UDzct6}tNu=JL*MJ`uj6?9&tCsG&GGit$WJ}~3;n~q?%-hJ zeZBwR{~h^DUw>#8R^@|USLy1X<5>Ut8~@Cl$-MqwJ+Zl-9lfxY zebM9e{UMI0&-5~1=yB%tXZl0)`bF@*XRf~)e6HvD8^P!Ftn|-+Roatpqo literal 444240 zcmc${3t$~Z^*?^o5=eO^Ed|0uh`dY%N|L@(pqRA1a7!QDwiF@=X_}@@AWdQ(ZK@Ok zX)xDoAo4P(U_iv6f&l?TwI#Hr2?!V}LO`Uk0&Ymr2q+Pd{yyi-?C#mQyJ^v{|9_O; zJ)fC5bLKN=&OCPa-s{2(&L5MMG&ZFF#)i%dCE>c^CI#eaymiZg`YII43+09m$G<0s zP6`ov0RGFL zf&Rf?1OMxM&RnZ%us>xvRo@t0!28)YNtLrdWjW#|I$br;{OmhMsjE6xtJQXrb}H9B zPn9!2^K|w0r_CqXNdHAOpXO&4(&*3rG|M&Ua^~kLs#wVWq&n!2KIy-dNvfdv*-Dx4 zXMft|mcCWHlCDkrY}vNY{T+G*Q3RNu6E%6HJD<{xcHoz?W(cM9Ksw}0*t z#Z!tqiq0x8TQPm=S>-FwEHA65t3R_oclw#rr%tY^oSZ}YLoeVz(x=*a{YG3e_FH_u zSn|S}AKbsUfiSd%+>g)S1=!ya zz{64mR=;|m3uy1<0e1c|z)y}1(6bqp`qf(*(2s{?_~)M+!1LMwKU^H3=fnX2UwV*# zy?@3)^Rxf>0R1KKXTSb>3**91&-0)2$LD}&KRvqw#>)l-13&!}(eHkG9zgu`%ReE& z&b7$wm){ED^U@>y^S>J4pMMW%*Ruh7&PR;#v*-7R`s3RI{Ac0e{`p_S#Nem@i~zqq zIKcjA5P$siydU6iUkGULCnx&rc_^UY7X^&RiI|xD?D-_1-!}w|_wxeyDMq~V(|>M& zpG*iCUn2qI`j!A5+5_zQUVuM59$?Qe0_MAu1IGIw1IE!S0sgr;pkEpT{Iei{pS1z~ zI08RB33Z!)M+ey18_-`f19%t?7%xWz@IMd`f3^hp+ZixC!!#c9lbDbE;@B?&=Gm-( z@pW4OpYH{Kg+bvrE?x`h$72HKg|YzsSs=|%e`|oA>VPGq1Mp|FVGfz-s~P;dcY# zSa$$#8v^_d-R0ZA({??0`wmeVCRYe zKHm>mw|pyrpBVV`iyL(TesyAiJv#%&%M}6hOEf_LhXL{Guz>OVYCzn(C4irY1L9{+ zK)t60wCm1*dS?XSdjfbX42Yl42jo94z&~dN^zVHbzkdGqa||Rud}=^^xHw=uZVy=R zow0|NSGO2GQ(jR1SX0sin(zo)9;z>?G{@MWioPc@Zwt#jO z1o*>40rB?sfOg#!!1KESe|A>5NGwzc-f-)*;5u@P+e42T2@>$ueM}O_VnV)^768kB{i3p)s_+x zj?Q0NxF~0FZT1WjmzI>56xWtjRxGSsSrQHvUbZNErlTQRR==jGiuL5wl+=dnYfCC> zkT<-@sAi^{v}Atn;!BFE%Ze&$S=&@c+tT8aijwTn!6b+*dRW&7K$=saqT1uVoZ)a9zRnb@LO7g2qid4RA(}1jXr6nchy6PMw z^-?D-*n;f;n2Q-sgDx(quVr3mg4ekvtBUH%YYCfESzcKkUNV3BV!nbA7tix;D48cZ z;gYhFb#t;orO}?~jK!Chtz2E=-xt%aE?K_>4p3B6qWPG)cz(%xzUB%N4MrtP=FeEX zw6?meVs%tlK&_!N^ZmOmx45#Rwy3P4hKoll%PMNmH`+iNW)!VlTU1e85-y{}oau}6 zSJc#27ZumqPQA3WsEYkyI*5ywR6yO-#rWJ;_FQD2U0qjG%H;ADTWb@}5jH6?Q^>o6?ml$RA>9pFU^DVxip(I?qcS5_CTn_X0V_3G-%x{8(IXzt=DsKL0W zj$eZD$kYUQ_>7vms;bKB+8TGvNlzda#c=fD_%jT_026Xnklk>J+)LyjWD)1PczBsVe zo-SKlS5mz`%prWbh?@%brJbGM@i(7gU@(?FWmRQyUCl*x=v)<{vlpLFh%nIXS{c_r zyM;4&WO-we8JkBRRnwT%uw>C_)y$Q)V}+yp;de#@XV%d4{V&i>jlQh-=!rrkN;d3yAMCF?s35fw=i8qi24mUdo5sebaoc^mF@=5u=3Lq zYYN4+z!e*oUk$uxT^k1FXIEH7~FCDGKH(#m!I z-H1?8w2p#)jhGzDqUOx9-_wO%W%g8zx=YI{R#vXNxU9CkM69LQo7~xu0u32}_0~%K znKe^xTPclX6`grb$mZ)MSkz&m?(3tUxnE6Q-6&IDj=ezkVwd5mbBch0s!u>>MXfe2YN^S47(X6nmX?&Og$Al}U6iwv{8zdV~s_K>FcIbVW*18vmRT+iaH&-r?{&&?v*)44(=R(HnVfeYA#w) zQ(RYFvU2u%Ooc|=^PuTtaPjk^|1(w7E=|CXts-S=m!^5_^l1l3_vDH}8- zxTktkI_M;8 zW-g8t)s%ADl$CV$P+CYUYdYIHe{B?QJarM>TZpbDd1-c`?h#kzjFn|IIMzcJ%1nyX zz9nmMesy)xde)q^vIHB8N`!G_TUxk=&zeQe30Bz)G2^t&y8(4G;c%yrZ2v@Y)wfujTc)nmA0>a&aj+7 zGNq_`b-2E)Y#M4Vs-{v}*)+Z}q`JvIKF-eK?%~E}Xlnx}-$+t*8JVQc^pQ4#L(JVJk=}b_4A>$dtd1b94csAXw;Bh$>`vEG9iTz?ak%`VP!#ZE? zMrGZ!I#)#4w=c4%ud1$GlV4L@R_1u@e7!c1T5@s!f$ea6jc%gxCKu;z*fY>gvBKJ- z)ds2AM3AFe4hH4mvXbm9w>5fLUOdm{Nwy<FntkV4CPfm9=H7)*}{Zp45#v zWw$-Vrx#UKIn#@y#I4pnT67Yp>{Gpy)&Ee&^{Sb0wWX!ibrra~LUw64pHYjEQ;8F4 znimnxm1it1TU`MsqkP%8b>fX-*;$1gA99<#9@X z=Gx*?uemF5?+Ue0Lv%tFHtB_H%c^VZipo8CtJS?pV5{rv3o)bMNUNy4tag3j+AP)H zT#unNTNGB5*u1g(%wJlIOhk8CIV^_XtSKo}@vN|l54*Fc7A{07OldmItx>bfew57S zlJ&KPE3U2$)09-P&hDIQ+~GzS0=szL(%PBSA55ffAjX$X&a#SiI1wydQc_d52Hi+E z`irkFEH1sea20G0;r=JwKo>(WtS;x$zvlv!LmP2CT!p%;XvY3PEwGAYi%VUHu%)UGT({d5wiQ|{HpsFtK`l8P06 z!JIjTQzmDHE?6*c_MF0;$=Oq#%PH<<4(hXWXtbaJ<)%)~nW+-AXcxD|T$vi0Q&5mU zdtPDo}mW-k5!Dp|Hk5f2jFe1195!-{yT^>`Dh+mR%8qgR=@)u0Eh+Tlj1a#TiH}h9wDov{;E>Rh zB;YRzH9eN0(xZ@X`}Q4pVkkA#qp?R>K0LHj%XP<=;R)1np+9PQVp$oU7)l8ZLZ-hY zctTr-(pLp}{Rq7z`M7N?ATMG+xWKlWxHis0W8Kw7mYspTph*LuY9D zcR#-xPZlMIWXqgUr7H{ak=Ngg@&|?H>inmE6WP(m1y25?(0ZL8A0d@K)|0+U zrz2UXk8#rN_efC*|1G~+eHQ5V6m2|1ZW#H%EuI%hL@aCC#Kox%j2EI|}w+y^bi#wGssod_0hWQ^tMRmRy!}<6 z^`sm4;W~eYf#+#FqRZJlXHHW7x!k}fYrNjTtMZi{4F>+LmCF8R1K*^yeCQ zm)2jeKW(0?rYW8q4BXD&YTykzf182Z`8y1}Rp;+Ca65muf#0q3_ZxU#zOvIY@CJ>K z7B+6hJo+?z2Y;|z$d<}@Q5yF^Lg1L3XdB2y&5kt@bA8) z@-H{=PK}ou_zsO%8TjtaN>9CsKdSI%18-QQcxW^5ZjE;sc<3UPzstb$G~R3ADN&Vw zz`!G6#j|DLX|E|ehYftT#?y2;ljn2;w|UMm@Q+?q`ZEpO<~hs2ZJu)t+~zsYz@O9p z5H;|T%M}j=25$RXse$*MulT7l@bli#{cGS=8gJ9(On%x8+~%jlz%#X;P6N03=`wJe zpKb%U`RO(Ak90rw8@RPv`-y?u{0tj-K}7L0V&J>qR{Vr6Q0X=g6aS*{3|-E~?QxoE z;5I*52L7DZpKIVYKY0dj^Aj=fOLi-Jq6VJ1OX156JXEXrDK&7LpLzrD(BDVWVBl4M zSNfX`{9cWB>T)(eU2#=!ivGe68@J`;1vRI z7x<3_-XZX(1>Py}ZwtIj;7bMGEpXbe+JC(QUu}c<>=XDk0`C|29D#>&Rh%I|+#&E` z(Z3SU)aza|f2&@Xns}dHPnvj|UI&_ZRIm3;JWH=zOngMovnJl4=NA)C(Q(zpTXj4! z@f5+&Ho?z`;78(Ff**& zJXhE+@jPL_#8ZU*5^ojuOFUiJFY$I^zr@pp{dg76`AZS@OFU25FY$=5U*c)Peu=jU z`z4+s?3Z|luwUXC!v3j_^*Fx~_Deh>?3Z|_7+(?}7UN6eSz>%iyh@BOiAM!L5>FTW zNW5L}Bk@eZkHk9#KN8Or{L~75(gi;fj|zSy-X-{v_=w;~;<p*);O9cYPln(};st^qi7yxSOFUE9FY!)czr=He{SxmM_Deih z*ngd{KU3H*@#VsPiI)odC7vbhmw1=3U*dVfeu?)A`z4+y?AJ$Q+=?t=zr;(0{SvPd z_Deih*e~&JVZX#9!hVVO3Hv1;5%zZo{&R)>60Z{WOT1p#FY!EKzr=fm{SuD~`z78l z?3Z{{*gsv^pC{~>c)hS+;sYW+NIXNIU(x(4@#P{uNW5Ld2Z=Wbek2|d{7Ae{@FVd8 z!H>iT1V0il5d54k_=yO9B;FwSk+>!Jk$9%yN8+V|ABlGeek9&3_>p*2@FVel!H>k3 z3w|VS34SELT<|kl@DmmMNW59_Bk^IukHoVCKN7DJ{7Af0@FVe7!H>iX1V0iV5d28I zRPZD5VZo2YO9eku1V06WABndLek493_>p+7;78*1f**-@34SErCis!~a>0+pEy0h( zs{}t19})aWyh`wMui$67;78(Zf**;8#5zRcd4eB_Hwbp+0;78)=f**+&2!15qCiszfzu-sWU4kEp zHwbc&p$?;^~4PiMI-Vz9{%<5d28IOYkG{48f1YmkWL*-Y)o&_<-O?;@yHD zi8l*=B%UVtk$9WnN8%ZRABndKe()7L&R?_ON8;UrABkrQek5Kh_>p*r;78(?;78)U zf**;u3VtM>F8GmnyWmISnSvjQw+nvC9d__N*@7R5_X>U_o+bE^c$MHs;+=vYi4O~Y zB;F_Zk$9WnN8%ZRABlGeek7hH_>p*r;Af)Xr%mu9@jk(i#B&8d60aBhNW4q%Bk>Wz zkHq^0KN4>j{75`g@FVd~!H>jq1wRt+6#See_-PmXNW5S0Bk?@JkHi}UKN9a2{75{c z?~l{GBk=*jkHk9!KN8Op{7Ae@@FVd&!H>kd1V1MVemVp{5+4x!NIW9=k$AJp+7;78)!f**-T1V0k*7W^y`{B#O_ByI_QBpwy~NW4|>Bk?}L zkHpgiKN24n{7Ae@@FVd&!H>jy1wRsx3VtNsEBL`z+&O<;f**+w3w|VCAo!7Zo8U*{ z{emBfrwe{0J|g&$c(>q3;t|1*#QOw45-$+^NW4$*v&vy76zUfINPI-_Bk|>eABndM zek491_>p*q;78&iaUV+Jy@DT!M+H9;?-%??e7WF9;{Af3Y{5^j;78&iu}_zHso+QA z9fBW;TY?{nX9|8Ko+9{>c%R@$;st^qi4O>VBwi}`k@$e%XNKUXPw*r06v2p+7;78)=f**+w2!149D)^E3u;54H^@1OX4-0q3;vumPlz5)tN8%ZRABkInABk59ek493_>p*n;78&kf}gtuKbGJ};u(S; zi8l*=B;G6dk$8&WN8%B|kHj+tKN24n{7AfB@FVe%I46{Nv*1VKA@Q8Rc)`!G;78(_ zf**-z3Hv2JBJ7uVgRo!XDZ+kF@tP>=jE9{qep0HoyDZ+kM01otHijI`I`gq_5i#q0JonLByObsh~Qu1eS&|9 z7YP0(-XZvxc$?toO2Kodz>g4kRPZD5(g3_q_?67xCG3%Suc-HQQE!{jf0@AhMO>A5 zx|n|@ULfMC#M_1b4MP8b&@b@}p52>q7|{g%)#@l2s#;-x~r#Jh$5UkLpn zF~3MWPw1C;gU~PWUZLL}b5u==&@b_b&@b_3pr3;hx=5c(zF zF7zKM^bZLA63-C&CB9tfmw2hbmkIs70`C!cpTJKAZu`nW06rXmhs3^K>S+*hN#d;m zczXce8Gv_OG?rU)ApT7j?dlXbUW9c1x&(fOgW?=O;H3iZ75G&G?-O{v!21RMg1`p^ z-XL&G;NKGXu)u#V@HGAWc@nVi3p`!mw@G|~;^!b>V+5WdaFs(PW(pi%neY5%37ojL z|8fORb=ZG-0#C6)d`1L5PT*02A1v?!f#Zc)=Wn^d4|mW|s8rw+1YRZZqXk|s@M8qt zAn;=a-YoFr1l}s};|1O(@XranUEmo4?-2Os1>Py}lLg)-@KXfdE%4I>-Yf7g2)s|= zlLX!`@G}HHAn-E;28q{ zy1+99eyzZ>1b)51a|PZc@H~OvDDa5Dzaj9bz+(b05coF*zFgpOftL!rMc`Eeze(Wr z0>4?{4FYc!c(cH76?m(_Zx?u*!0!-vyTHFA@D72u3A|I_cM7~q;CBhUTi`zwc(1_k z6L_D%egHN}GhPZ4;hz|#c&u)xy= z{)oUc1pcVNGX?&bz_SGYxWID-{!4-93A{_-5rID;@TkClCGY})Zx;A+fo~CbslcBU zc$L7r1zs=krv%<0@T~%G7Wg)Sw+ei_z}p1gEAV!KKQHk8y?j6QgpVSPdr~6ty^SXX;_ujpGSGBU7gxUsox-u=0 z2e-O1h2X(QT=@W!?{(#5l5cTkS{M)B;L7B@gVnA~3*o^Pt~`$9C9X^h-@)0gdc4b;%59YWsEvyGma%Eaj4^D99 z6G$H8%Jcxi;Cuge+Mhx4Zdd+1$va*7B$Btf^2sDW;>xFxe6K5?O7bnPObhM78(jGd zBv-p~Cdn&Yc@oJ>T=|P6&vxb0NzQR)T7VCpcHD^DZ&7FV85@(r#$gXC&g&Lw$;E6*f(i7V5BesH!c z(?WhQ$Cb||`6O4KMe+n!rUm}s7+3xh$?tvav_FsJ-L9NZ@=jNtP4ZS(oKFK$@@&zPUyK;o&6|Ovwu6AXbfCg8%av8}>T=^=JXS?#%BU!hHyQGchJ39duQlWfLtbUbR~qsqhP=p-&o|`r40*aCPd4P!4EY2@KFW{} zH{=5i`O|G)e*bC6e>LQ{4fzd2e%X*;FytMEyv2|oH{^#5`F=yb+mP=t)Z#FyvK+e5D~@V#tdO z`Fuk@&yc4Z@?=9k&5%zp-OkUxFO=zl~0t0BK_$Zr_(%ZB`dA@4BcEr$HK zAwOiu_Z#xvhJ1%1-(<))8uGP^T^rn z&WpWxWhAyc()i|Z^x|-KclI-pmRVl>v#gB(I>4 znIpAFV(WS!U1RGyZtp?hTd4+_SmxSNNizOr zdLHTY1#rTG)W<`qkN3G&ex34sQCGSJ9Dw8=tAx;rqnBJqd4?5h{Z2`)lfE2G)G1lv zQk#O)e@I%ti*)qL!KqEHcFs8L3X|P7)nFUF@Ds9eW?$VrPfA`2l5R%Qyx7b6e2lap z_7Sqx9^uJGzFU_HsIP}Q7;96zHr1P|iYJ4sxR0xNDStDSUJ!d{^eUh{G)UGMMzkFH zlCI)>PYSo<39e#i{;yOOuLV?rQ9-Rh=Fm`~M+>n;b`ncrPYUagvHre%KFnJXdp1D- zAxb|+M5q;~R9X37$-g51%KXABw$VtV@r7}fhH*85j3Yc6;6|-*;7B|#lVZfNGGQGh zAj7f`_wF4!2qSC3566U_Nz@gq8;&$?7!K7P#D|bWQ=w!S4cbtF!Ka4VBiJvX8xJJ) zLx?G;J-%#MC;kXAqSd1}gKUh|eGsEO3oVs@p@kyxx(~>t_h3>iJWRE&PeyG+FyMnw z-AMorx$daM{NKlZwQe3{4(8CRwtIi63w( z9jw5;N3y#kJ>dZeA$(f=*%E$^Bz_2^?vnUW7g~V20Pj&s3jfCw2oP%!(*qB zpBxYQPu2MkOUO@rTCut}W5mruMDRC5b;ofpfY-(i1ED(VlMy0n=ZSFQfZA-&rLTYV z^<4U1PEzu{547j*Z2wH2J5=v@?#Mq!@!X&O-DD(VU!L0x&I3F*J_Q^W(PK(I-8hR@h{-klkC(g({7Q$W(V{)D$RS7cE z30+W6Aep>Gc!iEGo_ZZWp?c{+Pvn;o38`m$Q|(w44+SgyI*K%Pr{3P}(JI;+9_a}W zBNG-1!&~<5MYDUXKJXd~f4~uIV|VRghzn!wmM3deCLUlWlB34a5NGW|J&&k1!t8z6 zAA2g+JDmE|n55n-L>{BHSAuC!>*}!6Taquj8zZ+RN^2Di2=$TNjz$oN*y7U!H4;f~ z(@3?0v}z>7MjE^8sm$X%T2Q93dpXJXyK(`^m$-72Wcre5uA{L#kK|kgNiBoh9%~T> zmol!$TJjzbgv55R@jce@y6lz_ZCw6eDdZ*QZ%O_E7FTAwQCq|C=rufI*N~xW*!8Y| z4P+5kC5_#1${uSM4ssiZli&e**3f+O;_z-T;M+S|2g?6owDPoC-ADPt(aJxRSe_zi zKUnW4<1gbLUIuwdN+iAzpW}GCZ6XxQLB%Qa0TDmoZLLjhU0mMV%PB0 z05(5cm6iy(1Mn0Ze+n{&;|s*l6s8}Q;riP{=1idY`0r{M1kG#+YBJ{ohD7TYzw^J~?;cUZ z-v<8|HC!rcXbGr+Y3{MAku`x=VlcMMLI=9Bkofk)8}~#p`my(|>qZ%Du{LyvYH1%q z+u=TZ0!Cn<-B&C;fX_Z>F^Uxj}B`-1SsJsCW=YEFhuh%~OT$a}Gr;ggNS zwxsEx|IS}{P8yD!6SnI5J;smf#Y4wH9ee+AS`*!NjWmWw)F?S8JY4t3{ZywF_OBgLS> znd{TJO+D88Z~4#l;JD*dLTlu9n7b01!kpD^V9hn zc}_uW!}k$OTIJ@pADi3wvermT-S;Cc;qE6=QKe%glWTDccru|m6H zZAk zDmC*}{MWZC^>5Ea;>lA8ilkP+dtb4Rx{Nelfn)h_XMPuU;h`rev~9}7KU?UEC^-v{ zb3|GecG5VY189J}7Wq4OuQO)1l9wY36#RqpW zOzUNP7R3HyP2GmdQH)!?AhtZRaVLf?DWcT&UGPe{KlvE`%Zq3~vw%NICR>wbZLFTk zjQ|x|+dGhz6;m0?aDh@xO1VeXUN<=%Hab)t@h2X7x^9&XbJ%!gi;}T{9a0As+OkEC zWw(J5hX=eY=gS2wI-~-Ef zvF=FxcFrDeq3l-EmB`L{xx<+@}blx$4?+mC<&Vyv35mgFbDL}F8#YEZh}pqAuj zj_getDk0NOh);U}TI`1IeT+)%eT<5$TLG%UTq@o|rK~5620uZb)RNqq&lP7O3z(#n z9JZ__`5UU@Je3f!6XMgdxMGYj41v9mQHi~eQE|KCJ}}Lt;w@B)8a~UYdzPyErqj9Z zDCO#DD!_-XyHVA>TqTs+3Gr!<;#LUv7}rfD_C7|%W!+pV-a@6Q?zfG)pBez(lH56! z>#m|)Jx%ra&~?w?y2A}P!f$3MKJ7eDt(14~V^mPox~u_Pq-Lsbtx?}%s*fTC(q6?Q zgZA~&c~~3J$(lQrbI^JUo-?#ggKEKGN1oIE0H+$d+>>SpkApewOTKA;eT~YU>`BW& z+sILOa+!U)>6{X zs~>gi%h^|}b?^0iGSM56*ydgw0GmtSmgMp4X_?rRg?@+oq$?>`Nhc~PPf4dKiJjlc zNnVO_IwyH9B%O1)lFn4+*m0el?4V9g@;#JOIpL!%$s>G2BHWD2chx19q{+{#OU$Ur z530*{T(+o7EP9h~P?wlZlh>(BEQgaXRhQkkJV{;l_B8c_4s>>C@ZX@Pr|ETDq`Sm% zPQ?*e{I;iwnK&myPU^#*>gJ|bkXd0*4J2dg?|v`!i}-Im2Rc>QNJxj4hRsy&($uCn zs(msI|5$&ZF15D^n82GTUnI_YoVlAe1^3TLviBQzWgrhnWl}+jZ@t2WsDm+uMI$XL zuF`7%6>In9G&q|$F@8Ih)h8FJ{d@Ngz6BM^uGy(g6d06UbN1J+hVw?TYoW)k0MpSJw6wLuJeQ-})2Jz`sWw$O^6Rm_jt6>WRlBS|KkjaP|D8K(n`7FjH&K82)VKBxwacNKNX2_Pm$+jqBYjzP_T)n)h+ms zm9Joxd!Vv$GyRK4Lg+;q)k}B1N}Z{9+U)|nlQ6D#UTVd2df~Op z`r1RzKK8B@)2~{7FI&<^CdGMG0=tK)l`ZN+wQLv75RRjfGVN&hL(L$bO9`naB*`Yc z1}F4uLdd5HFXKsWpCf509&A`;AaTpJS>F79`Vx4`y9d#;yNBjH%&)EQGt8}s*dehMBzU5~4mm2^~ z<@!2jq(_MsMhF+x;oS|LPh9Nb^Ds;Df>Dl*}Z=6F!#C_ z?+V#@mK=dVlsp?XHFaN`8c)u}Ril*@OFj!1@#IOIka{=YD`}3V4<&ieK(MOW&?T1- z^jHX;yz@@6$Le{EZmvJKBm5hx5wmVIuP59$0l$eIX`yp@o{P?duffsNdcx1qVF)rO z4bo&NN?>0sOB||79EK7U7pcV1S44I+N@o8fCOaBQ$d249`2bNsqBX!JJ{sx zoEdG3FMCd%3O$OQOv8rXglgxiq)3Dsgk-%@{~6*jo_)dgfNn$ZxI6uG_K>3U7>A-w zv?mhs7;Lk!dAc~a47P(=N?%la;&bS&J- z$$F{_cdD-b9`r`yQQS>{0y;}v)@!|j?B40Ekrh0OO$oSwAsZeI)m`;u1}?2`3_me5 zsN=}NxlVvpz*Yhhr?qvTbCxAn;B+;0;~$}N3+W}ZAA13D?KcomUs7GMsxRtS-+HsY zCI0nI`@E;V+OIlw%|l&7D^wNlzUb4Wqs%J)HpjO~p;Nt89OhK<_Vel(0}J3*?$#Fa zL>_P#;bkE1oj7ivDd$XwK?La&!NH$_2T#1US-P3j`ULnHqyWL_tlt`e+AerWK*3Le zQ^9{ifp3kU3n=)sF1Q&5X~1}5ZU-ecZjYGfzxM8@AML~LhZfce<3}yG^;l?HPRoLp zrU-q+Z)ZtS7AF>4nxY8_k0W7lTneXhF|;m=9UoOTm2!Ul5sD=9K8&6^RZy&F?@ssH zIv4M);h~v(RzI6)OkcE6(5X#wxKD>XYM*k9| zi3Xg>#!Yp#(a=xMf@uqI(GqTr->wq%83rA5=Hu<+7TkV`tDaEx@4>9aE0WZWxg5o8 zzN`hm!CP1E;yK)jm2Qiiq#s}zArP-_&3q`0cz*~QSrRf%6kyY2EUqE+20FeMt#+Nb zGk&{DOmJe%g3^hX_I(f79ZT_??e&O7pigT#qSJAgdTOXkk+PB&ExCZvew|QVwL;JkG{d688 zX{Aw9#8IqS`aFRBZ?iL=slI-%V=qH}t;(sB8ri9_t0UhYd)63sC{F|VmgmE#Xo zK8H_D_!J!4Y;--N;fA5BF|QU-31nT1kqZU&tl%!1uu*~~B>sv^@T&8Yr#Xc)v=r2f zOpm&mIKQjAfKpm;oNYtAP~Q$7G-tJ{R-W|E0vVgmKzp~;lP{t6KY)8R>8(dvLP;_yh_zr2Eq!QBt(ByalEi!5FK#Ee$9jev z>s|6ZMrqe?r1DHocbYq2|Txo-CkN!oHIg%B!WgT0#Lm?kp@JXasoHQU5|51wv*av0E=ldwNKu zu5qBL&*&TMsT(&^Q?$_@WmQCiN?6dc+%~qj-_EQb`rQ^~tJ(2dwEw+9h9A#{hucv# z{&T9nnqYpijPHhh6XM{XFoEr8x&UT7ra1ej+p%S51{WZC@MAcQZGc*g$D1fYt;T=H zx`{+`Gvrer^lWZAKc09y1CB9!U$pbU-so1({J>42z*0}DTBsejt41yav3v`8axRQf zt!vO+{{dXn`jVo6*6ln$@~aPB+dWJlxNX0f{xZH80Zr5H&mS>n`VrX$+DM1*k15gR z`&bMW(deaE7LdKSdc1&H(rZ<)V&}(gSv-%C7HQmyUFQV!F|V(cxADeE_QmyFQS#Y% z)5u|<=MJho`7~hUA?@d&Ye&YV{s2pIelPGanfdVV*iMl&G_mnP>Se@Z`Us`QMi7A; zHnYd1Hr+#HlY?tFR+c|{uxeVMgWvqre$l=g4hY&49sC^bk1!m=!DOJBV3&a(L&RxUG-i)iS0 zDFK~g8_RK*GwT-4$H|VbTi(ZpCv?jD1iPIw0gWEy7ZBCJVb#ijuOH+YIEfZsvVRsn zfP;Bo3&;3dxY%o96~w`uG0>4<;lE)aG#9A8;SU-(zgGiC8_ck3(T_GWr8=Wu5aTi} zJaAMw9yqheGxRL&>7$F4LMk;{AN?3d4!#V~-4~yMa}mLAA5}mcq^%KR=6j7QX5KK} zUQumSj~43V6ndO!Ys7WFohrB~E-10bs{GYwo!}N`qi*j6_Ypz{O&E82xGtrhP+ZUa z^?teUx9Ds`ccHyxNyLp~ktBaQ&WkYFunHwMvE=K9N^z3g^j&>F`qAWN;3h=(Ha1r6!#A zKH)A1)QLWI7LM&Xu%D{pFtezS`?o&f=`4K`gEF{HzYMqE7osdLLLNAaC^4+s0?*+^ zQ!Sb>I9b%)(%Oc`#hWNWg}+XAI_iviV3Een^btzkI7}qy{Q>qT&Jv1qIkxi>iXnK| zVTRFaiw&b;Fs(lwqd%Ao-P{g(+>$xC2R(>oz_p@EeV~WMhKi5&W`***OSky#s(RM) zD_CG_@Sh@?6W@rGnnn$Me$R0-pnM zW3_>|QaZmgW{jxX6Q~5$Ud5ApxED|2hI*2>TstN-!8RpM-}JzK@n=LO)sLR##&eI8 zyT~^a+&3U%b$yBaV$}6mk7n_hKL-}{>*g|kBk)-GO*HpSURvz3>Qz&*XTtp}Wyzht z^tEJmf+bk)v{FN2JRl=6esoM)q{0z9KR-ZBp@DXUIPO(dWm4@ec*e(t76KYwe#{$<+OaXh9V?0gJU!s?S{03sJDvL04%>E{ zpGK%f$LcOT!>;=Twr^RplDX2iFfGtd{t67gE|>{r%SPn0TF1f?@$SNB;-~84Yy&w zgtsokFso~y7aO5*c-RHxFIUir;cIje|- zGv%onYkmhOMC#OxvZ)tS@bJm^s1_J~J>iK~>+)4rQtYWf83rmIJ)F2vAq?mC0Z z!@j&&J?y_2pL`z<&uz&k{_}w|fpk-60ivY+#CdZh)!EUJZF!-;BTm~r-+X_-X0m@NN}iL>A0LU+MUJKv>f^Cg|Jf1(490AVTZle==7JJ6YW2;$gN~PS7Nh5il4xeKeXw1)_^CAyuRKB zg?4q{SJzC)0u?pjmv%kf4*#bp;=1*4`4JUULqr)LO(P$An{0|F{{Gc^+TOc~Je2%0&pQOh!+5*8 zBh@u`!_%b3Q%|?^qR3s!m+fvifr_baP$sEvSVs+yC)eY{(+$gLY@G?c^n zpe}@aOzI)14!nlg5u&e(!`c)n{p44A&U>8I(9W4=PIiwCfUxHIB_LGXWBn*kJuc=x z{gS%zF`PdQ{uKXso~Kb=w#$0{0d)F;#78vieu5T5;~KQwxEpmWF_?HaYK|^(PGX5t z;wG`gcwJ(gE|Ku~XjXu6{lLk%J}5AZ+dw^)Sk?Wy#NCM{euL(?uUTlWr~9iZ)M_r( zYG5&_#}wOR4dW)9QsXqkj&Efh{v40j+Quas^)`wm7}Y}e`4ZdqEb@{CTcJ+(v2E1l z!A8CGV}GNr(b{UYHnsfVCNB0fYJ_h>_QT!D>6}&8G_B@Lj~aH;(0TCb#Ab}uB|gTd z^-oxbC$>rx?p^Blw1Zb?KLeRgoTRnIuP#t)i(lZ=Z*B2I;5s_&vL1pn$hAd3BAaJz zao7D$kZhntMNjbRtmbnxfD>0|)2Q#+b$GS#PqJEj(k3E81u?egx=AKyd zI`sEg7do6YxHah2S&CMB2j!2?`c4=|Iul?X5`9)@U-VWrAH>=nR7hQ`L(K08mkp!N zx)v2UQ`P649NbyTIPR=<_u0#W%~YA)SzJxak>|~Ym1=^RKxgRi4!JtJ5MJV07Fg6s z?Lw1Kz`HE?=?|U$YSTGsS+H%6Q^|vL_Uo_$Wyb1kl0!Cg{}B}0)qSe2d0FrfA0hMd zL)X*2#peG;#c8)*ogIYsYwlE5wJeBG!!h6E!{bBe(I8Y*+u4!riV|XO zN>1ZSf>&qvdi}Bn3hi!Kr>?mhzCdc2tTtVbyE@y8v5PWxH#AT&#jDDyy5Uu_DW3cq zK0Mv<%j2AGu(KoE4=J174U@?qSR;1>XA|APazZzh-J=WX)!8#-C9SI6)!AC*XPAG& z?SSR#?BN;O``y*qZb0tpY(*}ajS+<gzNkQ#a!` zcl$S^Mr*rTYg02lFN7jUN-*kgbl99o;~84bDTzjHMu`BUrUw}H25@TP%g}0c{4bD{ zVAN&)Mtw)Cx!I$JS7$4xQtu|L=Sp;mD^S8JAi-yK#^0cWbF+?wv()5&l&D)u*zP6| z(lr{fFdf58y-F4fKZ=3T5s9~Ts3_Ql*mm74CxBi^cRE|b4{yofUhA=v;f1M>FMAl^ zBWkLf1O!rd>Ms{Q5?}TxCZw+X*faTE2crZZn^BdeI+LD9Qpu4xp5a{uRYezNJDILM z_VhVB)Q`zo`FxaTvuo}$vy$mQI@dA%X1bpTW2m0|E*PU{M>ULktV2}n?bar}{(V*t z5qG83HJjARw*`qJ=NmHUKw<-N6i;4@4^OO}f0T+f?g?q?#x~SFcoY6{J%_8A2G!DY zxV{XkkNv=NdU^$!1k;wG*@l`NBqgYM6}K6E)EuSN91b04mh)cvD4z7wV%L*? zK-aM57_>IQlRD8-kWSt4rE{F_2$4b3lYVuW=}EhQP;ZUuNhchxGU;x6nudh-q_=Q? zj4Os^uhO;hByCUMmP5%fq&=+4^l242-!rq4>6f4Fm>y=m!JfqNk8NPjyyd&DNq4Ag z?%DGlllbd$=o?MQlco?y@#Lxa@OV-Zmew?D?T;r7;cz>_1zx86f{C7V1epXD4neaG zPqOaxQFF7un&*(0)NF@3>q!!nC+RmT^AL`D%^S^p+mTi=VGI34vCh)#<+d#D)d2xL z188U-=R-B~a5q;i28O{&FJEHePTv{`(qFOu%@&BSSF1RhHTIK@7Hh}%JX57AYW*A# z)(GuT0eip(^b^~3$I$r(2dj6w_JsNJIH_tB!$MT-)io#ck# zTlcvVPs7dtgofQ|H>??QLc>zIVXf3M8u1Zy7F@KhGhzOqGZwz%#yn1-W4;)%PdwsV zca_{Xv=EI#Zv(-r707{B<3GsdY)$RwA$M_~(ff*=awC`J0h14FYz6ZPrdKvuA#b`i zVIc60d~OsB>ak|(M!91HH<-@;j_rj1S&!wNoX}%m1?2YF-zftxNd0|qJsY5WFsR33 zT#2X0qJU(N(X#*vJ$A(%ul$G&C%8bs$9(L- z%K^9RT3&bIdI8h7F>^i6JFRWHK;tJ)3N3m>4Ri360GFZN95uG3mDXg)(V@$JZ0Bfc z?e?bp$xZ3?rcC+?l$$c_E%ReHMX#Xk_O!Su zo!&Avc1m(PB_N*7r-$0WivCK#X8i)N`X;$0)YtYI2dx;sn!_uGtMFkT3#xCDqut>< zwK$rCTIC6`0{5HbDD{$WJEs{Qf4UpE>K@#s#yaK6OlYwBZxc0hRixuy*duD-orCk; zZIt2ftxhG*nmH0r-kL2A95&ygD^z#km^*Rcz;eQY!w3{B%g*z)EXA;lc=uR#sjy6S z3VkVca;CKGWUpnMO<2Zqf@N1iF%*5HU<^mBD6YSbYiINF2!1IM*lNPKbI|GUC~T?3 zPEgpFB$me*#fKj2;P>2qihQ82_3_IljtPAHf=QCY#D~`7WxYBn=QLPE zi&hsZ2E@lNT~yVdDFe@TeK>yUQ#Z%@DCJj&a8b^6C#%83a{OXDSGpV!qCVXmgB?9q zGp6)bIF~$r`3p!G{3HIM;OHC;qyr!a>b%MSXrSO`GzS`^VB1rWyp;;B3n+M^E_ifM z!SezNz73ped;<#H#WFYR;Zvy2e(>kH0rRLX@iUaLeoTV9VYg=jihS}nB*c^_zC2x{ zKHsO#&wb(-AMD3NKf+x``K_f`A*9hfYUcYUc0hjl^n5$wylsQ$2q+wkpmD>ISTsd` z-w5=Y-w+-fZVu!5)$j;T20my`lNM7WI02^y-J)^Y!o23X58)>t634w<>9Ubk=6Aei zpe+`(Slsv6w5neUNunRh_#_nggc(@K;*zntf!MOw@f$C5W8s%p&5bSGDc8B!l*I9% zX>lLbFgNv=;hpgfFYyl;)D47VPvxt}r#4ehq9Jm7@XWUuv)qRYvB%xJSF}=hAqo!j zYw2nkGjnSVJ)k!{bO32|v)ezF^2roJojtkTo0ORcWRLapI0lGYEw7nWYCKB!uqj_W zFJ;o!Sf8stDA&xbskfnP-1=P4q3T-rcL%ga&=f~k)3>du-zLBhir8K)^wZwfH3QlC zcMSY(@#J-W^FZbe@aDI%*zkC>Yd4Jy>4rW7j-Hnr#y{#8oiMGkM6)JdZcYp1HTLm& zDL$TzM04n>B6%qWhi(nHS~h@xuIRVbQ_V(Qb`oXGWA?}nymdT2FJ0Q9R{v^^9K!}0 zj)aV*>BzWdKuc9PSr}hOwNYAq3ZxC}-!y{q;G^_NVINRDg{$&pKq%>jz=P}{WWiws zOerX#rNyh}nTiqx(rHiLK;j=Vq_3viI7Vg2&v*HV___96m zx?#8w?4VAeM|=4hEBo;qsEH}pX{qPo5y$hHNp<7n;XN^U^HT#U_@2LC4i6=(X%yL= z48tNr?@+Qjdz2YI5E=SJg-XLjv^_u8JvY{kO6Dfv6slVvZK*Ha%#RJncJMdXi;<^> zYz*$U5Uu)T7CpPR?o?E&u8u=X)fE~rtgbu{#Ck_htaongx3RykiY@$L6@E8mRV)nN zy76Jf5Eb!gI25P;av2htB3vR*bc}}g;F>7|ZsD4L;0)Jq;@acM_OraiO%(4M;3F?% z=GJRymk#}TC$zOh>6@uX)FL7WVXi9)4byapxT7L0=D)b-C&@6^E5-d#jNflWgt_@! zPyn6%slSZU^Y{47JAT#7t=F!zg*LQSU!Ty{XpKRuaS*Tvvjbd`7Z&d&ZG0}n%%tm#d(fzD<4;AFs4<3XxM3Jv|5$f#e9A2)g1PjeT$My3(h z2*vvrXEzQc;d%Sp<*e?MN%JWa&ztCj(wiIJQK0o7BTyAhaN6VbvzCRl>aaL~=(h+a z;e8XDp$u0zfg9({R9YW?{f)|#k6@v^7vI>7-z16CIKwy1r~Vur79O!4g5x5kCBj2O zZG1lbJ0+2!UXQU?T^PI=@24Zo(TRl~N7teXOiW3A{$-Fvd7bS6Zl)UkII4C$TwrUr zn`xDNC|4ua0~imo2Sglj9>**p*AOE-ut&w(GCEPtPb%tDQ)m{Bdgd-io1Z7d$q_uO z5LQCpqK2g9|nomHStq|Oh zdo+Mu&sxJs-)^Ss8eOaDoHZRo7zWnSSY$(=N3lpe9pV7hvV}$b@a8tG$c#HPG@G)q z^y_mjOST;?$$y@Ty{EnI(sL+u&b?uD%kiu#Pu~1x^JK)7>wWz$(vmz6KQiT0!)_E9 zjT@&1BAIG<5p4R80cs$54Tt+r{*ma4>R@n$XMy2(Xy(=pzAI@aOXpP!Z+HoK4On>F zs}NuHSa$KNlXo|c-sacwIFyGIr}vILA_5k9b?Ww_oBEFn zMoWEV)YKLpp4e?vwEruVLV;0Q+d1G;X+W zOznaAcWm7_E0rGn!cRUunSm7Res~+*u#YcGLtnz*(USe?Ak+ci^Sg(=rza)vywj7ea zf`0KO>A_?6K~m1?z9hv-VFF3vYxbL@V=1c-Nn3#vNt?ir^%x2MB+(3zYY#O!wA5Q~ z7!>dkJW2UCeuZy3Y2lU47DVXlDCIb`90XzZzl7YR`kty!58StY-#rioi`K{J zO1lSs%iWqlPbRUAIx|3p-2-z;zqbee;?o1~BAeAFswnrb;%QQcDmGJ9Sk*{Jd4QWj zFZnq$-F}XNy+c7ga1q(+KL(D%OfrJ=;%% zFwpT|MILJ-`p>4lfcr9m_J>Iq>ZkVGv_HRY-}={+e)11n{|HBx1pSM({&~!=m-A_q z=Jk4n9o{*h`B=W-_bx!LSm7I~9cF4Cg{)ZJb{VnMgB(oq7qxH4mu*+ew#T5r2{EYd z9Lj*t2xqjvb$Eb&X%ZcyJB1f~Ki7fEQPrzRL!iTf20f}u|2#|WkZv{`x!m^br-$7& z802BU2==hAk%xW69+nVgucUPlI~Y#bcu)k7@$R~PJ45+eIK$D-z};pI@nBAHhPlW` z^qvbAY-d|e`n_ZPE!9n)@i~sFcob@Fe{1%y;!mUwRlG`78DsouZi;7&JO1V@!09Fe z_izoY5YfQNsXg-ybc)-PcB<4cvScR^@lSIeB%7CYnaSY15RlzI_L-|ifps~!XrPy2l9}QSja_Z*go(T((mYCg^BS)ImEd#}8>wGORX&zUNky)It%80wrY@H)m{bN-RGXE zpii=3S3i2#^MxyFdcrWFVo=P*Fc`s|r!U%RIma&H^%*THx`%~<-$pQ%3l2A3z6+J29cjT=4))#E{OwT!q9*=L47xW;oo1NZ%B+ZhJv z2~1>mg7x>f0y*d(FtfZ|i6edbc?)O7i2C!uKH6K?jZF{!!?p-hFbL$G&jJttk{UPk z@2xwyixLL^K&kXxC;DHV4>F%in5u9u79EPaL)adQ@`~_6C6k*Eu(!m~J)Fi=cc&XmH#IIP2cEc*3nnf=?8oqqj6jaaqZK?Z#LCB6qUJV0S)0KW}Af=~q7 zehhIWayoM3h6#Q15mn5KQGInfZed3c#jR>FCXKb*gx$V=t2^w4Kl!B!kEm0_!R@ej zP=Y+-CL|=*n&1&@kbP8-m}piI;|iol%sRqwn(b?RJc35O1&=^C(W#CRZ+T#S2xmcH zU>_MESC3IOD8zlaRa+w0ksp=QunCLX`L^%7Gl;X2`2iH*T>AFzL|$}m1bnO~4PlnlZxA~SK?`!Bx^Id#-t8+pMGdSRX zg8X!zIZYqW@3L+y!zt9zskB_<=cfLtelGSlA#@pu6SbgiQ1XgzN|V*m`t223?|Mh?Mp45a z9QP#D@cUwK4a67w&yizs+eO{iq`8S+c<7?lxM#OU){I1A=+YM>vF=Tj9*I56TOnQ_ zW7=ss@;79ITBa@iJuHkbR4a1YN5}HhBC*Bka8A1t+?P%|AW7a6r|RyUr z1ISOl;G4Z)At%D>5HjrxTNb{g7l?)MMz!L{b_>(jB;<@Qdnr=9lQ)ko$EVpkQd!3i zz1Bx&G~_iZvIkbj!!O}k$CimtbHiwP-*WsIyJQkdV#c<`9WU!Do+VRIQPQ)juBp1N zR~N)~lj2*64vw!l|H95r&C&R2LOMSsb9sV(kk8?i^;g@fmGwz|gHOO9b-;sP{U{<% zRn9w^UtBY{Y1WSsMO40R*4J@O&o{$_ffY84`=z4z7;i;_CW{ouo>KLIA6|yvyw0up zM5E?2Ma@ZW&8tu|-L&JcS$5|Pdz31t0T09(yo#RrOvoj%K;M|b2K)KO9C*C+jl+=B z-#6ZWiE{e*#u=DYNA-=jP*V8DPatv?`|^$7;ng^_9ODAtk5>`o8}F;5M()asY}LNL z@r6RShc^69Uu)lpBevMSQHX2p8{3!LFjjq6y2al{aetbgBgLj~#OvImV~v`}i<;l! z-r%NOh?@UD@r~oyU_amZ0u6>3_}AmmDU{R&cieWM&3-cfzy8I%;hag$xezI@{d zwUcJwXu{UkKW?nAae1F&tM>JcL#}Xh7QLviwQp290b-jqhlZ?*8y)ZmJM2976}R}a zDDLkYout_Gjq7UNqJQbr*Sh9^pa*QPe1?02ePc3tVnW=Yc_C9C9jGr}`a63)-HJLm z62B}Z62t!sQYdC(aN$fRHfG~9*kxh%#=L~z5<*MpSu^?Vr3oug?5XGtLZ{FlFGnFU zYuRfRo;z9XA;0Cj5$f@MRC6ZQjIx9?)5vzyJtM> z@QH9g8@~@P9*dH~i+j=7{fcl)q1cXaPhxxP@5PI&v{!()HMVMBFAiVk=KLN`t9j&V zUwQz3VEfVr@(Ja|yU}&F7au5!AK%zp2XV$+N7`Knv<=Z%`r5;c!?Yc562iC(PM zP<5E@cm?noW)LJ?kJE^un`VL{5Lt z`X%e|@vPHe)2Q+B0hAP;Rbf}LulV>p&S!1UD#4!A-?MIC#^omJ`9-18f6&A&$v*fl@Ey}|ME zaMb)i@hmr#F=v-C4u){tMU1IlOule|xQ~9W|-jgvEfuM%I zDI{*}xU!%b4Ak|hfzS7#5cu)J&CIQ}^cr{{h4@RjD9s2LrocE9z-vNuDcp5I&2%DM&HjO%zMqfA?Kat zNJ|7-x}e49yCMMNbb>aOc#01ub~^79&VQ4^UhFpIH#-bq!J&rTG#J6fKi*9_`4{+{ z(uZ+r+Dvp3cXTrPTkBxe?k>$Wbqf?Q=fLzQ?he?2iEPWpV5Sc0r2P)gq?||9_Fjxy z6P}tO_DAS6KZduK@Ft4)5#WBzOy1pm8s~RMz|0=+2zVGKnfMN1Kc6fE% zxgR?6UClT79L%%d;G4YCQ^c%P3l3^3URdFGk`zO7qC93? z08ObIW6-rDJVY;xpe+=Dzz3{S*sx(JRQFBJuRP~c#9u9581;z`Lg?+fe+}pU}|FL&2fK?UO-amvy(~1%;XjG&TQBf%d ziWU?#DA9<)Mg^r76)PwxLd2kmpizP)hG?qbjTUWc(dH`JRFOtRj7mwWXro0Nkz%xn z2ZNYe)D$7-`>i$mG5b6cPz@{{%2;*W6hd1YaV-M_STf5@$%jM?kYMDeuawm z;k!%GFFOjNi3f zEVfXL=1T-=IanzwXKR({50I2lUO-30IDcqvquCzR7~Th?Ws-O~{GK#qGlv{O{m0Zu zhW6H`_b4-m!p$I}kC}w|YvkW%?MBoS}F36^Yk}4)rVi!Co|rz$Yth14MPywf-hrswZ$pSlcWe; z@DLMd^8UF59-7-co#tzN?rz5ilXU%luFo8NT2gTlD>y6Ma;BtdFY}5BG7$lq$KEs5 z!1{3dY6+I9DZuZ)7z+v~vD0Y3)w$zAY2u}-%kH?4ROBb#YM13V#<3ugQil6lwJsH%)jyh$*>(F7gN$>f9*W2E&dEfpdHX%&G#OtD)IA|*1{ zHA0xtcJ@3gR~2ZuR}Oiv@_g0OL@ydtwQ$~p-t*)Sd7YD7Bq6yxx(hLta;w$cIrBq# z{>wt;J$tT;^5~s-CIKS-f&~M-=%75WSBzIN`p}3z6g&DbQtDYQ9e2~>UM!<2_sZ>6 z<`%kYuqLmpoDB+8nOulAqnb1j6L(BW0%guy={ZKdQ_>SHtg;^PR?9s&1n$elN_pRFL1r~ooHHadY(WR|*!ww_t(A>4%7mGohCBDRz>AdR56sRbu z(_rhvb;jM=GK`Q~il;si8H!{Y#p38iPNXCY49d&TB!(E1W84k)j5~B}A_<(#&Sl+t zT%$cjbY-**4_JRhk%1_%31Xn=sl{YEH(QJqZMN(}M`71=9F~^_lTCei*VDoI?lII& zuyYj+L<)Mh7px#AmQol~IOAmFlUJ4}?ZzRNu3`JMuH$_9MQJ0Kdg!%O4G6idWgn+t z;xIo&t`bp(#YeeR%yHSM4aOcG22W=BGI|gE(=8@fCoNy6%`+6$DfXtQjd1pvk^#z^ z8QzOT&D-2|MIS_kYxByo%hMJ<99VPlM%h?idma z71eLJTAVAZ$k-QiMx|NI-XQf7z0qds^p(9lUjk_l9oSJjd|05{)QsDVQFuYRruln5vPng`OR%?MoD$8;E&viV_8|ZH;}lQfPd z{LYikZz)P?M);%C{5kS-{C4KZSqP{irf1I(fjGxs%FMN_urZA!f0(=7>doRwAze!p zC54+#ksPJZFvae!fjlX!6K3N{;S5@zD}{HN`NV$`E%W~bg&=a9h;XS+ggx^Vuq|SD zJ)_$-SkIn)G}gopNfGS%uj#);a>#o|bAH*xu=GzP7YhI2aVeh^S5^4{DV6D#7LtfN z&2YPq%O=( z9(P;ji{Vpb%9Qr3nTa$?@VwFnz0IshmSqBM>%$?OkF7#~Bq5RU>XXgt4Tp=cwDv=x znbJE{IG5xhY)Qv^!uTNR_`?8girRBnm6c^0s5I0>jg;M>d&OJpfU{0dKz_MiCo8CD z@DSuLo3(J5fgr~%KkArce>;e(0!)iUR7PW9(rn34O*j*$Q4B&dJ;14ZTlIv?NF~bL zh^X4!CyP(Qy<4^|x?OcBsuliosOX*F3QIk;RNl^2XB=Df^A?qZvN(pJSNvA^+mSJ? zFrIw~Kc-9st>jOlIQvusdG=wMI^%Hm-A`=CqH^8XFz_sm$4iVqN+2jD(hm_E%8-5?3gKUOy?R}(QCAx zbqbCN${XWz!h2Czam8w6lGIfCOD0S|2LX0|V zpExF5I%*T^@S?nJL_$fVWNkd#HcK$AhDFX^GNiPcs~ABd7|VMnSI*fppm;j5t~!oR z+f`*Qd;)c|cRn+JPJ<<(}qvb9Na(W8RNCkD$F(Li3=R;x2k*?#?z@}^~bm04)~ zmiQdYRF0x~wGul<*0s^t!4P&ydN8T&QL#tI)wa`iMVZ&k-P|Q_-WNrgVx79Yo>z7v zBF~%qX_ve%?KoO^Jjm3mF|SJl{*kwlZ=MUHU_RjR-8cJ3DZv<4QbnPtrF*r;VFVO%0I@qgAjZ!{$S@RNUrE0mak@QU;{wPsg z??Q~A`(lmYuqs}sAZw70*5#0%)iDgz8YRe_uS^-oUG9S0v@8 z`OVXDU{GdR+CH5&u5}sQzjHDP`@)J6fhqnk7$R65*DWFfvyyGDD=^Qa;aw}^$`?dJ z_HwZ=4fKrdIF1xPKZ}6cLtR2aH=5b~r__lNP1x*Sq7vA2R(@SK^YSt|X!25i=||zA zUs;1GqKjVxk$LJAb56n)lcQIQr995>8h+ar3l+%rRKRH%ghdTRbEuI$d5(7(>TPSH z&O8{{NZzsgb7EU`u4Ho-B0qz;Er1|w|e3@>@oGI^wT62G9-hyN(c`Z`Wkty`{6 zSqiN4mjVwGNzKh|lBak)%9EHU=Qhq*$uH`~u4D2HXj=H7DqXo^Bq_aJ;MT}rl4?t4 z9K!9UGGf%*sjG(Qx^jx{w!uKZ6s$#UT1dSX-IY&wsYjl`a2r3PU|s(!I>e)XU#Qoo zg?~4YQSU3+qR(i6tdb!&aod$TcWVK{M!4o_kP%>g_*H$FBnPO)eCm+A)={EXNoL0; z5x)%hAZx?<)j!pen^V+BGxQ>O6Lg7&6*jdt1Alq=5F;bCimqO1dNRr(8pry)K8sq) z@a%yaOJbPZ84pS^?L&akO+kck9PFBv_O_NE5FX~a7jcDK7BoxqE|b)p$G@UI*S2+G z+R_%fRTq72j;O=9YgDE@Dyk|eh>FT(_9#;{r8cXi>ch*O;tE4+#V=48ueY`>(C-+` znUx38X3sEHig#%y42MHS<}p2K&eVLI3e)#4Wl3F_W?)NL+5zbq(d2tsi1|=y4HYl* zKBgd#S~GAR&||B<0=0X+sAYLt>V_^1{G8Vem?0b2_;z(Tc3CV&}48C!mJWnmcrVwo`y6QM&r=$W9z( zl{a|?-q=xaa4^=RiDJ#zuH4DJ&KX`=I~L1HjJxAO4;z)1 z=yo2;V_l0bw=KwZ?U&TrQwH;NT3=hhHSQU?b$ZJ-*QCG09~ZTM`lr0Io*%yz(ibB0 ztfW5t#1B-`JfFZ54}EFED^OqY-jXoz zVbKq>N6Wk9`)$oedRbk+|BquNS8>*dA3sj@2}9U(yv^BM!nB+vY9O7M6ZjSa`!9fW zOy*6JTI?>c1NwsUp-kSI_&B?fKF=z3^h+6$a&j^qBaU z;182$tL142Z;TSI5sta^R3~c(GIvgEsEA{@xvkza&ZDMAxAEPVUddmK^ky6EKzi-+ zG`T$Om+y8UJr)A#IXK90Y(RQ@drtak3fZaj9wktW^kf(lN3T{KX{7fQf(t((j@^@< z3`>O9@RYAFy))l5(mT~)2hyu!_>A-pd#3~Gv5=?I%aj)4>)xNF;W!PhoI-Xgy-5U$ zk=`Ymc#Q7N?rWq_gy6!{#IbwQW8p@5ZN4U2dTtL#X+QOKg>FI2nD!21$t#|1cIi(! zLnH4L<3UHrwAJqOO)p)Z_S#=PdD=M?lENP4@JydXIXvDJH;4W9G=~ck=1}VEgk6TE zSgSoM!#@t!GFWGLNKQ|YuuYg3*&LS}F0C&cC1*;?W^k+|x7B&cRF6JpPL?1h!E?jq z!&2f!edlnEnjogh^To0`v3XXRi0+$3v)oZKXI_L`lV`V-cu^<%dAg%a#(8Xvvi4oP zN0D>^Ev#zCgm!E?C2o=iKY*vzPRBQhpEM_Znk!{UnBLtTq*vspH*JFSECR`}_y z+THX%MJ9>L8Z zpBLf>hJeg&uaion0dnO*`;fSzrflj9L$SIh|+nP zc(W_Hyu4l0ShNesFa09F6lQp}fC*P{cIltaE^RcAf=YKFo|ero;YeLWUuG}e+?IZ_@#1`9w`|TU zo2NCYOX-s6G$)mJCGS!d7rsAnd_Oh5DvR<(222<;49+1@T@&qI(q!^A(q-?V#4Mkg zUZ!eNrYb|`qCZGAoPIdBBR)bDQ90g}&^iD2^cMa{&D&J;qgpe!Dwhh$JElR`N;n_U zoFb2vSRy#PyjN=e(7*d-zfj_Sl3&_V{JiShjP8{2i4Tp`cO51yNiW!7KPJ0Dz3anM zdy9Bky0HhRKM`X2#3tuDv*DNd^F_~I$SAd$FP3o4id)zlYky3Y!NGHX_WBX5mGp&S ze@YjY*@18se23DE`-nsK`F9Mj2+P~DWYT?`# z@AlB{L+G3go{O;3EHglFjwNZ&m9*trOfROh0>os~+I?cy8?!Ot$j!eL(TvflF?L-Z z%8T82pIaSMlNVWDk#|YyT1x{d&28)2y`(42TYlVqp8iPbUh*^wGq;V?38&%1lhg0= zLbjr@TX<(G^Xf|)7!fr}(pxH=q-7fPwliZP{c)0q?$y;`ORZp|^g{1CX(-=Y6p3uv zDB5f#c^_d(ZQuE3QuU%RTj%C?Mf`+b;bHTZMNtWjlCWoYzh$)>`6w%L+A$8ZOzp-s ziFBF>J9VvhGvAFQDHnhGW!-gmRC;gYA)Id1xzE@ajf?}S3?vmfJYi2)(!%o&K|#zF zeZDrM7vrhKT2#2Ebj(t_F3r`pH6rl!2M6m?)E-rI2B;&1MX70Oxq)0Y%5OW2aPs%NW$x+`avsvLj~Sx_o@$CDq$qAv{HP~-}jkkQ)VY(k%?#~ z-uUkOQ}xJ5y8xv8wZw2{`~9?Pb()`lmp0(QvzgE6P$WXIwb^TRVr^zpLG$gJkygf; z=M`D#-YWT$I$DmvMdwz1&+#}x41(FJOpWN$&U7_vV`>Oj>3BsmlYjXP3S)yp|(Kp=UGsS|JnWRoXL>FKb?O1f*BqbFLedAxG$039v%uH>K@5k%2wX9Hpo>L9VJYD1Fmus zaFt8S9m{Hv?3AlFeXiPqT#c741VLHpYd$YA6>6__ zIr=eYmuRJ}AHO6GYgppmq}vaTY|;Uk{}irHG;S3OyE5?9hjP5fSe>hJHVSp|!NQTZ zLEr%r&oABL?-hDla-+BGrz1eWzw}0bWGSzDW|uePl)Yt~a!AV%QV&b&1(JGs&!^YQ z2sESRMEsk@|A#6E?db68ux!i*p5HZ_=z0LA4pOaYKr)VV^}Z9S{Y}>EN^Pn2 zX3=I(q&A=4!;;!f>hz>`r5JEuYKM_{Kx!vSZeLq!djD*B&ud?elG^g1)N;v$M@R9b zHUiR~OYM{xsXZ*^@H^#Bb?y8E0#Z9eou1UP#U}bv`!$INq_#qG``S|5Bvz!n=h3f3 zN$n(3HMy!v{z;v2rPcsx&!zU@SJAq56uas6L~6Y_LT~BXzUuU(wnOZYFSR2{JRr4G zCAY6FwI?O@@}BSWygSfBR|TauicAvdT0W#GshLTU^pS|%KeZ<#6)6e(FX-b!;c3P0 z{)=WY3iq_d?y~q9L8NeI!>YD^cayhcVy;)tVt9>=bx1>HjqltQSYbJY0JKDx(5jVyH{~(x+>>a z-11uj6*uk6*oym4f^=MQPpXFb6<3RUH!H4%W4~6#ZBVCIaeu<|V{CBgYu5Cbx5TpytkD zkgf^I!6j#7)29UKxaPvz5BW9s8SdSzxq+AftLFNs)2lfK(RR&MlWw5q9>Js2nj6c^ z=$qDDC9@c6?%kKaam`%;%YMz>AqCjIn)?OM6YZKi{pLW;9sPN1&7DAyj%%(D`Lj6T z*{A-vceCbhq(N9UH%Xmd&5gl!T5awFhP{EBla;zoYwjV>bbozoxsfCP)ZG3redC&Y z5SIO#lleq+&ADrdSXAbMJj1448fm(HfHSW5rjOD`bkr>|fUgh#2}^DyT_?_V^m#;C z7MV1N^HZE2ao8yh?xd!?$&IIOzwhFt!!tQIDK}lMSA2`Qk8dSZG^8 zvqFrr)G<8LXiXa39Q5WW=cspdUUBv!yQ`A25ttPuUChq=at1SiMvF5-{gVe5y0h?~ zJRaDN%dDf-=U{nhEY=e)i<9(V8t(ch&+b}T)k=?!h1^Qzkc4@(rc0xQEG2Wbcv560YN<+gdhiySYi=0+}z7 z8kZ81T$l`Go4}vLC*yC|gL55)d96k1sI~AIc+$typ|Uv*Wuw-z^RA3DyF3eWww7Eg zIh5;aR+Fx?J9oOsL-Y#C+J4a5il@KO!pI_r63D?jUZ&yXn$NWb6Rc;9iF5vyOd!l# z$z?5#QH8FhjSETpi^}*$&DfS*Ug13eqd5)`S)LdPRU zL7W-t9fV{{@ZM@dIo632dtmE|upiW(_&)BYXGftW5R2aOa6**ZOVMmQXY_^wGe>sc zkMfyrgV){kqgv&p8nSPcH1cKKRmMWAo-&Z74H_C-9wIX`MwPzk+_(A|Y|ENOKyKbX z?cBDCAO`_?ukA#ZO_H`02DzRjoxAgUX`*<}GYS|rMXV2>K(s_PN~$^9(|ZzfEsEr$ zyKGuz7rWkj5|E>`II%hWQFu`diC`FgM3x%-dW;zXbI(hu+@56iDE(`Pp5{mkcSAMR zvutc8?MjEgt>~i+j?1~y1!mt@r#B6GT_i#~CM9?JQ6Kq>J@E*X3-RBsie?uJ~w;a9@*q%39s#P`z;WB-?;AjQ{+?Zvu(x-<*S@;?gy$ zu^VC7v~^h|m4~Ei=>QVlNgYz2Uk>jlIJBwzy=;>znogob;%XojQ*L9+Iruc1d%H)~ z7^<48T?8NkJM;C5DP*QAShGyI8@Aj=JJzTq_MDR#XDAv&GoEzwm`RY9aU|fRs|j48 zZ0U9r+OROA-nScX>WWP)8bentmDft8$t|re7uzL6nU2x;?VU9J*`F0tliDt#%r#AUV_%-RH zba6Q>X&mB|RnFRZyNu+5H+>Z9>ZjFG5R-Fo&1)ECb21QP9mPRFdIB%(*u^)sq;h6G z@QCLcGL6~AvlAoW?BaO~K^O-79>$S|jE({lQEAJXbBo-633F=&0hII9n>k3BFI)=Qh*lHhc!tNULtV zx{Rr@JV@xCIrC+!lC{fdFA_5qiPGx!q9#*V^T2IiU3z~>_Uz^U)hYQuq~xVCPpZ@X zfA596NFq^6ebJY((swm4wr}}}G=ow!I_id`9%OCEWZTNkTza_a6TISCBsZ2?rNFVi zG@XL``Vf75OuK98vPIjpEvtTe>tAv{tVk}nq)~;O`y=9UAOYaHL9=u9-><10Yeei? zMdXgwTdy-k-D_cl7BPbsVfwgIl{CN03$pMdyb9uC5q7Ecp;Cp|_LFnN*Pkg>Vj`-> zp1?Ab7OXVIgoDbM*lt4bP#=C4gWxowd%n;iXY@|E97^J`Yb%!7@}#L8B)RFCLK*D{kTGY>s7o?C{O*6~_xuipw`tYI3 z14mV?!-?-PQ6Yec)iccdo6Mz{fx2?_Xl`A$^YUo#ET-QcY4L@~qnhfgqWUUh<$-s7 z_+;gUo}(<6p!MNfr6#4y%5(o9a?<@~wfqvsD!~Saf-*`&)3!;ea+}?C0=WfJWw&^H zySW9j+4MuA7TOy=!eVQMCL9p!%75BDgeGU(6StK*I$RahVV7!T(<()&2!;q)Ki)5p z0iWTrkTdl2YExT-D`6dF%5__w{M~#UE=~>R;XKSMov|rO-144-^4u?tjW%}{1-r)= zJ`3m+wU-SiVQQ~gx}>P&w7p2TLz<3I8(MXeBog(mjJaA9wRjJtsaJc7ik5{)k3+iV zCHJ_beaPV?_jTxt%%@-D8xq7w*;;I96*U>jX#YZ>r?I zf5D`AtqDcb=6|)=PcB$3ioOBwFcV3S|F%heJ}i;RehW`@B4+X0YK2;FWErTd9DLD5 z-+;x+u>s{2T_%_+r!FNM)s{x^kqATjnK2)kK+5znFkNBX_2KiS1d>2`LALSBP++bm z6F&W|`?fi6_Ni17LH$9j+RU=F$YZi2acW&&>0iS~_@S~%Al3lg(`vUAbS1;nTB@xJ zoA`}EC^GM1uFuhA$hZyDl-z7;?5Op*cKWOYPPWzeYkl zD>Y#@tK!dFMojLF(8WX{_FPV5YLztNM)RfGRl}OW*o$o6;i+`oi)`hVwT^fl734L( zM1$HI8zy?pruY2PP_?duWB- zzM{Da>d;vtdegB}S<2j{c-ix;fSx-0!7h<#rS{@>Of2Mr0ru^)+1Xqz{aQ?GHhtK0 z%%Zh=%X43l>ea5MieI!f^$`(D#n-ugmR#~x*Xbo+b%`(e3VqTZ2|q`(l!Qd}-V@DX zJUyxopJuagX|(<uKO2EJd*;bPmP zeAB|$OK{S?Mwq%1N1)!b?Y0^#!Dfj$MkOedM7kHP%tMt&xn9^Y_u7Khm$hFyoo+|= zqh%GPg+Ffz_GIz&+UTCst_!)G$~Hf)IdjNosUBLLSRk^Y+S(By7X~8>FKE28-Oi4c zWA_xXQfZ`q#9UzH)LgWRlzy(}#mqwJCsa5pAJ%LfQD_KXy&cg~>ZNw{Z* z4i}WoGeKFymeC>?rH4uWV5uJ5BdSBEwZB+41KvtCUhxtg7&pl8h8f-xPqljUuFz6!RfBQhoSxlU6nP zRfn_$)m909Nx>47;4w&E36>eL8PV5=4`l0~u3pSDby6QbTeHD@&XanP9?!gkPKL~C z92RNKsO(gvHw(ecwBg)idAOP`X#y`9#)}!#XfL*A-mRqEC9iyuAmT>kp18X(%X67E z#p7)fB#>Xq3h>9|!vw=^Fhg4gi82cR%1(XwFwLq7aZ507cF}FK>1I+tqMM0)h~u`^ zqLEQst5xB3sN?A`BY~*)By)alK&vw+0aKj?6-ST$zA4a!#kPm&*%HbmhI&u$Ec%M} z8$OUP;(K=%iQ68z4ANh!;szmsS zw>~EJ7;@`D`W0F4V(xp0NY6~Mf%DUydU@fKK)nd#Ghw`%%&KI$2GLZo1|4%gOqOY6 zkxkpS*6{B!MC5_@%q+z+Jz-O=43v$Uk1B-^M~NvdH`XI;w6Xj0+(r!cvC^b9j!~A4 znv@t-8AxmDKWY&{S)`N6O&<``#Zr@bh;8*Hl_koQe|SR_Ytz1B#D*fWWshA zLlXW7TJAls7%aohvP)`Bsd$%#@DY8aDPWiCq*6bZej_?qTDa(aW0$6UKy$uI9OhO4 ztCq67Uf9$t65lB|1LsO_L>)kqdKJ-)raqcJ?nDD(Hy|gqc>{H9+%eT zUNGnh(QPr-$W^wcBQDyV7$U8j(>98Nh}Y@%+wW*J8E*F?GEUswdXRu^#fh0i%mxZl zN5cGhtFDi1Qz1|;@v0ABv{~Iv>UPh0vydRIVN0875?cBctR>QGB_I<`Z6Z#(+7|BC zd4Sjg{`|pXSh_srea2+Xg1f^s1+_8_Fh}C*6&s7u@7$M=fQjG>pgEYnm}C+WX(GYg z=9W|RS1b=@R?e}xNu`jCgrQPMQC_^&eV$yFfS1bZM)tJnZxJcB(fN(OWCWydSyg*( zpHRajYkPr`ik31^N6{3!2=T~Tf|i*kvMp%>dy=NERhb53Ii%jh`MP11!eg60q=>-= z_FK^y?k~vi(kyr1#o>!i!&HV*t4##$Q|!9WarElgfj%mh;IhqVCZLcK zt^35w&2K}L@5=STmLhd>+txbK^U~+@wA*|pM`6(rAZ8{v&xB!L2Ge?Orf`PuW*}_d z5mcXBjOC{0oL2@hvnb0gCajE~budc-E`%&@U6olO3z&IdesG<8=em*t%P}(LOLf;E zu6q~L-~T-^{Z7dG@TiTf$gm7qE~%2?e0x#mO&F3z88eyirw0SHCo=DFDtoX{VshL^ zxCs~M>kdJ=Jhg@<;PUOBJGc=txr>ZMZEluUB2T908R78)VJb?ErAgg9Gpd2H8VPT9 z0W(9(FP&J)yI87-X=Et9X>OH-IoeHA9?aB-Kh(*wjADeC;24VCbQV*Alb7)#@R<3e zFjtIor|B5;NfYYzY2kOdKPUVJs-?{?IA5s`e*(cCX~(oQ_ii3D1jm>-k0r#$pj5Ja z7Cw%9kx`1_=ES~ZRZpWIH9P1VrS!WP%gU@xw#a`J9!a!l-TUfn3DMkggvgVaxg}qC z=V9K1hEgGm`tV2*p)p9qFByJmaFsPHdW@u|wN33mor62X&YDA-DSQ_VXl_G2znFdxVb_>L3WKcowVFw>_%% zU=B|)V*JtDWNF0MO>+-O(b0L{7S3B*_lGs^GVS5*b9FB1%=BrQ9xc-z2cSOVQJ-3x zNC&r<^m?m3a1%}N_L4hjN$%|>b#PK6BG|I7qbQTDC=J|C!d*5`A|3s8_geESrRX}` zTxGM;xb;Q5++;Fn%i|(Q$%nB++7K!8EQ~H zKL7KzdOqvkpH?U15Qx4&JYqv0OJSw!%`!n>lnA$fBg=23O$2XbX_mGj*Ms<1k6de_ zMcv49w3FEI+6emdtX%T4BA2gKWui`~>{cnUNxZV7`&ugAlyJF?PC|!ELT5-q6P<*9 z6P*xysN&t`a#m*vUEE1Rhd3FwzY*X_49yDZ@ct3LL>?WA=L`BNS$kJ}5Gb?Uy6farls1M(6Dxpe#fAMB}$2Y-zB11yws+Usb zK~~18YBSq@Tf7|d3iDe{&o&M)qhi*$C-x?o9k6NN@1hJ%gdy9L0Yo*b5O$~%IeZh75#={LDua>#wLw@dcLPpY5?dYQak zGUj&4*A^P_eE)UKsJUJ8boG+kC2RDTTm*R`k8DMXy*Xx&^UqGKX|!{eSUbC2a{F3t zl-isZeY@m&PAYRGZ|`==lO5k*7~c$;9LBp{@&gi$f4k%_C1&E=B_D&lof_oPUkkG zs&vfam_?f0>Zlo6m8j6Ge+rI{<=RDA$}~^oPdH63DBPdL1zCOw4wNK1gIssyc>6ER z$dLpteS>k_OAPUHbanPWNzqd|CbX-cHvo0ayREx6|F?YP&z<1W={ ztJq(itI^Fy(Z}{zki8yH((&cDd^_D!l6ra1KeFV@%G3X(+vz@D9gy0)>hz@6zzrgn z)V}50>1IpnVM7Fl$@VPb_P);GAFZm$;ua{sc81)F>GmN=#})Tv8Y4V;;-y_%eRvOU zryKP`pyEzdr`KSP!&X}jW-9r(N7eP^%)50vUD0#jyynCjQgeTp8C7%tg}2i^u_9P= zmktQjT)f-q&Lc?2HTMl}r@NO1VV)c6V5CHyUd>&H<+Ez;>)lSbf{k?Fw9W0nGEj4$ zunkzoEnb`3^P2nGx6}QzHdu2@`Uh$*-tBb%L6DAX&O4p!w7EUFo$ehPgjI8|sMD*t zKVUnpn)`aU(}gJVH?6rGVWhn05nSN(4Qoygpzqo3bm#xUXwUZ-LD>|4v83mX;qFT0)Y(&hh-GEbomTV=ikr(foC7)ID-?y{R@{?=}%yZV`b zN111${Z^SLnht$q__)^}?C(jLZb5uMY+JC=CJp7s9((AYriefUbCKT~1rmBel^-OE^ieP%^f5H@VLz zTsr!uE2`dWXfA^rE4(+uk`?J@zDCLZi7-Nlvwi7Vwv_T{YV@@pD@-PZ6?^BCaCH=7 ziP>>PgQm8SVSV@kxHjv=ZrO#8nH2Tkv(w`w$GA6Cv}jQ~J^rHFe@g$kB-YtZkE_sA z%5LxU=W77{RCOW?(~=?Im5wpN*umc z*@!vKB=&XvZMMzy+J1T3?>OTMBnv0A?u!?7kY)?y(1S>gA{T9mylQcrvG zYL6AmTIe27XE7?SwUFEP9BVPf6Tp9swdf}K+18?r`i!y`4Msg}Yca+|i?SBoox~h# zAq`3Qt9$#x*7XrFsVVBvTFhLkN}PCKSXp#J39QBOoh5X7CkeUMV)Nqxj{Kq(^HbFK zUx!B(ErGRo&?FRPEgq5PUUtg1J9ooc43%~iv=*Bm(^^z(akZ%gZJZmIc495w+MvbK zMthy|5ZD*C%2**KKWu($Q-1qDgqe!#cAS*Iw$9h#uk?*uonAV#VARvL7DpTPjItK*JBiuW zLiW+Dl2L|~?$O>+O)3LIoVWgstX3s=$oABX4t>QhCf??vpE=3Y z2`?=tyJ6lxIJ$`bekfB!+3BMN$+8MkSD(Ao+UT>CjXn!7D0PgPYn+WfZ?$S$k&Qmo zlWz1W9HffaAhMmlQnWTvBJOUXir7Ssvl96MiEMe&s<8t)EsiIU;dh%FYi4`b`)I^! zub{_6iK(&L%+3VmrTo!dCS|6mmu?~DKgxU^5tYOU;^Jz?#J)iAY*$XQYRT+}rh3Evyf> z$mA*3;w=5Ou{cW}#^U@+91=cgb!3%8W;CJl1Y?v>FY^WlZPtwDO$4$>W0cFPqQ)rR z?K?ABpI`w*PgsKGlW@lvKRxN{O@|-WUL)<~^IhJYgRrcL=r2m-97J7INNT97e-^Ai z2E+-LSJpGV(x|l_6MI}_#9VSk7WL+>+{`e({&AJ%%psp0tw7)g9d&#||zlAA-WjU0k!(hp8`p(#9KJRw0 zJ(Y*K|BU@OAV?3s*cYXLOgcAOlIMi^6?DpOw_}u`F{BI+XbtH#RJCMo-dW9! zpa0Bzyk1Xta|21Je%=HUFu%l>h`QI$o8tM2MKIJNk196Egq!XD$}MJ7Z>T=EM8oFJ z@1?E<##Lcx3pGw|rJ*f0F1c8jcuP!>YU8=oxM~b-nTb$qXe*7Y&IDO)puu>qHLgYj z>x^fUfeix4b380_$RJOk%)357$9$#cw7l;tawlv7VO!27bdHHT*2EPk%SqKkrF!na zEL2`7iAt3Wmlr*Up4Am3>Y`aPpQ{O^y9u4F3D5X#%L#4|WoldMZlhFwY$vt%FU7k) z91#o*%+tax4~SoI1uov3P;9kJ{1%k^??*my-oLWQX@h|?k%eS!-Dvmqb3HvyjIp*AA$gkYUmA9EJ8+OZ3ln`qU>4ofE}VmQ=E%;`8}g1bV# zR>_wHXx>j$KohU-sBG%2mpDGOtiA#jdG1D!=6yWUmfPDk8v>U|&e zt`B#mT;X;i2J7A2W|U36G{n|JgOvPY;^@p0q56v-6rq6wVtRn7C$>QkFrBAAQo5Hs zjS!fgcE9^HeB1*}W48>%MfRNVF^d@we#f7*rakZ*Q#UMxjN@;A9Z@$52ji_^qw1vo z>g2g}{k|N;+el7!k|PO=8tj`-YVKsY&du+j_zB%237PBTecrlA*t5Ievf7QjKHXyW z6Real!rIEXCXr4PVW+P3csq_HTXJp2elOAO^zOt%IDMF;gi}eSE||)P-IxGInTE9R z(0i#w^Nii^dEB0gIxN4{gFP|TD= zKH@KPIrlT&@^}3N*)5`<=eNMFe_xF55p`$E+j-h#m>FM)rG&YTx`5VcfXs9d~bmdR{M)BwRNm%(5@aOuuayrlQllT(%e8*4fN_Z2$ zF_xd`viOaS^1~VWspEGnC^{qI#yNhHo~uWfIerpO$}8c<^C$dCI4QsQUBRF0cbxNE z+|j?q?fQw%NB@?zBwaULv|G~L*NWGj-|}fJYmc<@m$9HdayWm3_&cA!>HOWt-%|b> z`P$F8uI@ zC*LhJo9=S!@>^UiVddkd=lZzrP{{bWZYh8tUVaDN#%0ozaPG&%Z*6UBv-#Pvqow7q zf0Zz9`YwmYee11}$hvhty|pz+|D4Z;4L&^**|cf(YTqrt%*Uk1VoA$uuZfSFUr;`G z-g(?{AAI1`A9>_hKE8Y7#@gDS|J-+9cG*J@RaN}R_0|Gu zvQGXJCM;U?$tS)$5@~C*%d=raj~>H@`Sj@e6-rr|O)ul)yK8IjxMQDveD{Cq$9IQ9 z6DEkuMO(e0sFIckhY{JN#2m_2J`(k3@FtXl?b~efpG@1?fS3+n^smd>bD- z{Yb>L4p*M**FW+|R+b-LTBF_m+}7xZf8vQq#IB#{@Y0@aej|~|lb0>?(|_%?aeRFD zIp>5zx8Lr&r8U~|TU$48HX2~$y_wIB9d`KE*3Uop-Lq%!+$k=XUy+~PKA(7^scG|O zpWfOUEN^qOaNyH-@Okr1-~AW;`0k2|ZQCj;e0MZG5?Q|d#TR{gBvMsn>t|NhQ%^ni zm{0%t&tHGtF5ite&YyojcW}DpiFVi2tX{oQmXe+JA>21N`)*e|T>79vue~;CkWUxw zvgILVx6AKZUpM}hSHAX|&99_n%Xh_!F=OoZaqqo_h3~%W=QnKF(@$S_o$tQ+=1G&b zZS&os(2gAsJm9Z{ol9+PrzE zoo3VP>Rx@-cmM5gRaJlcoA0ivX>JadHz*II8-94PuC{$0K78_ITi#`5xw+r_o*#b4 zj^g6!(|z~$?Ms%7AMd*d3@9tR=px@8iG2RKUH+=7^Uwdm4}5y`_(s}KON&px`s#}> zw)L~Hu(;T6uhDMN9$SB;HQaiupWc~g-hR7n&)$4<*)rQciL`9}X=-}mg{CGyek5|m z6=$90yK{1yn;RQ__qJ`f-)@)p^UpVKeEMmhF74ZHpE6#t?Vn3^_3wcP-1aUMdw!WG ziSiMD8PmI;lbj#o@A?TI<2Yn0bHNptPn{SVQ#j%BqKR&p==q80UuW|Zi7VmcBT6FU zYf0xg{^ZkT4?iXr(Il$*ADu#Is9yjLu5L5&Q}>Cd&zLf0Vv&=S%13{j_T+hc_QRFa z?$Jd%Z2d@%*OTM*}1U;OVKuNN~I zmcJ|t+r#-w1!eJ0)~LJkm&KoqnZ;km&6)gVIBr=l7uq5G$#40SFhZB#S^RYrH(nf~ zIG@ZM^CKfCiyt!1mp@6*{mbIFq#?X@;m>@sa|~wXi2ninH9p)})A)SjipJV=FBtRf zkN8b?*0(#Y5uWTBj&aLq-kx9i5#!U7QMp+^zA*Rv(D3P#FP{?1omw<;de#rJ z&YyUF(dE;NLO=QOn5>J=KKJmD?%O&k>&Ss2-Lj>>ZkTvQ(X{C&opjl#%cf7fe9Dw* zS6p^^Vd2E76ZUvk(?yJI^pW3IPR+r<~jbw*BN(cs)IcYrWfbPyih)aFG4h-!J{vq zdX4emJ6N>NTu!u3Wn;oQ(>bTV@v`*#pX7Y6xLBlO`eXO$lyUpga_PzaR>}QVMk|cI zB==j%hAY4QB==h-_gmTRBe~yd)28HpE8jjO_ge+`UnQU4$hi1_^7EU{M(fdZV;wu6 z**M`G$jUK4ocTm3J7-|Fo~}84+SD1>3vKAA$x|nKu25*;z&s{lMU#xz2^Phql;}G- zU$Ex`tXc38S-JBA@v+^;m7Fga`6SP0B+q9g&u94dK~8hn`;(LBGm_^s?EUr0^BKwW z8TNk9=<^uS?&N&of7N_}QKkHo&#@PudyYO8_|b^zm*05SjH$Wj4>_;k^2zc9X7c3R zF;gxWco{h8G7TO3wVUw=e#7|L-!T4Vd-$+Jr%z64cjJji>uFBd9D_p~%m9mBnv%?T zHF|w2`uwhc-qfU*JP#9`|0L%}$@A;>dGh4>_2l{WANtDc<^s^h&sL-i7CTxy_?!3x<4khy`{WvK5>&*Phm!Sy|{hfTi zWIsPj&YzO=r{w%eY=r6WlJ|cl@Bgx&k3`RxqTR{)Q*!>4oIm;YGdX`s&YuD^s7@Wu z_x7b`hSS=KIckqxG6c_ zM>;Z+vCn^)kxg>E@AqfP@qTi=pB(S|?Lm68esX<3xxVkWm*o1s z=}p}A#Q%HyqZ03h+Ks_~R1ncCKD)8@pOf>z{qou3t^1p(?tY;3oPj5fzH#!@3nopQ z#(|ZDvxDUM33tX|*29zgf0FxulKX$u2=Nt(B%cQ)=LgB>0e*W(J`YGf4@f=_@Y{o| zpV;e3$>#wgn^4GqpGedYzjLQaV0R_~PDq6u*Wpx$v%kajb?0YVU96J3?#}3P+mgM0 zo_s%G^8J9x_XGOvC;2{+xa{onO|z|IHo!4S>} zdpFkfO~|3APoI3nHTqHtCu$Iq<9mBPl3cG(uGc5m>%~GO&+F>5Ow40)KaZ~u(ffCz z-O2qt$^AUZ{XBkqN$%(QzrLR*IC}5gCA!0BcgOcR8am|O*OQr3BQH+p)4h9|VwXd^ zp4@|%qz}h`Qg~M+kKdJ_?urzG)!=-v;fr07Z1AZscSV}P1HRf7Nk23cx)kgOE(i0# zQ+Mu)REryI00->a6$yivg6X|Np}W9-;94*b%xvEknFJPs^T9T-iuCu3?26QZ7lM8`t=Tl3c!4@0xSd@!G++lUE3qI;ML#;@G&s-{ZQy*urHXI+8!AJ&H^WZ8^989 zJGcZqGmZSfv0xZn0j6h#LcR7PU+@+%4}1um1TF{XgRg_t;E(qvK6oD(2A>4e4-bXb zfc?O3>BI+ngOk9Yg7d*^!D?^;*Z{r=hQVeqy-z5V_nr1gfAC5$A1ncz8VB|VXMy=(B{&6K4lV%KflI;7;94+sAL4@tf(3oyd*Aj* z1~?kb1{Z*{!R27z{^-Gh$P;|vu=Yp=IJS3tqy~KR`|XiNu-g&sk#Ro=g;M%cUU1ex z@&h-W03AGVNPDCe%m*_DghIE2+2995+asgFDJQi@W`Y$bw?`_$Rl}%fFyoZ=NE4WK z8uffU{&|!W9CvMKWmRvQQkwrI&dJ^42}RpN5UVN1ug`0zy@$U*aQ}XUw~EMepe7590E3j z)4|YDq0on57PuYE0gsqKeDEZ&7#s&yfwzNo;A3Dj_yHI?nsg@;A3O=n0e=RL2j_sr z-~zA;tOM)7x4~v`8yM<`eqBj?a2uEdzI_$(!K_Kd2k!){z;$39STngjvI#u(>h?(L zF}T6L;2LlQxCxv9?f^@`jB99L;8Eaea2U7=TmYsXOF6*4;DJ+!59WXq!0W*h@OE$s zcn`Q5Tn=sm*Mh0Xg+gJlFPM5Q@xepD31Bu@0*(ZifV08X;FI7c@O3a1{oDrb1VdBX zBfZeW9B>$TAy|$6%m*95S}+WL45p(WhfHga3_(AJgJZ#K!I|J#Tkz6myh>9-Oe%my<~#BPAu;0mw+41EydVvuohef4!Ny8 zvJM=5dwXO%I34WqBicPU7<>gB4UU}K9w`EsfeXP8z-8beCBz5M2e*SW!5%{>4>%ZH z1&#*40E@r@^N0_Q2A6>|!FAyM;CAq?J7^a}(Gze4c)-umEAT?F1e^^n0jt2(;7i~p zaIg93)k*LP_5};U5#T~_0=OJ30W(X94~_#@gH_-ra1EGxGW7@c1-sozd~hl_0lWt+ z0at=cz}{uV2Y&``0v`oahtWR3zF;dj0z6;=@xdan1biD@0{#Um!Q|E^rI)7AF9b(}lfWWy+=J)~I15|`Ry;&}@JVnx zSO@kv9sa<)507rn!zzN`qzoFj+Yr&=92jE(;%M$uIunEk_<(56ng~T2UdcgfwkiQTk-|hfNkJEz|1olt5##rz&_wuFb|vwUJO=(FM+k- zAODl_8QASH_y$LUz0RV40f&KWm!dD=peN85a5Pv2UJ2HL&w!i2x+l@oyijN>*cZ(F z9pwhk1t)-e)u89#Q(!gN2sVJ*z%bbF_vqW%yh{M=2hIlbz-n+3_!n?KxEZVl4}6OF zU=A1t&j-^-(m#Ryz@=awxC)#EZUg6onNJfRJQi#KF9yS437CEk@&)^WYrs6P6`TZ4 zUPgRy8CVV8{S5jJt^ixX(aX`7eA*>A7+egF2G@W^V81^gcW~cY<4ZG^TAhEk}o*ndGZBs z0BgZstH>8T32XzWgPA{uUvLPx85|3adVz5zI2BwB{t8?PZU>veqB`ok06Pix1$TlY zz(Zc7zQO)r33w{F1UwI14PF6m0-M0}^9c76e1rL59(W}<348;b4;H+Pyun+*2Jmq( z3}&n*{`riHz<%INFb`}7r+~fwh+PB+fHhzR*a#l5hWY{vz>Ev9pI|n)5-b4I>#Oaw*N7G+{Ibh1G@CgnE=Yu(G$p@Sc))IaR*aWTv8}Z-kHSz^d1T)59 zZ@_G@5-b2;0Smz$V9`aS`#SaooC+=jtHE{P2jJkbw8uYFPvGs~Z17F63hdKJz5E0_ z^%v?B?6Hpa3!V!WgA>3iu>afC2e|UD)Cag0Oud+TUyuC2ao|$$@8DYSGjJ<-)4Pnr zf66!v><@O|fWCpf!71P)VAD9-3D^dH2xeYFdVfQ1;Je@i@MEw9Jai-a0p0_y1^0gs zIe}SV#-->Dm<=|7W5KhUDKB^-xETC7xDsp!H-U5BM^2Z8LhpcWVAl`Ge?0mRjt48i zV(`SjlP`D=*Z{5s!(jF%^1U282xfz=;Ak-aL+mGb16T=u4Az0En`sZ=V_@pfsOOK+ zM=%@A1DAk>;3}{JoDfF-6VPX{4qN~>gAahAiJ{OwTZj)11M|SK;3RN5I3FwqtHHa# z1~3A)g4rL#_m%JoW`kFP1z-_a2;L4>fd2$*!M-ij6PN?Gffs|BSD}~S5by?YEcg*v z3}$YHZ}5lU+R2Qw!L8s!V8+$76EGWG0~UaNK0%McVcn$jb~K`u_}~g~G&uMl(81AQ58Ba8a5eZJ;3lvU?2rC`0Oo_+!3AKS&p`Bk0k{-g z0f zK5#9#4BQCjptn24jeZ^QCFKRjg4@CMV6Q9CV{jNatc`vJoDa?h9|9MHPl7AK)!+tj z?7z@Q^zwEv3#mT4;7L2s3veu0hh9tto59{+!T%)61@;3|cOoxv05}EQ1}*^G z!KGlYUC0YO72FD533fxTO2Gc$!(cwR6`TU*v=blf9U(rL4UR)^GC2t|8=M3#24{gQ z!Afug*b43h_v;dg^qN9{2Mz;QfaAcm;B0UsxEO2&SAzK|#0PHycY<|buWRWCz+vEC zU5O8lNR32_!R25T*Z|gnAA!waS{kdiQ)zc#7I-?C16~Y{2V21s@Q}SCktN_M;A*e{ z+ywptOr3^)fqlUh;0SQ!-jT>8a1uBloCQ{cHDCky5*P+Q1k(#cp)bLH;CIs_kv#AZ z-;G3yz*oS9;NJU0BFn%-z;)mq;C69$i$pT7qnzLnZ~-_LdxbwG_%XN?>@gTV!TI2J@L{mW9Q5l1>KR-Djssr@XM?AoNcq5V z;A$}CN3;vD7nptvatHf?L%=-nKfyw9Jy-#L0oH&SL(ngb2VCqox2Rs0*1+%~=@E2gHnDzr^fg8abunim!?sXFS1NH!`zvqP8;9zhHI2vpKXM!Jq8R&T% zm<{fCN+ePM_63)sPnoBZKlODiSV{PCU@f=+Yy*3oM!Du9_tPma?y+DV?mNLr;0mx> z=x4weSa>G&3*G^?fwf>}3H*X%!NRkU2l&uP;(M@i9Jn2Hp0WJlrz*oRJa4Xmhwu7NN$oD766Z{y=0}r_ve!-fbq6gs2OVC^JE^r;V z1l$hFr-y-1ms#hBy3EYza%i``(<{0d|6b54HtdQVC1FPFogvVdzrp-vzRt6vz4@_U z#+mzNj_khAjp@aq(+(MW><|0)!B^8A2WGvsE20s_laJ(wsS0J{pC$2~kL0z0zk*G> zA_t0J?tU3}q@1zuUZY?Lr_h)3cP8{a(4*gK=)%`p{$7FK@m(!?{@q>gN-a-Yuvgb} zx)M~<+0I`|^R7rf=%tf#h9)HR9+ZCo^sxc@k3ITe=vP9YAD|mXB>rgVoBzHm(%Ytw zF?K@I2iWwpefmP^cac6SYwLyaJuB*pmO%8bIoAF!bKkU!wSfYz22s$tn$)d z2>lh}A8*sI^y4psz8?BOn?A{>uY*gMJ>rQ|B@{aqVDAo|nfm(zt;ziR{NZ z=#x6&VLSB4I-vL13;pSUJ{bCd&58AUv_n70F5|hr42z&2Mf^nch0uFLzs-)HGSe?V z^jo2yWz%o*(_aVu(GJqz4*j7H=soC{?t^}&o&Fp@{lU;zLQf?B(a@iSeu^Ex$d6wH z{nZZQFNFR)^hEY!nUntscKTEN^w&XuBSHKu;%tZB2%Q$->sRjFt|^uc%uJ^r{3x*v z9s>P<4(MZ{XFyLRqnXfCpeM3nl}`SNY+x<)zQpfmm*FyB22IfWcfem8^kX}qXMTtE z?+)lgpdZx%eJph0FVPraCiFfX&?}*5K~E&VTIh-7pM^}CpeK^Qh)itNPQq-Ly+GpO z+8Jj&CG=k3ZjQs^t7C#t`-&|iWcPhUlTTcNLq-rr9D3P1gB`!cTXfZiYaXC369 z4}AypL+$j>_tT#O{d4Gve9H77F(et5CJ*_=5GC&{h(WgMKgno5^ZWLJ3UjY4s z1o5+=ucZBU%W03i%kR`*U22u#O)rl|(pXKHa>Dp!Eb-{A&<71~kFdOF(aqplc*vk~ zN}wm2J7hzj1wBz4E`UC>gZPEer*=TEfIb0wqB^dDesKr%M(7353j*ak%P&9lV(4Q6 zbTc{9@-taq4*iEV-AsM7jb=lC1$sO?F7XSXuj?RwA@q-+!-g+^%f?qgf4c*E4fHk8 zWsc(2?@zUO%3mXN;V)7BwL-6hF1&j2FYx1M?2n#xK+lF=+d=vT(4XvpUI={&^h50Y z%~VJEuYmp#^no_rn%mVtuYo?urcd_yZ-o95^h9IF)(+^yNHdG}aVK;0ix?lJUhq?2 zMg{IV%G|xXo}4-$WBhE{Fj~Nk$IRGZsdZlb5pxcNF$VlsU*yruGq@dm@pTmIy|i;jO+;> z#CnF8PS;~nBqQN@1N7eCZI7JDZ;yVhvZ3^y&<7`=XAz}W51!RPA8*SanRGp0s~{v{ zatL$BKJAe^`R(N)bBWo0J`)JDl`wtnbh;j@i3p!1&|AB;M+OAwM|$)n(A)QI*EzA5 zhch1*JFt#6oxLB=ERjR%%%24K=$fM9(DCX{!ewT(M;>I{n>xV?=juz@ca&+V&wjL% zI}diku1_3R@*hpuoqgIPXG{JCR^5xNPB!^VxY>m3eWVlag81P?9t%-2>1PM>+bgeS z1C~Lrg?_wEx7LT&L2u|F{&wi=JBZ(d&Zq9E_Q;!({%~gy(~_-)QLl`|-@&ri)Iz?(4)%!ZZ^mUK)}|CG-c5NldSWKKj`9$mMn(DdRjIo1otZ zeP)1uz0#$ArM+*1{$1uUsh^GYCuABh<6X=QR zs|5N^=);9q*KU~Q4sEAPp!cS}64~_C4*f7Y{%Bv;o1ph1ej<8mCeI8yp!bEI*#Uh7 z^aB&nMJ7eG-|s;`lJ=eYw~PETIpc8A!tZj!|EA;c z(hgJ6|Ie`Hw+TN#x57(%z24Y13D=)+`KLSK?)`u4y${%&)4lHhy#Gjv7#f;tszXyk zQyqi`sSZMeU=ResB!VCq1VJz%2o0SQni5Pkjg*wBrj=@{LsLyPZKs-Tr)_rkY$v-r zyS00!yV~qfE*E!eud9N#ZW_Yc{?5AZci!Z36Rq5m zqwI54sP8e9yCAMF9Md!2Z|#mtes-L1dZUBB%=F)z{;but4&!VBitzMedxzDJNGu5-W=aQpWffs zmhlb!m~Hi(KHf5Tt@Yg4f7~uI{e}+uO4A=TJ?Zn}deax19{RLpyjq?WH=DlH^gUYj zN&W2)|A5Vtnm(abZ}Ex7n*N&Uxi-E3S$neS+Z>zR{%q5?Gd*dX7nwfD^rUB&m8QRC z?H|=~FwjpEv!64tmk_ z`%F*jU)l79rYH5UYWgD62kKwA&o}HGf5h}n_PY16Q~HmQG`?Uorg@)04)hX8N@q^oHpVnVvL0DVv-vo1Qd28PgY=Zq@Yfzm|Ju&h#aw zPifU#_HV)TjUDuo>HFrApH(ZS?`?Y0{87#HT}`*Aj{g32$03q%d^Jp;VERt2`uO;I z8@4%Z=f~lu|3g=JHaxMvj!!o~pZ_e}SVBExK5TQbC)+b>Yd!JDk0|JqOn=*S`~)owW65kaa458s>(> zy}BhgG0Mt3Xk{{1e#^OgQUASag6T_4KcH1_nVXtn`U=zSF|~jFmip(L{#DZldfqW9 zTA8+E)AZ)H+i34Z+g=6^K8?9WBM_z>)SCGKKiDO zEi!%ZS#Q7dJLuhi*MH1~-)CNHWs*Kyhu?GFV0zLRM)q+0C)1P0C~f-24(n%4f2+g# zdDGu8Jv@JGIhMMAw`GiqrdQ8S-iKw=Uod@FyB=*>zh{Rn&$m_6mrqV!zi#@orYCJ* zm>65!Vg0n}k9Sx-bFR-@j$kZ|$I0O`mW2)YkP|@;G(V ze`0##{)nX7&8m%Gsj7 z%+!8;t_goKJ*gjyO+R4D+wWZ0x_& zFv9eonx1qHj5GZu)9q5*Uw?~lKh5;j9oC;~`tzn=)Vh9m9Lz`?TWosw)VJU1X}t!9 zG5)vyF3HOpPMjK5ZbpF8i^q>#2NsPTrzpHiq?qainw6T$2xnG3uNm+hj^05%UKc(7158tb@#`J?*`_SSkK|?TwH@l8XnN7~>s$9v zcYFYb{X5h2UzmP;n|@^T90~W8#dePNUhFxS!;a|R$KhQ6asRo#(&~B6$_;cJq^+Ly zroUwRL#^$EI_CG+5glO1>LtnNTH5r3O&_R@uq|2Bvk7|WL*De`OmBNWi_iCFGAh(D z*UHSZGXH3=w_Mk{*Ec&E^u?y1aB1@SvdZ*NnVxh_+F<(WreEAve;hsx_4giV-xZKh zf7A zyWGl*x-9u#w$}9UokbH{>*zjy%Xn@w{btj%t@?HGF_AVl!p@IJO%Kmjy?<|?f;CU) z&sX6X4c~+Hkd^sWDD&NxGA+kw+O+&=yB1uYyv@!1Z)H|lnVqftmbQ-VKSmdu{!P=D zwCdfDY}uYwrjNZM`54|{`k|&L&7t?2fpUuJNyqpI(bnl;M`YWc}Dce5=?)j$;Ej9gDrk~cThp~?BrYMwIV`T;x z;6=p!XgUU=AK`nIrdye$dsq0rrJ1HrZf&RKnK*n8Q^oY8XT|XSOi!Dhv@gT=HkCW* zCDZRS{k^U2w`6!Lrr(~he%jWlnSPz=*R-x5#;IkVDttH8YAZ9bwM@(TG4vDm+;93o zpDn@|j&|Lwh5mijlHrYMyUtW1~$UY3sKg?_rEv zvb>Y5%nU0twzZBpe$hNuXPG|F^ns3(uuACXA}e#Pm1(S)5n-@r$qla&uDIDv;E=r0C{2ueXQxzOdsez9{NAo^iqNzuA%d-;gzOO z>#}R;V^&z#SsTlq)B8VHgzpG@cGkexhR{yJ62>L0zuENNJB;ga`+$(?u>M%nvmMr-Z2Bo3)}L+qvW3Z6 z-$kZBZu&syNOSv5Uyz`uZTsG^^ZX9e?d}})e#PEsoP91k)DexfYmJp@zLwsShfSNl z$n@PpS?Mj;x~%CBnx6F8Kkw@&UCWB5KWXdl+FJh!{l{e4^w7VgYjM?eo9659U(4?S z)lFY&>z~@HcgHuB;emb9p4&{H(5CnQE^ylPL0^dH&9-d6&zXhwv!2tbmTfSo-1k{gk z&$&9zs)l-oW$nEGeDbwtjOq7w&?lMxi(B4)XNc9c<+y2irk`bc-qyFNnEpPrAN263*Bd@nXg|l( z#?3l5TOAv$jM)qQy8ljI7~|nbTHes~-COk*e{rnoZu2rv9`+e@7uoKG1Q}DrR6ij2Gf_D-u!GO-JkP9KYEXf*S~I{ ze)ut&Hf@xZ8*2OXmez9N8qji%=d8>XRwk)01=G(pJ*h7xUw>g#WsvNCsDnNHiY+{(OUWsj|lY)I@abGtz6RQkddY@Gd<~Z!g$lynVvKkFx~WC zyA~wXKhN~HZ2jhaLw#)dy~w4e|JL+@#vyI}Uu}Bb^!x2~+cw_be;<9r%H+cJsI|Zi9`jz&2%e7M1xt8ApA8I@CS5|JI`(o(FXw%;? z{R6G___J5gCz`&|^rY>WX?pn1`K0YwV0tY<58JWa^cPIu+IFnBa@*Q@nzS98O&?}@ z(sm5DgMFy!N!u~j^dY7vZO3HOH+R^M*{1*YKd>E(t=xefwqup)<2r1|2Gg@0wxjn1 z^9MR?#|YC$Cg@>*j5B>#)3>%iW>~rNtX$Imm~VQ)^rZc<%=FTI17AZzKi1p%eTV7K z*z4X8@6~=C_+tNgzRBtta{s_{7HL~|=!y0`XZj3#-F7W$`L2vHR;FTQ_H8ZGaxIx; z`tzn&TlMbenw<#e$Sl*(>TtbVX!>!cCtWL6m_FY0JzMK+jvFxAgx_(@*J8 zfB1g!Tn9aT@A!$P+mQEF3!q&XBOap6UGab=uH6(@)sSbJS)lbBC2lI=_eK%*XD~##qxY-%1;KE3>3S8%5L0 z9oi_He(zS=2;b5Ea)&m;cehtNw9$LA&1-L^jgeO7Hyzp-Z~7WL-ZzH*vE|;^|J@kV zO66;(k0%U5{Toexqr>{)d+EdT z#l3Co#}5x-{qTMDlRDhH!}r*q-r;ziZu4)2A zz20vb(J|0-Q1ioHXk&)evC=+2U1_hk=-qKAgFfH%Aqk)Lg1*f3FkdpzoKMi#nEpZi{jBf0SlB<0oVU6Tdnoz3Ry2J-(`~x4 zzn&I-}-}JV7N7#lV`>$WCtxU#sOg8=>)s>mOw>N}xy$hUINZ*Sa1Gm|rHr-Jb58Rz);zw$ z-|~2KQSx|9H2p)547@$z8ZguJolPI;*(YuK0@G`zTX*{V8P92r3tJrOSYc(NN0Yt% zb*Arb`anKVSpQAa$C!STZR?h?=$X0YT0QJco9lWk`C1qLPRYHdZ?e_5tRMGrgZenx z%7nkYG|+wxeVA=}&h*Kxb+lw{7MVW3!}=>tzuEMG?gwFizG3Hi(7zVW)AQ^pPy0On zu9-)}SsMBg{)Wo7UrO%h2-Dws-2PTYTR-D3z6*3Z${ya@miwV$o5K12Ytx?%b**fvE1VCDLoM+<;ySBm`r?7}R-x+9 z@6A@`l^+aztq=O}v#q@j`dHJynV^Th&aiWG8|y>(-kaVJwfD7W*Z%WquGQ21<>d2e zvFZDop0)kBWgqr@qIr=G?X0zSj(fuLLOs^bE5rKBg!A@8{ojEU{Eo*^8WkgLaS%Y*9QK47y7Zn^u0{KGqj_zZ1G3enSM`) z_1`o-{JpZI^@p8noaP7` z*?-Nb>zc93>N?-*YCfB5EL#0P)5G6dYkoG6-s=CI7q5R^7)xCvH80q54-J3Y=2@%f zmez9N_-*z7tjrEyPwq?jdpMgr^rhtMZ>=vYtlVU4=avqAS#M>Y>(H0YrY|u)XFBc$@GtzesyadIHtmRT(okttlVy`Tk~U*`{~u?@TN6 zww3AB--V$+&n5SFh3Q$-x7Odfm78znlKLB+Z*yR#ck1s5D>GEYNOZTd#joAVgjRvp_dKFVY(x4*SB&^aC2nQi)!rhmX*Z@GuH_$Z4^KfJ?stTcU0 zhwWHz`d$h82y1e)=|fH5+IEb%Ad1eha!K1U&h*PoPuh-Yre9+EK>IX|!(7v+nLf~X z2Ys>WrzGfMJ64$<{`Th9w&M*ecbAn*+K#~&+V6Cjp0pjKOn=byr0tksddc*p?U-Tu z%?Wzgj`^m~Fnw#=vE0gi!^$OX$6C{0Ha%%OHktlnLO;^hkD(XY-;y$Yvc2ANT=M#F zWj0!wq_LP}`s*Fqm}PoxD{U;YGJ~E^ZeykC-KGyT-eEh|o8H(;8}`TNqLCfiNSnTA zhc>dNr%dlOR@1D^_zrE%HT~{y`~KAPSIgY(V$&Cy{_(Isq+b|6Q-||omFZKzJMibY za9nM&^L)OoKhIwGzA(7Ij_~Z}f72wC8*b;v8&i_ki|tt^M6#?cHJRCH1%W z68p?zdQyK!n7;OvbKlAI6_Os8|hkj15 z^J}!#U+uAeUft5q@O$CU#GkuExtUgO&5!N(_q(m!O(=I^|7X7W)?Tl*x4W&gMfq<8ee~)`KHj1&DM`U+4epk`mrtg@s<9544q;7^XJLqI@Vz0N1X*lnz@%1C%ci!pR+P}u@9X>Qkm&Ah#@Xw?-=^=WA<^P(f8Awo z9(YgR4~9fPc+Y*k_U4)JCyT7w!=DW8{=BE})xps{y@%RInBKm-LshG7cRw|#@1-50 zKMgYc`}g#{wL|o+?LKBF+V*|VT9e!V)k;_mBk$-cT0dXt?)!aj^oMS%?dhJrC;Fnb zq2kZ=_SO5MmwSJ1C9G`flqc-A^A9`D`r=N}Pj-rXkoxG)tfKpRM*O@dD)z?gk*|q4F)t|CI zK)Pe}d|%&hcZ@dmS+VD~>3ca9{b-xMuce|z+ggd0+x9KkDf-d2efBrz?j014w-?^i z_p6*SBEj=z;B@u_C`5oc-0#(St+&+}qre|NDEm z_Y~WXuXOc&zb9JJ)mQ0>{@S&dZF_g${NCtC-F<)Vu`yp3@0S0Gq6eP(2fJ?lOK;yJ z+eKgMvuCBB_VvBCU9@1EaZ&Wo+w^^Q`{?Oye`d8l@Sg1I?W3P<_m#MXu=6|p+wrWh z=eqjVbw%^TUbf;pPI&MC2ceXmFZ*}xGv3Od-?zA{>lSUg+u4L z?!J}X(d(g7>q+Y`2L4CG+mmhRTzX&~D*0alt zJ>l%v;55hQ|MB(0k@)cY!=T;JWoO2Bx}u+kVTq59Fm8Kvy+8cHw&{HjbamYuq@`WE zw3lig&Hu4-ADC(tEbrQFVRy8ytM9h%$o7G~{(cyKt7ez8ZFy(&FnX}7?^|7Vmj15_ zVc)&eHTdoBzCZRxZ}mJHU!I42)atu%pU-tgPkPOJ?Qi6?VXJzhn}5*tOmFl?ci%(3 z(L3FJxA#UXdPW%egI|W52U4i>Q?|zGedk2i#(f(y+Lp)fdv{m#C9iY)$GblIV7DDw zae=VnPM`1ku65xvy?q;dqX+u>h3zgJWoOE-nni64cYU$T9>ren>HA$zSEIM@-+H5m zLt*WXP}O_R>ANxdf;Y9@^qzaVq9x&7(01J0UfkAoaj`qx8k%V2Cl0iatX;zzebKYl zhhOzY3w!%s?hAL!uk}S6dPf*}WSh7whij+9-|m^y7roNk_eO8@bW5)_76YAY|DhoY z75py_Q}dYo-x#ORzp%^B>6>O(ga7$4`aiVp!H55`d-pFL~Hx@Hc|=C3pRX1#@gfc<$X(gqq};|U^eoBv8G&c;J^1qFLn*H zBmB2^r2V`%deRS>U4mTfI`9|av_ElGcXUU%$l9|*l(K)};QsW9X0+Om-A*GrPnthL z&)dJ7cYFJlW5%5n-MHt>>kAj`dFYccd?+zq@Q70q)1QEUglLlJ?^ooELAN9q$L7KdQZUOuQcs z|8-nn!I#qCUAB(^_rpjZucZC(7LMzU7Y)20CXM&&+Hd0hF!Z0|Wqa%IzS9VBKdkX_ z<9;~(^>`dd{yoNX=D_=5>9O&CDEuKV|F|#J?z_u@M_|Qg+OP8(?F-X!dA+|L@8{wD zLcD(h@4w;i2S@%>jF&t3+fjdtTYA60&mA1^&*txF7#rlg`TG?1dXnoQ;~RdY|J&Q| zToK-f%ysy&C`R*V`upPLHvWF2>y|!l{+zr=ytLGF^T&Qmy7{wzAw|h%=j|v z%bYLszAX5%=*yBX%f77mvg*s4FYCT+_%gc9+xKPKmlJ@T|>vMs&; z==~1ZFY~ee4~Y|O2khfyz%^soWeba~zQZEny4e-&8V%YfZa3`(ELlEa`EXtBj&_VH z_j*BJq@CBnEoa&+Pao=7<6Y72QQEgR^e_CJX8*dP_iwpRHKF}C+x~@ir@d`Uzhr6PkBKc^Gd;|7#KB_k^ zsQM3co^c*Bj^XD_=UMRUoaew7IM0KB&3OU*XU>b@|Khv^9_+oaU1jhveH?fN{21p| z@Ttyg;5R$3gFoWD0sd|0QJ=lAAC22Dou|OVuiS)wrolg8hj-u^@WY&E!OwG^1HaXI z9(;-O0{D-d7r{3O2EJ%Xt?35$8GZRnGI^|LnW~zTGx)Ka1c8IWK{q>AVa++j#|ik@G5e z)p-qkgY!E0kZt3BHoy;X9&Ot`{%1H(f#2vn4PJJh0blJr3;svvIq===={X#qdGI5g z7r>`EFM@x@c?sNt>hbXp{%hwI@IiJ13;n5rAK<(OKG}I4{5Ize@F$!{gWAXcr_NL0 z|LQyqzKea%X1!T;jC1fI4Ja?R@xc-DCZ`~v4y z@Y|i&z?V3$ga5>N1N`^SqxZCr|IYS-IP^0GevtDt_*u>~;Io})!5?v+0}sFE9@@== zzwW#MKG;5}hw?@6{hgP<&vIS{zr}e4e2Mca_>Y{|z&AUugYRL#bsGBF03Yu>+OB>4 zFLRy(zt4FZ{CVdY@D0wh;5+OX_a_HF#(5t6eCGx5dz}}-zv;XL{+jbL_+On@z=zud zNf@^(_@|uLz^6E`gWv1C0sal=(e~}*|7+(d@NIXB`;!Jgz4g5FG>)_kk2cG8f4?fCyG`M~I zPjsFFzuI{k`~l|~@b5a$f^Tr110OOp?q?o+jPnBcdCrUAbDfvK7dtP5uX0`i-{8Co zzP(KVhViU{f6RFue1h`^_?6D19oonLLFXy(7o4ZT>&`Ra+uB#)g??tiKk7UOevi%ixhsh=zVvz(3-=3VyWn8u(?->)`h}Z-9TzdE~iIyX-W7 ze&##{zR7tSd{>*84gJr6ALcv@evb1T_|4Aq;Ey>kfWPd#2)@yI2|Q&J>7k!x=Xu}W z1Dr>m^PA}WMCTKo+sEqW&m8BcfiHJ{I`}_1KLdPwo461CnFK!C`I+EnIzJ2iHs@!9 zf7SV9@b%8m0S{kj5c+d2_<_#P1E1zR5B`AjDd4M}PX!NOEF0QAAN&yK)4;EDegXIk z&MySt?t^jt7lB{wd^-3;&MyZ4vGYs7x3`J2(Em%pPjo&5e7^I`z<=uea_~PozXE*t zhvIe%;Kw+>68swHSAl=o`PJZSoX-S*%lS3nd#B_6Tnm1N^XtIxc0LQd?)-Z2gZGH* zzXAMA=Qo1SaXuS-x$~RAf8qRQ@SZ*6c5eaCI4^>q<9rVI-Og_Xf6n=B;2WIJ1>fnz zaerIAUhpTJ ze-?a)z2bUG;Io{64t%Zi`@m1wJFe$`@EN!+uRGUsl;-~% z;F|xBQr*q=R9^G{DR9mIr@=M|0!_I|EIw<|DOTZ{C^f)^Zz+; z&Hv}YHUD1#*ZhAGT=V}WaLxah!8QM10oVM06fouLh53c$D0=VY?i{P67 zFM(_RzYMPV{|dO~|Eu7d|F3~-{=W{c`TqvE=KrIi?c=Zc{}j09|I^@_|IdJH{yz(@ z`Trca=Ku5Hn*T3=YyQ6ouKE8GxaR-M;F|xhfNTE03a)@LIZ-8t5KiZ{z z{5Aid0@wV18eH@L8F0=2XTdf9p99zYe;!=({{?W({};hE|6c;v{C^o-^Zyla&Hq=y zHUD1&*ZhAST=V}8aLxZmyS9(N=KoXRn*UFOYyLk2uKE8gxaR+J;F|x>gKPf30IvD} zBDm)NOW>OSFN16TzXGoL|0=lV|7+ly|F45<{=WgP`TyvB?c=Zc{}j09|I^@_|IdJH z{yz(@`Trca=Ku5Hn*T3=YyQ6ouKE8GxaR-M;F|xhfNTE03a)@LIZ-8t5 zKk~qlp8qxfp90tXe;Qo#{~2)2|7XE9|DOZb{C^%?^Zx~K&Hop{HUD1%*ZhAOT=V}G zaLxZ$!8QM11K0e29bEJO4RFo>NAGVx{x$!f0@wV18eH@L8F0=2XTdf9p99zYe;!=( z{{?W({};hE|6c;v{C^o-^Zyla&Hq=yHUD1&*ZhAST=V}8aLxZmyS0zM=KoXRn*UFO zYyLk2uKE8g_%D2ZAm?14_kZhrBKT(Klfc8*K!?xKlfmETJP$s?`84o@oKFWo*7*$Z zDb5SvH#naOKF|3q@P*E2gD-Vn1YhBNF8CVf^T7YX`F!v{IWK_^-Y*`{1>k!)UkLsQ z=ZnCPbzTNP+xcSfg7c-|bDb{(U+BC7zRdY@@E4u00DsN-O7Pz~uY&h}JRYA_;JZ6t z4L-*C8t_w{*T64vz7~9r^L5}4J6{jJ+<6`R$Idr8x42jH=hw~~;0@<*qMqJNJPw<| zcX1wlAikdHyx!Y+FZe;u2Z0~$d@%TF&Qsv$J0A*uwew-%cQ_vozR-EvxyEOy^O4}s zJI|n=pE@56E+6w4=UqPj@-aURE+2C|xO~iG!R2Ef2QDA;cyRfc6TszTo&YW%^F(m@ zm?weD$IOAt$2=KaKISRl@-a^ZmybCSTt4P$;PNp~2bYg|2Dp68N#OD^&jgo`c^0^Q z%(KDeV@?K_k9iKbe9Uvfo{AF9es5 zc@emL%<16rF)s#}k9i4rJsn@KE(Mp5IRjii=4IgWF)s&~k9h^Se9Qv4e9SAsGkeDU zyb4@C=GEZxF=v85=k;6zE+6w+aQT?mfy>971uh@+dT{xeH-O8>yb)YJ=4^2Jm^XpT z$GjO_KISdp@-d6x@-gRt%g4MGTt4P);PNr&g3HIe9b7)<9pLgY?*x~RIS*Vu=3U_O zG4BSKFZmg8`I7U&b0+%oOIdJ)s_kqioydPY?@Xa<1b$_1ukDQ4K80Y11?`O3oc(W2QFVS4=!J_04`s$ z2rgf;1TJ5)3@%@?0xn;&3NBx=1} z8GX2Y{N+ogz~xJ(!R1S4z~xJ3!R1Tlz~xKk!R1R9z~xI8!R1Sqz~xJp!R1R8ST|R{_-VL z;PNHY&h>d;zT^mS`H~~S8OWFB0;5moGUFT)yOdaQTuYaQTu8z~xIW1eY(l2wc8o8C<^PVsQDAOTpz!E(4b@ zSpk+ay__w$vU`v$qnH0B{zc0 zmwW?UzGTC>#z(&7o8a;#qrKzno~~o^C40d)H~q@pqmlkSQ7XUd{$c)Y_bB6B?e1wj zd{5NU-^UY~uljuEROdJR_Za-b`4i43HewLwPs7h{2gLP^`a}F)<=lk+407=u~P<+lzW8IJ?~)(?WqZ`~bSe(Q(8<+rB6<+ttuF28k8aQUqt2AAJD z0$hIUN5JK`?gcKtb#HL_ts}wZx9$Tjzja@5`K=!Xm)|-HTz>1vz~#5@2QI($k8*z~#?o!R5~$0WN>`NO1YHM}f;{Mm`%@@G#2mp^+txcu2Oz~#?Q0+&B~Cb<0Bv%uxgo((R4b~3p9*>k|<&z=h| zfA&0Z`LlU&`Lk2N<voD8n#fm6WsJa8(wo(Cp^>v`Zba6J#4 z4zA~cGr)Dfo&>J@^_k$hU!Mi8`}Nu2x?fKQ*Zuk&aNV!Z1=s!hJaFBw^WeH)PXX8c zdMdc?*XM)lemxCb_v;J5b-%t4T=(mXz;(Z#4zBz4#o)SMUjnZC^`+ptU(W#7{rWO+ z-LEeP*ZukmaNVy9;JRO539kF~Rp7c`Uk$GN^-OTxude~u{rXyP-LJ0$*Zq1HxbD~2 zgX?~M1Gw(jH-hVaJsVv2>zlxJzrGn<_v>50b-ylx>wY~4T=(l+!F9jB4P5u@x!}5A z-wv+(^&Q~4U*8F?`}I6<-LLNg*Zul#@UdIDUzfZ*@7D{!m8V(=t~^!QIrCH%aOJ70 z;L20gz?G+}gDX$f09T$W+Bbdp|ssXM%RrFEYaQo5tD^HaISDq>j zt~^x+TzRT2xbjpvaOJ7;;L1}Kz?G*ef-6r|0#}}@46Zy?1zdTmD!B4gHE`vr>fp*# zHNcgpibl1Mzw%TmaOJ7e;L1~Fz?G-Uf-6sz16Q6Z53W2_0bF^iBDnHYC2-}b%HYaV zRlt>}s)8#|RRdR^st&F^RRdgks_0|w7<-nDv%7ZIU zRRC9>stB$;RS8^qsxr9pR26XLsjA@0Q`Nwgr>cW1Pt^cdo+{d}ef*WDN`Wg+l?GRy zDg&-ORTf-%svNlTRC#dasS4oAQx(CLrz(LfPgMq2o~i<_JXIB3d8!(?@>F$j<*6Fr z%2P!jZy$fDR`r^E4|<*7>G%2SoWm8YtJ zD^FDgSDvZ{t~^y8TzRSnxbjp{rhWXCr%HhF?n<*5qb z%2O4=m8U9!D^FDhSDvZ@t~^y0TzRS*xbjqWaOJ5Q;L1})`?rt3@>D5s<*Cx(%2Q>) zm8Z&rD^HaJSDq>lt~^x%TzRS@xbjpbaOJ7W;L1}~z?G+}f-6r|16Q7^4z4^^16+Bk z=z#X|SDq>bt~^y5TzRStxbjq4aOJ6T;L20w!Ih^ffGbZ`1XrG_1g<<)8C-d)3b^uA zRdD60YT(LK)xnjgYJe+G6&=_<{>oFOz?G*;gDX#!0au4qSPvJh<{y1#so5 zir~sqmB5v!DuXLeRRLF?stT?=RSjHusyevxR1I+DsiM*CDaym8Y5o zt~}LjaOJ6r;L20Y1y`PG9=P&U^TCy;DuF9cwE$dss)gXnQ!N5lo~jJ4Jk?U?%Izpm zRRLF?Y6a?1o@yny@>ErD<*8PID^Il=TzRTB;L20gz?G+33$8rXI&kHw)`KfgRd=rO zQJ!iexbjpD)T2DrCUE(TZ#t*X_!n^bjBkOB)qnYnUEuN=yTRo%_JGT0>;;$4*at43aT{>?jN5|CXB-4BpYc85@)@@Sm(RF8 zxO~RJ;PM%F0GH1=1YADjj^OecQ{eI$cLJBsxHGtX#`l6NcQh1SxuadcKE?@E^;CFlZy};#5?hP(qawNEX$$h}(OYRFUU-F~i@+C)s%a{BZxO~a| zz~xJR99+I+23)@6{^0T@4*-`hc_6ra$j?H8I5TlfBBLraQTvHaQTuMaQTv1aQTus zaQTvXaQTu2aQTu&aQTuYaQTvDaQTuIaQTu|aQTuoaQTvTaQTuAaQTwaA?@QYUor(Q zUos6YUorzOUos0WUor0*;R>9><*1+XU*1_dVHo)aeMu)YJzkJCQxO~YpxO~YBxO~YhxO~YRxO~YxxO~Y1 zxO~YXxO~YHxO~YnxO~Y9xO~YfxO~YPxO~YvxO~Y5xO~ZIZ2S1jmrQ}nmrR4pm&}06 zm&}68m&}37m&}99mn?wGmn?$Imn?zHmn?(Jm#l!xm#l)zm#l%ym#l-!mu!H`myABy zKK}A0Q{eI?)8O(YGvM+iv*7Y2bKvqN^WgF&3*ho4i{SDlOW^V)%i!`QE8y}atKjk_ zYvA%F>)`Sw8{qOKqr=FBxUq$6vl=3S7Qq z8eG0)23)>m*110K%adT zE?;sHxO~YnxO~aQ;PNGxg3Fg&1}#)ay7Vo z$u;2eC2QdFCD%EZ?FS!|9zGQSnd|lFY zL%w7$xO~Y$;PNF0gUgppIoJ5emmCHzUowq)Y9Q(Ma!){KQ4h_W}Qd^L@dO zKPaBJ{3!SrosRw)0& zjEDX5kdNm{K5oBr-gi|zVnduCZ96WMAL{&0=l42iJ%4ciThxD=?YL0S!>GUF{7KaR zmUGr~?qP8~hh7x-Q~iI*`Tke8_y2=qiiwWAE5rboxg_q z*E(lCV-64dW%p>7AGbR1rWqe-oWJV)oSE@=EFmw$Br zLocs(Pd_TIXPtAk`(x+t2?mG#sNF-x#pR36wY}eR&i&PMbX@)&FRylIIv+ACu3zo` z&iSXDtKBn>iR<~MbG7@o&JVgiu4i(yw^20p)A4ya8t3U#&JP0LY&;w%pYwX`&n`EA zE*>BAZ#%!*dBb>Dv|AJ%+0!KQcZMGum*4M(xIb2+`E!Bu@y?ex-{}1J&ei{!$Ho0W z82x;~`6s|r$H(m+cVpbH`hT{lCC? z=>Ozf;{K@r&p5xKF|Own=U4jid5iP!IoEmm zXXl%of56M%cv@UfYEFB9UUt5(bM4e>v_t#`g5Q2_0H9w_nj4&f77}4?^NeI z-xl{%{aNBX4c>irT+e>a)t`%;KjvKhsXMPZSAQeE02fyQ=3K&d+tO@qF9)Ea&Ra z+4;DhJ5bL*JAWPZ955xm4rKj&*Li)O^CI|s=T-1;IggHvKX>fo=ZkWN`#A4%uD>U> zFSv4s9|c#=a1^+5h93i0&Tv0)_gQus)=h1j@@`_i3E3Y^cTzSQ7z?E0L7F>D7>%f&)oCU7D z;`QLlE8YOEyyA`E$}7$W|D&C!o&GLW-OFnpa-H4(!{?3-;L0m*1Xo_M;as0Xl~;_8 z>b4sDzfU843=j3Ez?D}_gDbC?0asoz3$DCk4qSP~Jh<|T1#smRi{Mjjb3*@1;5R!j zgFoWD0{(61Rq$UruYv#7c^zDN#RjN zGyE3cRXS6(p>uDoIaTzSPJxbli6aOD-t;L0mjz?E05f-A3B16N+L z4z9dn16+B;VE9StJ zSImPeuUG(AUa<(SykZGldBrlg@`@F3UNH-GxE3cRbS6;CIuDoIqTzSP3xbli+ zaOD*%;L0mj!If96fh(_A2UlLP0j|7abX@!RE3cRWS6(pD!B5BHE`t>>)^^OHo%ovjE-*~f8`ZZ;L0ne z!If9cfGe+<1y^1%2d=zg9$b0F0=V*uMR4U6OW?{Ymcf-*tbi-8SOr&Ju?DWZVjWz0 z#Rj`KXVi{a{ z#R|CcidAss6>H$iE7rl4S8RYQuNa-sKK{xprofd~OoJ=0m;qN_F$=D|Vh&t+#k_NU z-dA368o2U`)4`QjoB^)9VgX!v#hKvBE6xH}UU4?K@`^=prC*1(llTnnze;yQ5U71x6+uUH3HUU38XoR7!zJR8B4S9}9p zdBp~}@``UdS1w3-#puNN`XH{n;vnZbPnB0346eLl3S4=`q2S6Z4g*(SaX7g0ifM4= z6-R(8uQ(E1dBsuS$}47^YaEnU90RVrVixr%uQ(38>-^YnO|7trNBglDTl42o=f^oe z)cH*3b5Z_j=P#iAM&lv(RYYF#ebeIOXT0|(Zas>waegfLPn{nJzTX9LJ;#IJ<$MD8 zM&~DhA9Z0|&xzoVJ3k5h-<{{c&%Y?H=Vb6#oSy=||Ma;0so)EZ2jBlqA5V+N#6K6u zd~r1%G5O}_Ie*sqonHK_&RNecm&Emq|5jX&>c83fAuqPq|7(?ZuKGWA>A>|o=zJmS zf5-VxQU7@};(C6K`k!{rdfsArS|^UozHZx{(t=Pf$LdlJRG+xkXQVn zm*+UY?~1sdzk2;U`uNXxzTNlY{wVLUZ6Pjym~-Xmu5U=!L=QsCSG!lwjO%&A zx!T>}eD{~*derX4*Tm(yzg9SZ#LH`Y_q#SOzs$MXebV{gIaj+Muoq#wCjOwk-Lmta zJ6Db+Gb=t%C*nN4+4*VUYmJBcKfXGyU%8ZHu8;Yd&TY7wKd%}OdBw_6JiF$5` z%dheB%Fmqa{5Q^*cs;*xKL3YtyXyZXH^%)x9sT^4^E1Fxv*UI*dOhm@ZO(UoC9Yrn zPu&#vzl{DLX*`U>9bR7j|D5x(bM=3>o8$7w{HVSEPZ{-1?@9(HTY z&j!EGcxZRB*Q5UT-4^pZoU8x$84t%#5&d7~<=^u1>i>J^#`O&SN!(BMf06U&ovZxs zoUe7R`_6&4$Mw7pe!ugEbGsZhe>OXx^3%9oou}8|5!Z8{bLHQf$A>dy<#S2|aJw!J$p{|fkY z=j)uSKd(AJHW;|}qw&doCa&iO=jzWdoj>SY{n>YZT)yI5{khut3*c*=uW_#a9DYw+ z&nI7P@6Sr-mpfN~j=483f0uK$`-Jn)JJ)sTkk7{DH#t}T?{Gfk=W)BLXQT7s&Q;Hi zrMRA1&Q;G3o!^IgKKi-1d>Qq;;CwUc8GK({e%H0_{kh!v2s%bmx)wff&5w|fP+@`?p;4X(W6 zP2kEa-VCn1;w|9HD;B|(SDXW`yyC6k$}8RmuDs%0aOD+m2UlM44shia?*vy~aUQtx zig$r4uXs1O@`|4U|HmouaXTM8JvHX{fa~wK-V6T4ed6+;1y{bY1g?DJ=fIV3yboOY z#{0qdPRH#o09U^80r0!M{Da_i=br~xzHuS=nR~?TegS-r^M}BdZ+sa17hZl5_zWNa zN5FgbjN5$_T=~Ywz?E+-gWv7-d=Xsv#>c@oc=<1ZE8n;nT=~W?gDc;-1YG&XC%~0& zTnesy<5$3yZ+sG5`NpTfm2X@Iu6*NH!If`(8eI9tXTX(jtbi-u_%(3l8=nPNzVYke z$~P_tSHAHZ;L10C6I}Vm=fIV3Tmi0pyhBfH)fpc zbF1==S#aeWbKuH1=E1+_?H0hpV`}p`3jAN3m%xYEW`^=*@O_+Dz(ZUol&^v--&g}z zzOfFjd}9M#`Nrtvc>FbP$~UIKm2XUgE8my_SH3X|u6$z-T=~X4xblq!aOE3|;L10a zz?E+-gDc-y0aw1U3a)%(4P5!gI=J$U4RGZfqf^?)U-`xqxblr@aOE2_;L0~WpL#iE8xmER>75Ttbr@vSO-_Wu>r1pV{~f!_$%L- z0$08<4X%7+23+~ZEV%NGIdJ70^We%i7QmHnEP^ZFSOQnRu?((!V+CCK#wxh-jWuxP z8|&c8H#WePZ;U3kkH7MbDRAW*)8NWCX26wi%z`W5m;+b7F%PbMV*y)kV-&g}zzOfFjd}9M#`Nrt9_VHJ~F$J!CV;Wrf#tgXfjahKz8*|{w zH|D{WZ!CZ--&h1!zOe+Zd}A40`Nj&k@{Lt+SXq zZ%l(L-r`NkBu@{MV5}E8mz0SH7_Tu6$z=T=~Wlxblr< zaOE2-;L0~v!If{Ufh*rw2Uota0j_*wG^u_3m2XUeE8my~SH3X=u6$z_T=~Wvxbls8 zaOE2d;L0}^!If_;fh*rw23NkZ0`JsW7)Yr z?!7q<8pB28&`lU-?$Q7`Nk@^@{Oy&m2X@Pu6*MfaOE3o z;L10y1y{at9k}w1>%o<8tb;4xxB*=G#*N_0H@*R`d}9M#`NmD)$~V3Vu6*NWaOE4L zv*Ytc$B*)jz2M3>4gy!caWJ^@jVW;D8;61`-#83h`NrYk$~UILm2VsYKF5rxaQUH+fXfek6kLAjW8m^b%i!`uzX&cr^l@o-#`I6rNmoNEE@aMdq=fLGlt^k)W z`7LnylFx(7m;5%ke94vI@+H3mE?@EmaQTwo1(z>b1(z@RBDj3Xm%!yqeh*x}dYE?@G8;PNG30hcfNBXIeWYry48{uo@o#{9ADOlIy@fvK3!4HM#vcQ@-R-aQTwM zz~xJ(oy%X7FPQmoFKe+dlsCB~#$?CDY*YB{SgiC9~l2 zC3E2NCG+6&B@5v4C5zzlB}?G)CClLQB`e_aC9B}_C2QdFCF|hwB^%)KC8P7&$6vl= z3S7Qq8eG0)23)>m7F@n$4qU!u9$da;0bIUh5nR4x30%Hp8CT`H~HA`I6C;_VJf5nF5zDnFg0HnE{tCnFW_GnFE(EnFp6I zSpb(WSp=6aSpt_YSq7IcSpk8HF3Y{pkKHUor(QUos6Y zUorzOUos0WUor0*; zR>9><*1+XU*1_dVHo)aeM$_8IU%q4tT)t!)T)t!mT)t!$T)t!uT)t!;T)t!hT)t!x zT)t!pT)t!(T)t!lT)t!#T)t!tT)t!-T)t!jT)t#j?H8F2ZMS#bH1IdJ)sd2soX1#tP2MR56&CFk;$xT)yNYaQTvD zaQTvp!R1RX1(z?m3|zis1zf)5a&Y;QE5PMTt^}7aSp}Cbxe8pqT`H~yJG+f{*$XaTauB$D$-&_AB~#$?C5M8`mmCHzUvfCOe91Jpe94i{<-5t3%z(?69D{n~ zOO6GXFPR0GFF6iezT|jt`H~aB&CGP>3FL^Jx ze96y(%a<&H%a{BdxO~a`z~xKc4=!JF0l0k02f*b^J_s&f^7G*GB^QFrm;3^_e94Ev zv{kWpMeDUj&yg`8asbp7DJ9m%!yqE(Slx%YPYM zzT^^c`I1k7Z}57Sg3Fiu3b=g9C&A@QJ_Rmcav8XM$*+RTmwXyrzT`9D@+B+a@+H3p zE?@FlaQTv72bV9o99+KSH^AjfeiK~21|Pi@ zUox8B{v0S@vKL&w$IIn@rm#l-!mu!H`my9m93R~t&`Gd@s}@|0+%nD2A40H0hceC1(z?G1D7wE2bV8d0GBUW1eY&a z0+%mY2A3~c0hcdX1(z>b1D7vZ2bV9|0GBTr&1fHg`I0Gc`I2dH`H~rM`I1?1`I0$s z`I32X`H}^2`I1F&`I04Y`I2RD`H~fI`I1#|`I0qo`I2>T`H~HA`I6CP?c*n%GP=Bd{N+ogz~xJ(!R1S4z~xJ3!R1Tlz~xKk!R1R9z~xI8!R1Sqz~xJp!R1R< zz~xI;!R1TVz~xKU!R1Rfz~xIuSG146e908Je91Jpe8~*Be90`he90WRe91hxe8~d1 ze90oXe902He91Dne8~#9e90=fe90QPe91bve8~p5e95TLKK}A0Q{eI?)8O(YGvM+i zv*7Y2bKvqN^WgF&3*ho4i{SDlOW^V)%i!`QE8y}atKjk_YvA%F>)`Sw8{qOKqbu9T zU%q4tT)t!)T)t!mT)t!$T)t!uT)t!;T)t!hT)t!xT)t!pT)t!(T)t!lT)t!#T)t!t zT)t!-T)t!jT)t#0HTmUX#av`{U$wlDuCClLQB^QIsms|=iUve3^e8~#9e97hD z@+DV*%a>dUE?=?=E?;sLxO~ag;PNHcfXkPxfy)`SwH-O8R z+z2jT@(pnLk_~YAlAFNgOTGy%Uve|Je97qQ`25xJFJH13T)yNWaQTvh!R1S)z~xI0 zb1vUazGNC)zT`;MBVTe9xO~YBxO~ac;PNHMfXkO03oc(W3oc)B9JqYR@!;|$CxFYB z%sJQi$d{Z1E?+W_dgMz^1D7v(t8@C2w}H!-oC_{r@^*0fl6Qd1m%I~PzT`Y``I2{m z%a^ip-%8K;QBt; zFM`X*d>mXp=9j?bV=e}lkNIVA`It+<&E+6wbaQT=k zz~y6p3tT?t^WgF^zYQ)Qb0xTZ%rO^9SJaF;|1j$NV98Rzsdv*7YEbKvqZ z^WgF^3*hoGi{SDxOW;FnGn>97_&&}n;PNr6;PNqR;PNr+;PNpW;PNq}YvS?OxXH&% zfy>AIALP9Ye4JIa|2-B&kW0fwL~f?s1jIVe%nUP= zq(#(%fCT{~H=%L~2#CUgh=?3SjLJdea3o?y#9Q?Uf4rWGiin)!yVhQ7J(o4lT+*bi z?_oa5G~e0J+WXnhzO21}d+(=KanUh@ii?ifs<`Nw5yeHv>``2F%&g*~V{TAfbj&fu zMaLXhTy)F{#YM-QR9tk-DaA#{+@iSXm|GPW9WyZE&41A`YZMn9vsQ7@F@uVWj@hcX z=$H}3MaS$>Ty)H=;-X`2P+WA(F~vp499LX)%n8Ls$DCALbj&HmMaSHtxagQ$6&D>d zFzU^J(J^Zj7ag-!anUh@ii?ifs<`Nw5yeHv>``2F%&g*~V{TAfbj&fuMaLXhTy)F{ z#YM-QR9tk-DaA#{+@iSXm|GPW9W$`boByI?)+jDIX076)V+Iu$9kW$&(J>>6i;mf& zxagQ!#YM;5pt$ImV~UH8Ij*?qm=lVNjyb8g=$KQAi;lTPanUiiDlR%^V7)j0MaQgB zTy)G@#YM*qDlR%^tKy<#Midtvvqy2!F|&$`j=4c`(J{vq7aen4anUg+6c-(HQgP8S zrxX_*bBp4lV{TPkbj-l{-uxFGvqo{zF>4hU9W$u7=$NgFi;fvlTy)GH#YM-=DlR(a z2E|3k98+9$%yGp<$DB}Hbj(S`MaP^{Ty)GWii?i9RdLZV10V9{zv!4Xii?g}tGMWx zLB&PKY*k!z%!uNmWA-R6I%ZaJ(J?nDE;{Cz;-X`YD=s?bgyN!OPAV=s=9J>1V{TDg zbj+=ai;fw%z?=V~W7a4xI%cinqGJXX7ag-zanUg&ii?ifqqyjpS;a-i+@QGVm}82I zjybNl=$I3Vi;g*|xagQuii?i9MRCzFw<<0=X5ho#{1+XwMsd+GYZVtAGpM-en5~M7 zju}y0bj%*bMaRr4E;{B0#YM*)Q(Sb+am7W)oKReJ%t^&X$DC4Jbj&S^i;lTfanUgY zIB;{V3l$x+Msd+GYZVtAGpM-en5~M7ju}y0bj%*bMaRr4E;{B0#YM*)Q(Sb+apt1q zh>m%O;-X{Tt+?oz_bM(r=7i#+V?L<3=$H>HE;{C;ii?gpskrEvk1H-Z=97wxj`_6W zqGL`eE;{CB#YM+_UUAVef1$J|SC(J^Zj7aj8e#YM+FNO93I4^>=r%v!}o z$2>}L(J_xzTy)G66c-&csJQ5u&CEro6CJZvanUiCDm$WMb|@}7W<+t(F}oEP9dnK1 zqGO(=xagQYii?ifr?}{tgNloenNnPI%q(-sAJH+_DK0wZ24zQd%!?Hl9djddtz%xM zxagRdD=s?bClnVQ^9sd9$GlQ;(J`-5Ty)G&DlR(anBt;ieoArCF|Sr!bj)iM7aj9j z#YM-wPI1vOuUA}j%ug#WI_3?Ei;j7t;-X`2Qe1S*&nPZB=1q!=j(M}SIim4OQ(fNR_>dS#8`qF2@`E_!89anUPV6&JlSqPXal zJ&KE7nN?i$$_#D<%Hs*S57J} zdgYYjqE~KFT=dGVii=(u_?S2UMX#(;T=dFX#YL|SDlU3utKydk-AD{B-Ny|Pwu(JOg8B|>K%2vfiuZ$=zdS#E|qE}`W7rkqnk%qlK=5f zy>d!%(JQwoE_&rw#YL|ST<*<((JN~d7rnApanUP-ii=*^s<`Nt5yeHX>``3w$}Dpk z?~7hpP+auNb&88#d4b}hS8h;T^va7B7rk<$;-Xhxp}6RkV~UGjd9C82SKgqw=#@7q zE_&s-;-XjHp}6RkcPlP><-LlFUOAz-=#>vDE_&s|ii=+PsN$kmPAV>X<>QKrUiqZr zqE|kxxagHrii=*kS#i-TpI2P;%AY7MdgT_yMX&so;-Xi+thnfvzf)ZF%B_lvUioLm zMX!8KanUQ^P+auNz$d63koqNhodS$cXqF0`zxagIw%q4$BuUx9Q=#>#=NA${W#YL}N!(8i? zA5>iQ$}sN$kau2Woe$@PkhE_uG6^e^4d8Oi_OJ1e8=#rmQTy)7X z#YLC=l;WaGUah$3lGi9My5zNri!OPc;-X7luej)vpH^IS$r}_GUGhf7MVH*9xag9f zQCxJ%n-mva@@BxmBZ&zG&$-i!OPm;-X95 zrMT#lpHp0P$-5QbSV5PZ;_%`}i7vTWanU88S6p<-EzD&CJ!9C2JHHU9whj(Itb5i!Rx!xag7*#YLCwQCxJ% ztm2|eZctow$uY%6mmF7Ibjbva;xH^O9sZg`7gR;jpCw9)+#Q#WKeO@ zC0i92T{5D$=#o8(i!PZ}Ty)6|ii<8ernu;m``2F$*kg{OKwnHbjdNrMVA~` zTy)6^#YLB#R9tk)DaA#X+@iSXl3NuQT{3XBH~&SKtWjKa$y&ulmkcT{x@4>3qDw{; z7hSSPanU8Sii<9}L2=O~#}pS`a$IrIB_|XYU2;-!(Iux87hQ6T;-X7#Ra|t*z%}0d z7hSSOanU7f6&GDHsJQ5ot%{2-8Bttx$sWZ;m&__Iy5t7MMVA~?Ty)8C#YLB#P+WA$ zNySB%oKjqL$t{YDF1b~4(Io@ddh=g&$r{B)m#kG>bjhINqD!_aF1lnyanU7v6c=4G ztGMWr8x$8^a!hg2CC3#PU2;Nk(IqDp7hQ5nanU8WC@#9>R>eh^3|!~Uf6*mt6c=5x zR&miKgNlnT*{Znck`cv4m+VnobjhsZqDyX2Ty)7X#YLAKS6p<-3B^U1oK#$N$tlG} zm)xSb=#pC%7hN)Ny*K|wm#k4-bje!9MVAaJF1lo^;-X7Nn9F!ybjfbTMVDNoxag8+ zDK5HXkK&?B_9-s9C@#9>2E|2}yjXG3B{wQA zy5tp#i!M2)xagACDlWR@4T_5{d6VLzOO7ipy5t>-i!OP$;-X95tGMWr6N-y2`Jm#W zOFpc)=#q~rF1qBT;-X7FuDIxuPbx0Deh^d`;OAUGfdZMVAbGn%Wbo*P=`As<`NqyDKibLd8XwT%@?@l5L8ME*Vx_bjihvi!QlD zanU80DlWQYyW*lto~pR$lFJkqU9v-Q(IuBFF1lo=;-X8gP+WA$h~lD4u2fuf$yJJr zF4?8H=#t%vi!OPZ;-X8gR$O$+(-jw8a*g7mOMXys(IwANTy)7Z6&GFdEX75aJX>+m zCC^b@bjhgVqD%HDF1ln)anU7v6&GDHu6XbWn*Z-pTy)8V;+J#ye#O7Sd_Zy0B?lE3 zT{5Y-=#u9uF1qAe#YLA)DK5I?km90CrWF@mGNZWYl3B$?mpo5#(Is<=i!Pa0Ty)8T z;-X6qD=xa^h~lD4jw&v?wp_{IKGpOMXOg(Ir2s zxag7_6c=6cLd8Xwyhw4;B|oOP=#m#JF1q9;ii<9Jsp6tbeq3?UB{wR*KkT8~HSouO zn9X#q|6F7Ci60P{I(!!wrGNT`zYW6A3Cs;FzK+72%vZf=>>L^hba?Ij-S9&KlkHx< zD_oCu&iy1A=;5E28oT=k9_IA3`M{aL=gm1RP!pkm;V*bQt;sH) za(fmRwC^&HaQHJmN8x|U{Nh{v?`ze2-eT-*xQYTE!{Kj)@R&a*p6bn?N0`^v6PJ4Z z3iB)OCVn#8X&NUx&)!V@NamklzW6xe*lyzIYvUCDk)w#OHZ&0UALfUiMqKiz^)?E> z;dKfq?M56p=Fjub5x;p4`o56EAMpRkj+BSbaQNFFAl^EM!avU8pSzm)dcuKcpq^v? zY(9&)r01~D62FJjFX_nwmoRL?d|hYw+`um%Bs=fhg?{}K+j;#*#HGGG!+h7z6aO%M z1^)XEiub-l2{dygd*A6FZ(Rv~HgLakUMLa%-;mF#37qgMCxqkuI&jRNr(Ys2>Hh`u zx1LUX9*2+LMd4rLenI%Nz_Gq>TtFEk_5Bwdev;eg_pqJ!eU8FUHBxwP&H^U^_sjoY z;F!(_*HC&6XFHcO-}?mOa_zU6XSqF*`uhXsxs4QF%E{k=%e8FUd>wQ*rE^OYrL&nX z3mgR;(^GRa0eKct=0joPZ|CqgGGBZ+fm1k=e`BuOrR?YZ)AL#281LgykMSdEev$dq zVzS>zKL-x@0)>xoe<%5NCiBM^P|YE08-Apo zZe;$m%PG9X`v&vp|3Tr;rLVw#_ws$Qokh$~V*V>!&;_4&Gaq5TdW^W#-;Mvu_j?WT z6o=pEJ}0jjnXi+8V}4$*`oS#oi<-zzh%dU%*a1I;+oee=7J<)l_~)*t@bX;#!Mv5z zDfR0g_fx#ByHR+_x4kBaU%V^vLpk0PfQwCc`p@U^k3+kHpQZE_xWa^=8_@m!Z5;mi zKC&8-UBT9MpV01$}@N4jM3Vj6*1MX+Ps|3H4?VJGqHGbsU+nINB`WMj8 zfoDqC*=qRQK>8XAxRJvj^<~EGXIT5;XBy= z2=jA}Bz_F@&oKY-9mFHd*ZiA*de#ER^xV}&;eX8GZ(x4>!NjFK{F1RVH*oSf#2YyL zGaNp95b=*P|09QQ{33C7Ujn;6;-8*(1IP4a_n`2S|KBbVe$TJ^+i5Mqy9}QjIOT?(sDW|8xr( zxQN5Q2RQnZ>1zqBV;%;M{z>ae6z@UISFoKoK2CN?-L{9N%i`d-fbsk6zz$%F&v0>|gF`4hw?{kJfG ziTULm{+p8&zGim{e;D&00iOryd3k`+vp4hKaQK&ZrSJzcpYsi}vk+ECFEUSXaD>X;Xlpx55J8P zDCvB@MEHIFozio_bKdmS0{4qI#Nltb-D`iC`JkH5xt#fYRnBi`{uGa|TR1;|#eBy0>^s#$e#${dTacA+;IB0`@eUwos-`~cBCEH%=|(2V*4UXF82=e@@muca@LA?k-oC|r&O!=*8QX7sisJ28`FsiUsUJ{yDXWh#*W;sx z|M0)B3xVT(J-fzh=S$2FXdo{4^*ZyrIX}e@x$tSSQ{PVE-^=O0kNGQ~^4i(sKPmk2 zoy6sNtzdp4hZn!%?cb&FcX2+*{jLWt|K=#o*S#h9(`+Y_pm@bk`vvo>*b$KSf6r(9 z?XL!o`F7R+P^|Cd$Oo7Q*g=rAJypWaPdWU-Z08WR^S2V=TVb3dHaV#I+E{|$4;<6^ zQjqRfu6>62Z`z2@V`Ha$kHYW1iNGn$PhjT++aZzMi9a>$$(ah<|(+^Um7{h@E4B``I~%!(Y)y`6l6W z%>VZ$vLn}S29EyZl=3HEEMb4YA96XFAp0kCI#&V5a`@^s1jIkja`^AuLE$Cd`#Jo@ z8R8ex;|x5>;eWV-cq7|C_IZj|*SnK}qyJyCa2FFYOP2+f1DCkig!vj}J7@8@po@Rp zXzc787;B(}?8AH$hmUZ7x`z2benj`X>3ak&XMX$({_%bgIM%!UxZRU_F;OD?UrX>4 zeoS_BfA=BgdLA$E6aVzQ)9|^0%fCViZ=vi9d;mDsuZMYm<(_&-?)O}N$aeI6RQ9L-;V%V_>G?DJZxN37b0$3Kq%TlG5WnKl z5_Yz-oxScP1I=tF@H32eZeZ1y2|UL9oxm~P&`kt-nYT07^O+xGzKQ3-#1H%i^R{s^ z(7<*M{<;7Co>+q43fw%GJL!Jsvz=dUA%55Y5_p;UtIW0Ec-$}OxzERqtMJ*){5KG& z1CI7r9!B>6%={+i&+>eZw1;0|uG^pgV6Nvgf6Dw-7UaW3Kzh-!uP}^4r^gP4V8bnBo;be2DoN>k*QkCzwy%MhQ8V)AM`a z_`Ht2p1?-t^PoKW-ETK=yx(8GMDa?$oM!&Jjl?CNuP$NdISwDQ^9+u6lzHk9;?myU037?xTe!b_8;Acahkt_YgqTkP$LI3WwFD%ef5hS2 z{)c!yhyM+8J^nrW5B~Wu0vyX*x`xsz_2?SrdvH0IJp4%sJAW*}t^X$bW3N*J59f3) zX8s8t=ZgJHfMfn_;QZN>!(R(r!Z0#lce5QmuksS}!CUFRZ>Mu-*CRz^%Vz>`Mi+}zO+~O zFh9v6JNNN5`#^i@cfV%=M>}VIngU9>-B=?04>>6pMB9RA`PDZD(3J^n%Q z>T%Ffz-x^K?|)9_@HcRMKZ$?-D0AJPUJKl>oZQFZ_4?I41Gt{B`13yCm_Ktk{}1ON z*OmzXD2MN3zfr>fmkD3IPUeps{)TZfJjnLn^A?JCzndxF*sTog0^@c}&uecb{tgbG zVgBlE1SH-EnXh>_g`daae+Jy|enT){iS~6r8)1IT>14-ZJD+FX&GVCDe~S6_?7xYh z_7CQbA+jU={#7t8!gwz|oVc{}4*>T|=g$qF8z_8@!Y|?U><0OQc244XTFD1oPv+;( z{|ARZwwCN1#ddzfT(5WiJov$AU+Y=FWqu$Re2Mn}s3#cyaFw1<0QbAEuX6ZWUcdJX zN><=S=4Tv7Ksf5kX#cT&i03)H1>Dd6nH)awISMHG_B8X?;Q8REj`QL7%yYL8A7kG4 zc8XW~SL4h(xgC~#cnY{*dJft1EdiWIt>yWX-P!&b!12D`xSZmZaoHquy)O5Fz5MN; z2^{U{dA8va;U6%3ZeaIwDBcE6&od>$zX5z-)6&c_A-Ne2?726^dl|RGX|{7C^Yghr zN;&@$^UbGGypnH!XZ}LuoSeEq+`vE6ubGa0U-#~e6#Uy8Q@`dj=+ z|K82~@p+V<82uc`GoODi@h`HSJ@z9zdL8%)%xhkt@bY|HnRj;*7e8t}^QW#NF74`5 zz~vq}DduaR{VCpWaz6Ykr{^;8voSw!;c@8u`J&r_V?I3lN3wrCeFeV5;rCnSP0vdv zygNqv_dDM~_G@|GvX_H&GA|rKc4EwjnCtnvUo*de+lM9&{~}E6VEW$+{R4jFxxD3_ z#NT!+1(bGgG4nB1&I`;B<$Mr7?LOw4Ab$LGkh#F?%wOh=d71gH@1l5v?6(XsU(Eb5 zuD_DcXE6W5$z*?&!(R>D?>Rot;qTkzz27j@bIb=lAF`VHE2mNTX14!n;OHMt@qCo{ zZ?^&Wi}$C7!#er3WamV-^AF~aKSJOy+@K#0^FDrdPAtKDf#bNKR*ehN!12DcKm1q; zJ5we2?@I7i@MF;aUhq8e(@(b%xEHuz`hR5j+`!VaDg1>T{*4mh=N;y6rw%yAd-u&` zN9y%2nO`3y9%B1*z)!;P9|1oOKhj^!W3K!6tC?$Eeh&0QwZ?+?KZgVNyWi7*W4uR$ zKY|}Aw`-Xn@I~VD*xaX>Z{`AZ5%c?**W64%+JRpH_ltLL@X!2s9dJy~0UxJ$rC*3M z|JfD9rTr{GyNuyqIEA?Q71&-Qujl?n^7$BOk8u8N_XstRGXK^9+%G-35_}VIwBLL; z#oNvKaLAEV?;ckBM2-QD;dT3eB5-VnSO1di470=0!{J|oa)%$euQ9_pGS}BV9R4Ra zQFtjoZ##@cAnoU0Ieh3w;!>{m zIGWOv>L5EmW;^qlKLz)JpBVFY=2|a^GwJS(khsW8Qru*%$sI^B=>!2!0NvufSI3M~@SbavpjQ#XGT?>`3?y z;59z;JRby(`M>xt6khzXEZbSPiMaT^FLU@uzD4nlzLmcBK9=Hrg6BP?y?PJxk3fCG zkBq050mpdH0X+dfq8nxmC+7a|O>E}?m2a;D$91Z@U)T-CMOa@xynx~r|L0oZ`??MD zzrPIJ@45f31V89_vajds>VW&%Im7U|ft&u5A`DUU5m?W5YObVo!k^}I!F&DfJOUi= ztMMQTDE;gYn4h$axTN906Da)Ob|WtHRPSZ}=rzRUd3C>!!s~sS>zLoo_SbX19X+4I z_p=`*e$i^?=iWd8zs=zXnd^0NA7;M!ZIm9FN4fzx`XO6Srg@}R`Z@3g4*xRvcleQV z^$K%6?mp!Gl+JaH6kh6Ag!xu3w=JB`JaEZFM&|1h4u94yWJl`PpG|m}C)q-wWuNB$ z&`;y@I^#|XFVE{Ri?|-AoXuR%hd;nvuao>6^Sim-kalbr7$0K&O7q0w>FjqMX1M!~ z=-(#+$8;X?8T$Ja4$@U3{9SCn<{=8Wo^CI&xkUKA>dC&=kJ7;X^7-c_INm>|^L#D{ z+#Cl|%pc?SiktPoR_1!W*{)Cy(2gz-EzHxq(hW&_xCS`pr(O>;#Nl7LkHQx?-~P*l z=RaIudo)pb?g>+Q&T_sT47}DAPX2iuhtDd1;6&h<{-hN_PPFd+y)i z@CS20-p1+tCG!*cx!B{l7K(T3(-d!n!`GZhd=B{a_&Jxk#a!>pIPG8Pe!u$+1#IN- z>wx2Z?F#)KevW2-j|tCzxW4`q_`c9yjq|=;ndkfi+Zlf+*}0Cd={?CmAFczA@xJj{ z3NQKp)(;TZ>l}^)?w6lyIQ#>jrU>&K?^Vq8`t}2$;$XaYol5aaztF&ZufvGT^X&nS z?ekJD&j+#n^EkX7|9%MkY_$J&wl99&jm&pjLiQhKJ5$W{c=iKO|FL}Pbv_Z`X#b?W z$(|UL?IJtkmo8`{`;C_pKba#x zllhX*5tp>RD113_DTn_6j^%A!wTJtL$^P5bc;_VGV$*%UV}^rXa1PmD#y@_Z?abll zBIBn2WIn?7n>qaNOW5CkvA>@g1djQPdJBFe-X5 zLHoKNuVen|TPVDYzaqdfKi8;ze`f&4@~n09wQT3nUCEA=w<}F}PK4|0-V*#PY1M981J`ven7(iEAxxKK;gyj-3b0MhS%#erW<=hXbte=)z~4-{VF+GB-(yvG5@c(Yef_#sZ`aS_Tlz5Zko^IfMX zU?Yd`0giV5{7JGS?ayT^i5D&EpYO3h zCobo-)IvLg{DK&9sdtNjV>LcW z(=Yx>5A)A+y%YcT3Fa4s$j)!s{z=`G{?}h1F86ho;T*{Ibs=!m{&2qr?xp#R0mpPc ztJ=2*nBRI61(ftOokrpH`rf;l=XhKu&+@ zf6>8Y-}dXk&%^RC@d58V!!f}9;!OhgE6;Z`*ZZK40lx~v?*;7*ek6Y`1&;OZ(XSDg z@x|>NUhBCJn(&-iuCKpyc%7enpGEPe*`JB=HSb~m5$J#LW7kLEe)k*W@Mi_R>AbN- z_^)vIGp?iX?HunfnCGA$z|SV;dz?+_tp7OiW0}7TIOfkUIe)%M-ASN{!+-523NQJY zW?d$c2e`J0LlwbS|v#m&!pYJUM#1FZI`FFYA$@9GpxZm@AiNil}1KGcd z?c;dHFZ}huF&|F6io&1D;je@K!!P`V;d29%a3A=Q=kgukXy-ZhLq5QEj_xI{&$~E> zxt?cU$Nbp&WM9?~+{OGA?q8%odW`uI>=(`Fc#iNBK{ug`^vw=SUe0~>jO#kis zQH0W8e1Q3;Lx{`xWes!GweTbD{1|Zb-(EYDD%{@YSJ>mo;qN|@!p~#=P3FC<*NFeH znfY%xJu?6KJLU^tAUoop1i)Xx^l#csT>8O-nO}Y&ap|XqfcurV&vJOZzVu!FWdG;) zksZ1Abmsbeo=-Br;P(`MgzxtY%=I}=lfcC$2Q^>MiG7}rmHdB+d7R5zA76Ct0Hsr( zBljcVSgr~gN{{$^zvb}t?rNp5JHg=(m`CB;m|s*P{GA+r z!)+8$p5ueS{qo`earl?sLH1?7&Pq}`Pv>^{G>-Qn<`=h7_+M5S-X4MW z52Ew@eqC_4GmDf<=eAa z^N;t>CHQeUinopPS=znd1IPCHZXRDl&tyJtaQNDNDc%d|D{yF@o}*r`wFo%gmp&IF z%6vZ8Qz<_inP2@$GA!-$6$P?$#X{nL<#_+d{4s8qq&?YVn8J6neQB@W$NWbc(pEh0CT;c{b=S#98D4ag5&K3?iX*C!#{O6 z1(f@}+Jpyx@*27!@hiT_;rHSBc_}APF~9j%vLkUFI7-iP*WVH!Wq-KQaLz2(*GGWk z^L_0)3jb67?V5GOZ{Ll$v`gd6YmXx?+@~)JfH2%qww?Ceh|2%*_E8Y3J#zB z6or@er{$9Rl18_e(6Tq?jKdj3C*Gq)|A=`g&71=+T?eBMizx@W_m~Ur+ zpMoFBpGC}%IEA?A2qPuze9CZGUj+R#et5bwFu`^nXMbst`85!Dp@g0NKTPR4X}&l8 z?aU7k6PI@QN#-ZqNnHHfy+2CjXX-kNP|D#6!0~=B7^Co9Oamuwpzwo#BK{C;C}X}*uGvz`t(H<@7*_0I;Ea=evG)@Z`I3O_jivl*ZXI`&HR2< z-#1@O_O)OA5^%rtzvB{rz8E;>+f~Xx`5tq9-t~dtFJkzbtLc8FogW157w<#~{w&)$ zi|4Q8`7Zi6+1L95hL}Hp8$ET&=kGCJx0uo+?Ze-gKemMUy= zcaXVmmo5U1_odGfy^h1{^*pyiyNU6h{8>uBw4V<_Kj)YJp8?14e>joCU&J@}H|Dy& zoD203!>75O6q~;Xj_K68^Dfs=c)h-;4>5*}6pevp$So1T1 zXf)QFj22=80RZ{JaDV^&c%UzlOAI9Qg+wk|7>dSInRFr#A^S4XfmEh9mWuWjGP!&- zHoPtn&kSW#i9(`pe$YQev_F|nMq{~LY<)D5F67n+`g5_NM6_>sXlOlL;`%EJAq$?M zLz#F!icus}u|hJFo*&O<1JN@&TUHh#x#UQ!km#_2ZHa6y5r=>Gh4Hu0%0h=#cUl^a zC1a`N`NTUy&F2-OLy1BxnlI#%>4Cl&{BsE;WqGDAk%B8bLLmuJ{9E&?B@3g=7j!Md zD6EE+i!!N9Zc!$kFT~P?d`F}CJ7^M6>Q}48uMG=RvH03jKb}6AEF?<&*xVM&tz7~+ zTjKZnGQYKSBnJiyWdhW#;tVampN1v5L?T@((uJwvQVFhKv_4kqx~Ao^0Vp7`5@s7e zm`J5Eqa}WA!kj3b;1v*EKWJa4nRtSn_^1R{1Xz3zk0@laQ8!nOUWGILMhGI}_N<3H-tRZ&( zaIS2C-b8YsT!6;jWFFF6=EfU(OV<@jYdwTW#|IOAvD8o|O-({k38vewlz%}CFp|tb z`&Kqdxy)#ZLT%z{=^f6c){kZ~^^$;T64|Oh)tB|f{44F@+N;G077nC0hq$qPY+1Po<<_ zmoum)s5+zz{$I#lr*xF>dr($7rL*<%E zW6Y|@aG6wcBmvQuYOE<}&;*5sr)=f4I9PlzS*{>Ap|M=4uEP~!-c-O0OO|qG=;2$?q(IA4sZ+A7{!A{BFI0N? zP5s01!F;k@|J5=OOQ!R^nOvq^X$uYvX7Ytf$*RX@ql}rBYMPb$3Xi0r(oI{I39-J6 zOJp(|A}ae}n+L(QU*DG~;Z_+NO@o<2h0@rPO!p;Y>GHL{5d#gBdjt*1kxZ^!3)xVq zb!<+>MiOZlzLa@FR-FWbx|1I)6S5^08%YK?{g>EiHw(J5~v9yrY3T2a1SSee?R@vf5fhrU(%Q9I~xx1*Na8>jdAqrWs^|b0K zAoeVkvc(g$>|Kl1LL!l>R2=BuD?T}he5jnW2N^w7(GO@yfq!4lKWnP&b~M5$Ayc** zSdBx8zU1&wRYM9ZNP#P5Q;33Pauu8tivwndb1-XBrs`YuWU(6Wqk)4~<9{@9*euRK zRH{Q3TdvBt;IQOfly8Y47m|JHDq5qKp=7!c&n03*WwHtaOs*huW$OvNr3f|ctfnxKbXF?e{{vgu32;)7Y3W-Jq^KAXr5 zm;JrGb6lTI4VNpiRxq0x1t+0GtI}Apm8dKKU|XP4tnaNfJCMt)k5%pm^0B_Y6gb!A zry3e7_maVUEZtWzRn1j2d>AG_2rg)uN7a~5CerD0&N+lgjg)oRnko--TB;fRQJ@O_ zxCAQOgV*QNrDh^|jFYdbfp38+_KH409n3J7$>I7!qUB?CN0lut5IoU+SDllkZ{Opy(w6MgOHhRySw&Lu=0IeDtgAMK%Sr_=GF&R4|DC%+ zcNOX&3_MB9lVm(uNUewb?2iqn3LsK}6eJlN9cedy!*nj74$D<0ik?vSH$B`qc@b6eXGVacnflO+*IMssvkZxm*{6VWutbkW`zxtY^41C_He zKA6j-Gc5%e2Sv|^NsoqTJ3K^FxTa$ZQdBRG98^OPKHJM#$9g^;^QLW_&IJ*uN~lPd zD>w8b%%(vjZv~@W;5?Zp+79)#%GxzO6S_2&yn1xz3Gg+c6A*z=I+y%wyHCI(W6;v9 zO2iA*nsf(;;uA702-M$X2AYYkLWB8ddq>I&!~cWwp(j%@eC1$uRzpK$OG5~)R}PJd z2sMUUn(7;?2rP*WI>y~4v0_J<;rbV%Ovz^xaiiE9tv{OS$GX)NjmFolvn(qFbw3$r z@xDC{Sz}?>3XMZ7S;#|S?uwZb-DO3o+HHf?QEhb;tzsEttM1z?YM_fdX=p_~Juda8 z6mELeoMvdtRrAO)pTg@Kzc(Z`3?V4y(6iAWg&24T;=@2!=2V`Ffs@k->~@4IT3$CD z%WmhVqUHYSSniun;KXzSPxG-rQEhTpiRef&G1~4^f~g|A8{sk!JF;wKI%#fOY=xSm zt}Dm|E~*-xP!I>w!=@@jjZR}{l(PMb_6Q`q9+o|%+ebTwtmgXq#-{rEU{hUFu%)5F zYP1^Q9^ALVvG|tmS&ph=>A@~|8WqID;oztjJ;CF5wNt3KKZj$T7_RRYI`@X?Kme~&XOrgeg6 z(oy&(b0!9L;>zY`ye$cx;`YeQl9q>Hg$FMV?y#)2UGYRZaeA_^FbEH@!wL~t3d;`% z3rJelb|+JbE?66ke>KCx&FreoD6DbjKVUVl`2$QXkF5)*6GKT{0S%_=*LG!LRluSQ zh)ggSZ&>r%)0048c>}IdUY1Pp#Vu>wX$^8D6dLP^=mQ1*L(7)!Nu&1azQ7z z6r}XDIG20!Efn`-u-VRrF=%Mdsj(L!KJ3>V(RYJ2)qYK#0W6{f{&KDagl zbLUQUb^LcW76<*?7!0jl1@)q^Dh7)JsER=pne=epP9r1<|6bAGpHG-@C^Ngoyz``4kSWPRJ z@?%oUCFzXLW%bxlHMQkpqfk}DtD09v zpf7^1j+*Z3lfS`NXeur7u8*Zk9FD?;k``zqEPi0H4lP(oJ!=dszQ-!hB+fG zeZVAD|8N>4Ca9f@M?4u4KD8*rx0u$nKZ|<6`$1r@tKY7CaO%%^dRApRXAz5APp;sU>`b^6zT-5Cg(2M)7Cz8rA!OA zmf|wh@_k#61%jp3{Gq9@H2>TTMObUj# zF`u0$1?~5aEgBHvjxHMzjx8M!;f^jH5akXl9e8`&UOHyynbPgz<|kO=X`F+iE*rYHCbQ5RwlmZG z0UWr|-rLa&3+!#VBpx3`>119#7=+?U9Plj-AZ#s_y6r z8Je|>-q{s`orj%PBj6Fwa+UB{oV7ZEj?eb06i$kFaIG-&Xfv!9kTJ7fFJ|Ut&Q9HA zziFpc3~SaahR5QpRSfj`wpYb)QoMsJhEaNFSTV5MS~bfZ24?oo?lIV9+-VgfH0u?^ zV{z6h2D-c3t714Q-oX_k#M4YOaikz)X1!v}WNhJ?O>_B$)w_i-y@-Ax_}>@8l=kd%1yO=gi8H@uOx| zkif)DN)lXNM%$R3qU5-`JFYCDH@Q;^6Gps~N|SLuW>%WO#7s&PT)y2)lj9%mxYC3! z*iI=;81YUjO{T}5S!n_jGbv4Q`F1Z&j#IVcN)!4mJEb&X#M@e$+)hf>K2Dj(XHV_T zZcmP`9FI~;xek@O^b#|M75zFjVYm$$R=zXdE;$BK?(8gsB*@TU8}h7tm$O~+45HlG zc?L?xYFC0w)|A$Y&-lgCy-EXnkG}rG} zf1zH)U;UMOC4co->gD{Eu5>Tif_`pW*7W;CL1K-)F5fMQ!j1v&!hWC2{Z&zKNt^j< zd7p^A>BfGBrbK*qB=}tKoAB9R=kF7}Z|;MQGK0g}&VKJI)9sc2-hA1P4*;w2OdkN)*ntng zyO48xJpgaMY{v(H4cts00NB`p55T)ta(g`hZ@!rQ1(g~Ex5o-ktkPO?A9H0|S{QXy z+G*fpP&Zh!zulnvNQ);5%j#iO?K$v?UFG5It`Dsuz8NfVm~n~mb`G;xWS~Eo#kIsf zx#(L^A=aHzXdqsk;USq=tsUK#?J7R^>n){tqd1$*+lIWl?Tk0ARE*x+rOjfofnIDU z6dQ5j*Q{0`kJ;IMe&}#+*9zpMeP>i4Sp!^hb$GQE2=ZzB zRG^u8{IlqWu+zG8E0D9|ZB{Fg$L#D@AauRAYXx%BzB4LN#qAZ1lW6GN2(e2=} zhOW}iD{C10ww5)$_P&a?l-;T_k97KL$*YK#U6t*+p1k^Gh|9gL`3F7WPRT%s_n#sM zAssW#!t!0%_A7%B?>|KrLON!eh2>l3?U#iR?>|KrLOLW1&900p>c83{QtcJaHj!$t zaQ2E+dqp(Rfp2*+dm_vpiKU6y$a?3`?$KnrYcP|6cN;hm4poy~lix6SvquRH3 zVCi$c^`jw*ukwIl9vqQwwMXDzaN_li$#^@x zr@TEGZs>yp&ili1YFRM4G?pJUF9L0MAI#2+0KsUvWq0PSBJf^F80$NmdEgRwV{*J; z3*-?|056@CrDQ4qno|-uwi|>e{y>FN~GFLFTx=a2Vc7i0hE@@WP2`?{IuA z9BJ2^7)YkWLlKi8$`JDw>UKC$j&>DchRW+-oN5+smJLgbtT0?1iq_*cCX@ZH41pM( zM41#9=vB6o8BV^NSIih(QZ=%7@2#YTs+ab|gL8m=}jO@d=W8u*m)z%O65$fP*Lb{n{PID3pwdc(X zg!-UVot`WV!ZFO|-94+8HJVpDFAm`Q#7uNhUF795k>t9eSQcL|(*o~@Nu=@hLr}q* zSFVobl5p~4>&im3VHWej$xJ+hr7cAF(XjGJib-~=ET>~QW-owhpzTOmCE7%p!Q5$T zKg||;cyOg<<>95=iN0tWdiJmrz%GM{^Pr?uU587TI6SMpvnvWMd(qp3&3T~Eo-Bq3 z3~wBcQ9~Y$#|rVm) zJcPp35EQ?@RAgkxRU+rNxTx}dJ9i**(d=y_uyWLKU=qEV=wKoR4sUx$GU##eTz-sk zwqVB|q^S-v2-?#UcWl)eXT!{Y4nq-BZdA+40wi<<(hkmlS1MB==f8cq)5|X&f!FkP zMeEJW`A&u6K7zMFu8PxL6t{epI}UUH8eC{6p}~~|d?|%^Fiv8u5R9Bg@jY@YVCOSc z7^_i_sJK<`bafwA9aOf(!-e5o!c;XUFRA&m9|m{}_%1~BULgg(wNG#5^{mn){|nv( zh>dDVR~_07@lK&Un6UnydTB?!R3W3r+$m7(3@bOCOLlu?8NA2>o+IbUJYN!-Y4yrlFMsZ?79(`;^Ce!iB1{ab-6QIC56~N-m9E$pIMcL1Cj~ z2O6;T&hz80w>?SodRi!q_7K+TCv7L(3Z0gPSA!(Tcj6}2?Gk(a0Cc|JbgeH=0?}YE zJOuY&{>(j}u~A(jO>9=Chf60$ZFYIYai-f#)oP0rLng3+5$gLITFL@Xlij z2@ond4iBP**nna4Ei*E(>TClzj<6aAVb}(#WDRmWuRoCl)L@S=OQ)0CrW+a+%4gZF-RK&*Lq z{8+-$iKJazT#ZQMf^0UmepLe6@w6Gkb-9H-qq^c4+S4r3dcj&bbt-WnW_5ivD(& zM*|*7I1I_+N(pW)_(Z{|DcMp{U6o~ZGBFyKdvr?G4joIZ%$>I;ab7&tSLp8uW~24k z&4%UAApZ^TK(gxH$D6?XRxeeCWxi7h%@DW%lMQ*u0D1m)0jlii;pMP0uz<~#GYE60 zn<`sq?86DwLF!;2^;WcdIGchqcVNz;y<;dCK2?U)cxy7Cff-YXl)T(<6EwqviC7=_ zh-SoyGeOgT8L_+O!Ke;fb{ZGOvRP=S+fN1KP|!y32wCtv8l%Q*#a*u!&Y%JY5GJd%Qs93p2IPGVRD31?T=v?FGg#&-4~U+ad`nH)~Q z_QA%)tjBpPy;Ie8#LWDunoor$OcITAwPsq_>F#*^9$M55nNz?I*7nMUMI77Wa$Fq4hJo5UADWpw%om$ThhZcYpersGnVYSujska>qXlogun zby|9>5obxjxrQ3jJKPU1V|B{6GbAc2Ntk8|kKATo8j9unojfDa%qE{IYg@- zUUZ)*EC;vK3~j>fZ2C=uTTS`lY&MfCuh9$f)YRIwe>Gab$l76jKwuksnE5ea4{IkkF_)dY1GOHw$Zik6h8?si|# zN`7`bv6ea5Ba=go*tDxwJNl-Hygf;TgFgF@5jC9@t~bgvJXw@ijl_ILXZ^~qM8Od< z?4C}gmdAP>ps6RS9qScO=R?!Df+pgy`Qp`q(HIoEX^n8gBN5Ncn|PkK_Ew@hs33fa zB5yUqAR0VVoHpsq6q5aLKK?RR=|QO<%=F2_fnR}Yn!R&bF$bp|cHyCOEo2|GqwhTa@p`bL_=4TDDlfnnyn z9VZfOx+IEXp;hnL#OXLAsuw+b4A~41zpJnwa>ULD)1pd;0uN3mbGji{v59GdtXvG^ zG04M)mG}?)O80}L`Fyi9Vw>k$$)_u^9s))}wr>yr#<0_#WUXSw1GFX3H-)i-T0~Q* zbwkN?`w&o=RfW?NNi~2%JhQ=EW1JRJcr@Gy_3ng#W}@oEnkeTKuG@ct60%Ovz< z3q}*hL+v2S4({f$ESttTt1sKcm#(jQ9zIAbXbF6x?Q=- zZRSQsZJ<2Q#++lyd#T8k`b8r zuoV{Lo|?|Wo@TSwdHrpteuQIP;AT zW9hZsIcOTqA{R`iGy88fwAJeJMdn?l!~*vSJYGn5E@29ZYqq4f>e&)}5YA+f zXGZY<>=H~I1NsiAVI?UJs29^%8vfPd8BlXa3H}T|>h3Q0YAI95oSNO(o^QjMYEveh z3G?PrP)nBJ^Y;`MHk@2X9jLh6&BjfP4~wwtH#dS_CigEed5x)1oeU^PnXGhCjw@<( z#kO2*piO?ZdnuO>x&!C0ZFjk0CHmWa3v#*GdaRr61=u#^OeezdJh;;S(PX>-!<1=h z$6G7wpoJS;-lNoFelS+OStJ6ZlYAkkR*66}I8l#QKg1G9NJCrneSd<T+_aPd?upEt|JsOfjDE5fJ2OBK+PxOR5Q5*f~|nuuzLUO8-9Kod?Q&dZ6zj@GGX zZLCIGukS3(mtmM$kvD)Vj-s(%m^@VJoZcg`tN~c4O==WR?5cWZ)%9nfs;(G@-ohyC z(7`N5;&lO?CW7ZgyW5Mh36iGNu}Z3kOBtidt!0iQiL;oV=Ek0cfoEizAy=CrKl0^&m|H# z2!mCxcG2{y6{Y%ZNU?-=l>sx*au(#n-FYe!+@v$s3`WZj1gF__u?&b)xT|oS>7(wT zGDun7P(azWy|UU04`>A_o^;il(MiCyU*HkIQWRMFrTqdZ)@7FgIexI^yCwsgM^pFQ zotd|r>xvEyl`Ecp{S{5+o0S3ig8e!htZLrESiGhO$_{B^Zl{KusF~N$>UDOR5`_Gn zjXfURG`L*jRb`b#7;V@};*Pv+NT+9cfvaJ`2}7$9e2)V3^UD+IVeVh*93hp~`Kb_g z*@3JC7azP)nnlF57P8dBv>Z<7Aq#l5)ZlK`M7@X3y3Ae*y$8v!O`1i;85ig|E~1$; zgN0HoIhSgz^{g2A>h=bL*^q)8Aze6k$K9-_lY~W=vG($vBuWpwxC7c^?%CZP2`~AM zLuWRNQ^dSQZkwirO^Jf43oCVSZycr!mg|U9;$*JRioR*A8!Wv}kCsbO)2c+3(sHg{ zRjklTTtJtEEgZ0_68qC+BocRdpBB`kRAJEU;*qAR@^Tg)G3udN$TD+?ZJFWTRALdt zx>m+%YH_B|RH8GxBr_bd)M8p#m(bbm&N|abrU2tE0vb%LSre_J*;|MdUf~TBAh5@i zN?;P*5aY({Hmn{dtOmmFHK@+Grp$13nYIIMAuJpLO%k`%kz%{7i$t3y{F7$w;rXF{ zB%=YG0`eO_H^4R`PqT9=INV;^ zNK4mf2<13zrJH?$^${ckwS ziV_yDNCuq=yk5|}U^oamlsf_bE@l>{m@t(8>uKpXpKP!T8BC@X?NV{a>YA+Ztm6`! zlqyd}E$%1(4@jxdBe|ti+@|bQ3m@?|p5iiy;|$q}FAcPlsnV5soPTa3boCF84kmCq z+DvljZ3L&=zuA4N_Yt`i5B7beNh_M!36iWxExbyFZQZ@1ODvg+F!TN4rFue|w;#^I za%g+v-ce=j_3)_eY!Du3v%j9rNjG5+iJQK=%Eb63=K?~z{-l(y1>du>ER~rmK?87I_u@O69Pq9jZgW)h+Z_<+iE@%L>_8<4UzBO@L^v%y z3a$`LD(8oX60J)XErO8)olj$zi%_sD8yihyJx{{6$No+@b3jfV=yLifR~unFl?`!N zJi)_j>1RZxvqV})q0XqJX4HmePz{zfS!U$nS#Y;VY}mjN3~;i zQ^3Q7xT;_N3z=h%!7xpqo!nyovUvc!c+jp{xOR8_5G73ph8kBc=mi-m7BATOh2tgc zlS{3ClvUT_Q#f9IBXugu8+4A4Y2qmyv&RTmGNJrOTO+Bto~|qcSzx?U*JSK8mI})a zK<>|US%sR}g?&VLLn8b%B*>Z4LnvKJ%_cz1dYId?9S)eFP)$u_8F*!8MdFGqPGiWE z!z)3Pqhnp{f&q8;rdt32^Ha3k!^{*yDS_?<4p5+cFw8l6iGK2tRA8vI0!B?{rjun? zQ{`wajZ-= z*2f%J)CPO6Q!%eB8gV>Lmmpp&op@&zQHMW+4id5#n|JDpYnAhS?3!q%j^1o*am-Y) zIoO1j=Hb~Rrg6lPt$lQxs{p}>7F;#(J84eY*@`WlR`+WEsRUOAfk6c7zc4!u3p#9> z%$@^t4V&Pi{^7Jal%aj`h&spu=eo^&H`WL8q48J=Za~Cgrmo8wY5ZSV*4+ZbIrD&E zot-%%iCs){`)1-FPC|+gCfZFFnPyU23s+66aQ=#``NZza3OaL-AY!R0M`$;9j7ui% zp>rR+oozA9Xu7wvxyl?g!_Ju_+j?{g6*6a8y1R~mAh$!7^P3t=4<3$^YR72tj4U{5 zhz`o4u98ZDIa;b6meDz7z<>WIPTklIVP!$ZvdkvU75!!z2hTi~uBp%)K$}4g1{9Ln z5SC@GNhYz#({!zGt!AACW?eOlTbn%-BqgSRF&E(G;FvEwIWdYW@}sd3)IOA!s}?1A zA~+1QzBsst85){%!p=#rN4W-D!nh|*{ZFETfd=h?iuSH8gooU7OY^N}Y|$&1QCYhNC68v%?bUCt zM$PLJf~sPdQ)l2S9UHiKdH__-sR>Z{X%J-38a55^h7QC1bulZH%&+Lp$A{spfQ4`l zr&i(QQFM!UikVX6_f%B|#8lA^M|obA^ST+Qi*U4vJ1DT3#ebXn5VGK9qNbmRlQW|U zY>;5c+h^{)D7n=w;j_ytd0k&AuT!0=FOU+RxaGgwd0c5j-Zxe)dJhYMQ$_VQR1g)*qxT znAXoh<;R`tMP-NvT-6q#?k>kq#s}WGa$#;5Y6&zAcCsN?roDy}yB2Erm$`KDSwBNT zDh}PWUbkZgdMfpO(^*{89#U7EGih*)ff7C6p=&(r8jX}W=M8#NXE-Z&z*XN}!QeP4 zdkW02GWvMPQrTr)jV|ooy)P2C=LfZQ59HIM@sY>~o>B>F zdKRV};whNojHjRzGFy(p_lrP70@E?zXW^rVhcO$zsqtQ%ja+Ei<#L#DRD)T04*$^4K7-TSJ6-WbflBw?!@Z-k>- zCZjZ}+}>?*FkE-$%Xnx;Ll$$~R=9W{oV$VBZVP{0tJfgaZ@PI|sQG%GHCGFF&or&J z9T&0Vz|Xh}S@33~BgtF=-Uy(!gTQ(^I?SLhmKzAKOC}puV)twJj?#!q7lgA_^wuo3 zABYlcw^iOr^xW_ALB6-vMnHnBJ^#*MF) zljQKUI&+vD-mf_;1a22sg%}^K&wGYMCzMvpf+Hms#j*cqPEat2IBi6U=> z%nCsJ@beOFQAO3%X^ZM<+B?a6mS-^GZNw|3m^rh2(Y`z!(hW!Iq!Lu-ySyhC@r;Cw zo=WfGbJk9>hGDcZ!57TK5JO=%rk$s^8*UZhyL0JA!Ky9I8KxhtorIGR6LkCG+6u*s(!49I%sNwe zbAaRTx||gnFnS(c(I6+plvvx2S zY;P)Hzb7`l4n65+e#4kP?xNIMOPG9uZD>{$Tt5g>^dRYNnB>jT30JrQ!E`c4^u;lD zSz*B}1K}4{*}{S<w6BHMb zH)ty57k4~3?{->bpJ9sUAGu%uQ}o`8u*D}(+habFL}1Sn=7PPZZ3e9gt0C^XReEGu z;YD1Q8eM8RqRGe+-lGt!5G2&2bDX3i2OoTIc!A17n3aRm*I-+vYXLR(@wiWGu{;)+ z;%!;brQ^B@qk5b3FZq0DFcW7;H;~DEfZU6UjZjy!prNTa1bOO%>}*>Y?gMd z&M}^w%R|EBmEZ*p@cLEz0ZwNVC%);-H5J-uwsXSUv9VIYNR*fKv_(ngl7=`!?w;EL zf`qCAh^kp=;yy=$&W(}h;~J@ZwrDz{v^@$c;ZJYl3GlWb&pnt|7_HtH#etfcdZIOC zKKJE)XRS;?!2FGw!hr+Zd*gTvD!eugU-@dE$yI0iS!ePIrwj2lDRf9+#2FcPF5^Lr z-_Ggc=T+&zC~)cIKncu+>CR)ZzvC)wRlD_Off;WzM&Ayb@9BCw=$WHDjT<6Y##3-o zM;EQ}!Nb{-FmnRUO*d^%lVgv{EDkhsvw5&4AEV9;L?x9l0+Fyht(V(~q~MxI3*zcf znm}U@yQ= zcXs+khFlQb6NSoYXZlQBlS0q*#gw)HD`9uzZnOQG;ZkMAV%y4{MT2X-aPMM-m z+>FE6$bJ_P9N7uA(QlfdiOyn=z@E}X&g?KX+fSj|!-(FQa5ZZ(Jrk`^{@|Er_x=(p z-1bA1TJz5)1wu`N7KPMQAD={uh8fE~=QnEwP@i=%`1JCcB-^!*jX@GZ|c%0A9oTdYnQEJ7ZM5(w^gV&9dqfpq-6{W*sy*h2}+) zcF+F*m3J+_k)>C?NCE^RAPA&HB#Jr`LLG@%zHZxXgA~y{uI{es>2BL)WkzCgr(9LG zYufdgsUNee=`Z22MyT zX}V0mSOGI&sFYz6BDMlyrPupRU02C!s%$A%E_E`5wtY#`YZ7->&%`Y2FkM{aX>$^~ zr~W*5@d$7G0gsDDCpA5SyqoEK{!{$yU!UKZ|vCKZ@D=*^IlEHEXCz^Cbtr*mGs z0+*9)@8OTQRp;+JB^Ae|aPF?M2eLYxKt?&KF{?(fMEW&O@9mhGPqr{_2wCBC3;ox9rxDV!VS3F_#Lc%!Uits zlwMQ?(?LyZW_W8WJel?QRZ|N$$>C#Ssh~#fk~Gy(+3==1`>CJUSJOsFOH{#RBYuh6 zVY;Wyk&w(Ri<=)mgZDA?Y-&h<`GMwl-ZWk*kIc0lZs<{^%!JA^BAy;A% zU0!D~E-C;gnUNLYmU3k3?B>84fyQBc)JNXzMVs(Og^IW4m6;biM=UV#2tAPfg)lRs z3*3YK^6Gtw3B&`i8Vdl}QgAs}euSF<_E;;si0jCyZmNA8? zm4h%fu#BNCjDszd$z982M2RE?S%$r-2d`oco+i*2p+W_`_n;uZ zm(z}D5)^Z|e%>ET9w9Pm+rs;s7JuJ=+5rPncHol>on*~C8?-CVNa;=JzD|!mfmF2I za@Pn;W4Wyc(&QNmYPV5V8$9S$6ziqDu1GJqRojob@r`0aYhHi{ke(r`G@xXnHjk&c zsAy%xAo-`>3@!t`MTEsc?iD6j%=HlU%F;rzTEY#H?Hn9p&GfsE+f1q4A8v1MpPu)R z8>o|DgHCCXNEf}lVtWVH{Ast}Q%oRjnn=nEC|9W`y=TvxNI{kMAZK+0u@s}hDb(ZX zc6HGPw>L@RyEr0e4)x1hoktN@cxWZxUZ_tim9TPV+pr~lBVtX6?d&m+9W&5+o7g6? z3S(Eh2YOhgb z6JpQKxG;|^<1U=R77AO}^R{ni-s>|01O>%44#xQw&E?>}+l9irGTE2g*tS4PPrI=9 zmz7F_r*JC+8O0u57^Dc72T^t^XvKSgln99e?rR&n@|d@pIaCNaL!er=Re?v?giwhl zLDpXasc=K#_SqMM5j-go;|Jb@qz>ac-d2JOQj+9{duYKeg}gAAXO*EfQR=s!Y7D1z zCwRL(wT#s%Oxxyrozt_iZmX+_L!>@0!p=&15hrRQF{u{|!pAiJvpnvLq}{!Fa9=({ z1WQ5E>q~x=L8qJ`vvY#A!{FLkk+GHBda^RoE%XFLuq!4fl><;yj(TW5asvu!k(Ab4 zk4pr%_9;Y{ps`h(3UQ;6V-6FR$Gtvo^l9FNHU?zD#_ z>zw|aIO2eYWGmKhW+Z2A^AjmaD#$|IE$Q=~j8m`PB7xz{gOgzc*^_V<7to{RP0laL+pL4JnLkn% zeokmq>m{J%jBLCDcI+C?Fv&8V#_a;orQ`RM_^$`zRzIS^28m1bWLkDCnU?9k=CK-> z7^Njk2Shj=WH2sP@P%hRgBEt`?Xd?dPFybG1G#4pEctNh7Kj^nnXsR8AiO0EDY8om z=xiXQ;KyK&?aCB;zwiCVw*^De1f*#Nj~JOpw7J-76Fi=IMag=+_q2V5qAR?&?p<`d zSL|aipgnlW*gj?cJ$1ka+ZM5PS_VAJ!K0e778!RQ2}s!*LyyT8WDYs)-s$(xTYZ$* z!VLp|qjCf#{zgr1-5ibkFq2KyB+o@$Kr4K|MHQ355bmX^F4`LzDt8e=j6qCmx6M*q zsNfRuxiIuyIl<{Ql`9ZcxJ}MSdQuyMpwn4bh%!}a+gr6zGMVsVo4>VOesuGF!q%J) zkpj)ODp=cV$DIF&u?hq}4aod@$TT^=70B^V1x*W*$e+P)2rMMJh%!5f3OVE1DHOJh z6%T8#uwOQCdM{E0O$Fl|#zLH24cjwPMCKu4iU5O=yFFV+$dcUosAm=hHa%BQ(R244 z!GWxlv}alOdkD*;FxN!e9zjt^oVX-dVD!$8b8ETmdywXjF2>-m<*hVEfR<_rw?RQg z!uP1IurrdKW$HkxPIO0J|Xvf@EaP2EPI<^q!$K5B-ICpCRwCIX(t=)ZUO^~RW3 zrA%tH5Wuh?a0N(z3Rl$#0O%2m0B2Duzr!C$VHJ#^up)LSh|PX<+Z1$To`HbJ1t!tN zZPGTwd++J%*Ex`kqdsA8$5;8~db0VFNL#f%CR|8$ zF7)KMvXhYWP_z(T<6o{(=SPl zBuc3WjU*nca)fx~We}mm8W-%@#iopS7eJ1|FA_xgLz^&fshFK>C3V!1x7p) zuU4P=9q-X4#6T4SHUOW5+AzX%5uU{yW&4t(K$2)%;4MVxg_AMsxcZ3u^hwUDbBcM9 zRS%$vrfe;f_vJ3aR=iF)3~B+ZF(U^9RIR=+0dnKDR;cX{s;xN~n&l0I;(qefo}3jO zOluM4p@(&0!^WOg1GD#(@ktV0WKUE^GLCtuYsXr7VdksUh8{YbYY8L^_@_j*c8-tW zinyUghf;_a5;n;v#7g>x$2>7~d~et|-LtRFYvitPqcVi&{<5t#xFD6Ep_Fe>lHJ46 zd98&-v*xbIzQ`7f?3HMX4TX|e(}GrPAA`$YlaNr#2l0#>Dzw2~4OL;V7Os_vLIjAU zv6N*!1-U2)+&c(Swtj?CXnT!r15%8Q9X}GLP^E&8vM*2H19%And4U;V)7X0`Z5GSi z54C^&#%0G@JXkOxo}&SE>}aE?`fOplrvHi6vI==dbmD@9;2|K_C3qXjtFYOA-EMlH zCwYR1o-4_kENKX#&)NW2_RyPRw>XiWTc!Fo2x#n2A zEOm#axns1vSI%u4vx&ks zj@g;0&8qN1N}EM=giQ!f=mdaxvUczw2iYpiFwfqx9Fg?oq;srm=+8n)$g(6#8?X)x z%m)soml@={`GejSGa4{doco45{OH?QMkF_0H;y}(8KwdfWAo;D1ARxnRm7xE`qf01 z*qsBV$TmBwcFasfSrM`9hEqdJwq{FJh+Rn3eQ{iKEdqY&uCVN4c8`mhD@8X|*t z78ZJbIXI0V9J#yLjo-;Jr$p>8=kG-&)8yp6l8j3jvETo+OCw8^pXX&?;DJ_n|I9{3~Hc?t!%k3%Ppr(F&L%w0|u8W(sj zX6rbDo5)Nj!XZ{cg8carl`9jy(0}SyE<9e3kbB88()Nc==h#hj|GUb=T&uefh_phc zJPM{k(Z^2Diy?}!*fK!Q?NQDVO_F>OOgD-9*%s~r05dTJ7(5zZ5yA*_g64-E-)}_- ziv;FLSFXqred3GbQ4=_j)diA=SO>gXfJ$>NtfJrVSMC ziI5?VECn%XsE|9HagMGa_#)oRc+zW*LgkQcIh4%PHoGgqB0`@-aoST_UjDAdUvi84 z!BYwe7TfZ)%dl^=TBY3yHDy@TW!~FQ>N0ufu}a9IoM=!a3LsA3PYqPq^5V0zIs56r z-ciS}Pnbb=B(2C}$07+64>X36@oZ|TT9$=86;(UAJN-;4FwbMf6|#D^CegkbA=DFR97y509+cVRM_>D*Y}D2rv8ZH z&wEnw2VF7^zF!I#cD^C=wwkvlgS(|hJe#nBgJ|z+PUwQSfbE}D4yW}CSbZ~%JG-ao zqv!oG5VR1QiYWrA%~`)?YM81p&Ro{v*kUHjzyS*O5mI$IsfM|1 zN}TR4J{X*B@Ky@s6DR5fF?|Mx6qcxqMOSBK^2Wja$bJz>{e6H|UOm3(1#;K6BKloE zm#>)0Wj^1`E5=6s15M7;{Y+Gk=SZd~#zLU>(~k0%+<{atkiE;UT;M9oI~bq=X&c$B zlid>XRcY+I{sJ}vyYIXzRHk~AnLwX@$~4Ybf&>V8(`MF|i*AK+sD^wp_R8HcAI6jU+cx?;HF_@}_FGr%g6C_O zr5Mvp5AwxRLNI2$o^2AF@C%|RZLel zo)&R$!qGo>;ynlW{7+xKVaM{U=P)2%HHIzLVJ!IU7nya>1lsY9W2!a`j~oY@efT(n zbMG{e*GTYhPeMV2g&m+=Y}JLfCsv?OUU@rQ2Ya#H^tT5rjp3MJ=NPviU!b1|PgpMO zkk%sXr79cC=&lxAE?^CE5t)L;e9fZLiQK#2Xk9jXO+aOBETaCuRVm=zCE__s0V?QE zXdMP@MYk@N3`C;*8tIZ{26KXUWy50*oaj18flc`r`v6A52B4>baRH+NAJN`+R4b2) zxPcKoDfy-yQjF%BdETReD=eIA7nmxLeHCWnJ!n7ss8^eD%sNWV_O&adAPQNy_<2+!R~zn^J$v76K&f84soLIV?j-lcbp_h zOXk6Rs7wl+k$YX?WZo;ZivU~wYY{o)#C$BI9JliXq0>qILK}B zy8}YdvvvnKf|FG`VVi*6jSFK~&lugoP85XZO2XC;CdaM$tCD01Y-l@xgjsICViYFx?Pi-cGn( zHCg9*Fp`tAJa0UMk4S4IEE(Zu zdlzd1q=16S`Kq$!K03ZY8K`e|T9q{p*A6OtA_;=ZTI;HZi^_34ly6X#WQ1hA=uM9A zKv&kF2Ks7nKBg-o^SmRs3tx*a_&?##ce z(e2=ouDrMVTYLNc zf2r*s%4wCm7xKc6KlpXup2jk5{~dfrk4VqPe{bR=&Cl>Joj-qtFT?hC-pJW@T&Kwy z{C!bh+wpJkK5W1L7jl9f?L51Ly|?4vCG9`d_IA88GS_2Y5$);l>6H8bKSUodjJ1Q+W+`#A^_~Tsq@#alHUJ+ z@C6OA+!gct8`9p6cdVfv)ApaiaE0yfYI{2lX0-nz+W#ibk-JtZ``hx$j_L2U_jdd$ z+W%J2{sV1qM?23R!`|ERF52TicmEHyy*sM>wDx!Gg&w!inAW~M|Bq_&%8q}c9c%Kz z?rZbvZ_zfqf8{;Bk{|Bl^BzK!2iD!)CU{m#G2h#e*klDC!r2R6NWp8x;= diff --git a/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d index 3f07975..969f5d7 100644 --- a/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d +++ b/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp.d @@ -1,7 +1,10 @@ /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp: /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ /usr/include/asm-generic/bitsperlong.h \ /usr/include/asm-generic/errno-base.h \ /usr/include/asm-generic/errno.h \ @@ -333,6 +336,7 @@ /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ diff --git a/cmake-build-debug/TanksGame_autogen/deps b/cmake-build-debug/TanksGame_autogen/deps index da1914d..90ed6ce 100644 --- a/cmake-build-debug/TanksGame_autogen/deps +++ b/cmake-build-debug/TanksGame_autogen/deps @@ -3,9 +3,12 @@ TanksGame_autogen/timestamp: \ /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake \ /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ @@ -349,6 +352,7 @@ TanksGame_autogen/timestamp: \ /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ diff --git a/cmake-build-debug/compile_commands.json b/cmake-build-debug/compile_commands.json new file mode 100644 index 0000000..a246f94 --- /dev/null +++ b/cmake-build-debug/compile_commands.json @@ -0,0 +1,80 @@ +[ +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp", + "output": "CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/main.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp", + "output": "CMakeFiles/TanksGame.dir/src/main.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/GameScane.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp", + "output": "CMakeFiles/TanksGame.dir/src/GameScane.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/GameModel.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp", + "output": "CMakeFiles/TanksGame.dir/src/GameModel.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/Bonus.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp", + "output": "CMakeFiles/TanksGame.dir/src/Bonus.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/Tank.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp", + "output": "CMakeFiles/TanksGame.dir/src/Tank.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp", + "output": "CMakeFiles/TanksGame.dir/src/EnemyTank.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp", + "output": "CMakeFiles/TanksGame.dir/src/LightEnemy.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp", + "output": "CMakeFiles/TanksGame.dir/src/HeavyEnemy.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp", + "output": "CMakeFiles/TanksGame.dir/src/TwinShooterEnemy.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/Wall.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp", + "output": "CMakeFiles/TanksGame.dir/src/Wall.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp", + "output": "CMakeFiles/TanksGame.dir/src/BrickWall.cpp.o" +}, +{ + "directory": "/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug", + "command": "/usr/bin/c++ -DQT_CORE_LIB -DQT_GUI_LIB -DQT_MULTIMEDIA_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_WIDGETS_LIB -I/home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/include -I/home/frankyshelloy/CLionProjects/TankiGame/include -isystem /usr/include/x86_64-linux-gnu/qt5 -isystem /usr/include/x86_64-linux-gnu/qt5/QtCore -isystem /usr/lib/x86_64-linux-gnu/qt5/mkspecs/linux-g++ -isystem /usr/include/x86_64-linux-gnu/qt5/QtWidgets -isystem /usr/include/x86_64-linux-gnu/qt5/QtGui -isystem /usr/include/x86_64-linux-gnu/qt5/QtMultimedia -isystem /usr/include/x86_64-linux-gnu/qt5/QtNetwork -std=gnu++20 -fPIC -o CMakeFiles/TanksGame.dir/src/Bullet.cpp.o -c /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp", + "file": "/home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp", + "output": "CMakeFiles/TanksGame.dir/src/Bullet.cpp.o" +} +] \ No newline at end of file diff --git a/include/GameScane.h b/include/GameScane.h index 44687f0..d2e102a 100644 --- a/include/GameScane.h +++ b/include/GameScane.h @@ -7,14 +7,14 @@ #include #include "GameModel.h" #include "Bullet.h" +#include "Tank.h" +#include "Wall.h" +#include "BrickWall.h" #include #include #include #include -class Tank; -class Wall; -class BrickWall; class Bullet; class EnemyTank; class Bonus; @@ -24,6 +24,7 @@ class GameScane final : public QGraphicsScene { public: explicit GameScane(QObject* parent = nullptr); + ~GameScane(); void ModifyPlayerLives(int delta); void ModifyScore(int delta); @@ -65,9 +66,9 @@ class GameScane final : public QGraphicsScene { QSet m_pressedKeys; - Tank* m_playerTank = nullptr; - QList m_walls; - QList m_brickWalls; + std::unique_ptr m_playerTank; + std::vector> m_walls; + std::vector> m_brickWalls; std::vector> m_bullets; std::vector> m_enemyBullets; QList m_enemyTanks; diff --git a/src/GameScane.cpp b/src/GameScane.cpp index 713c703..fab8dbe 100644 --- a/src/GameScane.cpp +++ b/src/GameScane.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include "BrickWall.h" #include "Bullet.h" @@ -32,8 +33,8 @@ GameScane::GameScane(QObject* parent) setSceneRect(0, 0, kSceneWidth, kSceneHeight); setBackgroundBrush(QColor(20, 40, 20)); - m_playerTank = new Tank(kSceneWidth / 2, kSceneHeight / 2); - addItem(m_playerTank); + m_playerTank = std::make_unique(kSceneWidth / 2, kSceneHeight / 2); + addItem(m_playerTank.get()); m_livesText = new QGraphicsTextItem(); m_livesText->setZValue(10); @@ -60,6 +61,8 @@ GameScane::GameScane(QObject* parent) UpdateScoreDisplay(); } +GameScane::~GameScane() = default; + void GameScane::InitializeLevel() { const char* levelMap[kMapRows] = { "WWWWWWWWWWWWWWWWWWWW", @@ -91,13 +94,11 @@ void GameScane::InitializeLevel() { qreal posY = y * kTileSize; if (cell == 'W') { - auto* wall = new Wall(posX, posY); - m_walls.append(wall); - addItem(wall); + m_walls.emplace_back(std::make_unique(posX, posY)); + addItem(m_walls.back().get()); } else if (cell == 'B') { - auto* brick = new BrickWall(posX, posY); - m_brickWalls.append(brick); - addItem(brick); + m_brickWalls.emplace_back(std::make_unique(posX, posY)); + addItem(m_brickWalls.back().get()); } else if (cell == ' ') { m_freeSpawnPoints.append(QPointF(posX, posY)); } @@ -326,8 +327,9 @@ void GameScane::UpdatePlayerBullets() { if (auto* brick = FindCollidingBrickWall(bulletRect)) { removeItem(brick); - delete brick; - m_brickWalls.removeAll(brick); + auto it = std::find_if(m_brickWalls.begin(), m_brickWalls.end(), + [brick](const std::unique_ptr& p) { return p.get() == brick; }); + if (it != m_brickWalls.end()) m_brickWalls.erase(it); removeItem(bullet); m_bullets.erase(m_bullets.begin() + i); continue; @@ -356,8 +358,9 @@ void GameScane::UpdateEnemyBullets() { if (auto* brick = FindCollidingBrickWall(bulletRect)) { removeItem(brick); - delete brick; - m_brickWalls.removeAll(brick); + auto it = std::find_if(m_brickWalls.begin(), m_brickWalls.end(), + [brick](const std::unique_ptr& p) { return p.get() == brick; }); + if (it != m_brickWalls.end()) m_brickWalls.erase(it); removeItem(bullet); m_enemyBullets.erase(m_enemyBullets.begin() + i); continue; @@ -433,7 +436,8 @@ void GameScane::keyReleaseEvent(QKeyEvent* event) { } bool GameScane::IsCollidingWithSolidWall(const QRectF& rect) const { - for (const auto* wall : m_walls) { + for (const auto& wallPtr : m_walls) { + const auto* wall = wallPtr.get(); if (wall->boundingRect().translated(wall->pos()).intersects(rect)) { return true; } @@ -442,9 +446,10 @@ bool GameScane::IsCollidingWithSolidWall(const QRectF& rect) const { } BrickWall* GameScane::FindCollidingBrickWall(const QRectF& rect) const { - for (auto* brick : m_brickWalls) { + for (const auto& brickPtr : m_brickWalls) { + const auto* brick = brickPtr.get(); if (brick->boundingRect().translated(brick->pos()).intersects(rect)) { - return brick; + return const_cast(brick); } } return nullptr; @@ -570,6 +575,13 @@ void GameScane::UpdateScoreDisplay() { } void GameScane::RestartGame() { + auto cleanupUnique = [this](auto& container) { + for (auto& uptr : container) { + if (uptr) removeItem(uptr.get()); + } + container.clear(); + }; + auto cleanupRaw = [this](auto& container) { for (auto* item : container) { removeItem(item); @@ -578,20 +590,14 @@ void GameScane::RestartGame() { container.clear(); }; - auto cleanupBullets = [this](auto& container) { - for (auto& uptr : container) { - if (uptr) removeItem(uptr.get()); - } - container.clear(); - }; + auto cleanupBullets = cleanupUnique; if (m_playerTank) { - removeItem(m_playerTank); - delete m_playerTank; - m_playerTank = nullptr; + removeItem(m_playerTank.get()); + m_playerTank.reset(); } - cleanupRaw(m_walls); - cleanupRaw(m_brickWalls); + cleanupUnique(m_walls); + cleanupUnique(m_brickWalls); cleanupBullets(m_bullets); cleanupBullets(m_enemyBullets); cleanupRaw(m_enemyTanks); @@ -621,8 +627,8 @@ void GameScane::RestartGame() { m_canFire = true; m_enemySpawnCooldown = kSpawnCooldown; - m_playerTank = new Tank(kSceneWidth / 2, kSceneHeight / 2); - addItem(m_playerTank); + m_playerTank = std::make_unique(kSceneWidth / 2, kSceneHeight / 2); + addItem(m_playerTank.get()); InitializeLevel(); From 35d818bb00404e748e149baeb2e290465a4a5303 Mon Sep 17 00:00:00 2001 From: frankyshelloy Date: Tue, 9 Dec 2025 04:02:08 +0700 Subject: [PATCH 05/13] Update --- .../TanksGame.dir/compiler_depend.internal | 472 ++++++++++++++++++ .../TanksGame.dir/compiler_depend.make | 472 ++++++++++++++++++ .../TanksGame.dir/src/GameScane.cpp.o | Bin 432464 -> 435720 bytes .../TanksGame_autogen.dir/ParseCache.txt | 2 +- .../compiler_depend.internal | 460 +++++++++++++++++ .../compiler_depend.make | 468 +++++++++++++++++ cmake-build-debug/TanksGame | Bin 498832 -> 499000 bytes src/GameScane.cpp | 45 +- 8 files changed, 1917 insertions(+), 2 deletions(-) diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal index 52143ac..aa75b54 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.internal @@ -1830,12 +1830,475 @@ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake-3.31/Modules/Platform/Linux.cmake /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/mocs_compilation.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp /usr/include/alloca.h @@ -2219,6 +2682,7 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h @@ -2262,10 +2726,13 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o CMakeFiles/TanksGame.dir/src/Bonus.cpp.o /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp /home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h /usr/include/alloca.h /usr/include/asm-generic/bitsperlong.h /usr/include/asm-generic/errno-base.h @@ -2650,6 +3117,7 @@ CMakeFiles/TanksGame.dir/src/Bonus.cpp.o /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent /usr/include/x86_64-linux-gnu/qt5/QtGui/QPen + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h @@ -6876,10 +7344,13 @@ CMakeFiles/TanksGame.dir/src/Wall.cpp.o CMakeFiles/TanksGame.dir/src/main.cpp.o /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h /usr/include/alloca.h /usr/include/asm-generic/bitsperlong.h /usr/include/asm-generic/errno-base.h @@ -7265,6 +7736,7 @@ CMakeFiles/TanksGame.dir/src/main.cpp.o /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h /usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make index e1baafa..3e19240 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make +++ b/cmake-build-debug/CMakeFiles/TanksGame.dir/compiler_depend.make @@ -1828,12 +1828,475 @@ TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLi /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: TanksGame_autogen/mocs_compilation.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ TanksGame_autogen/6YEA5652QU/moc_GameModel.cpp \ TanksGame_autogen/6YEA5652QU/moc_GameScane.cpp \ /usr/include/alloca.h \ @@ -2217,6 +2680,7 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: TanksGame_aut /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ @@ -2259,10 +2723,13 @@ CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o: TanksGame_aut CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ /home/frankyshelloy/CLionProjects/TankiGame/include/Bonus.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ /usr/include/alloca.h \ /usr/include/asm-generic/bitsperlong.h \ /usr/include/asm-generic/errno-base.h \ @@ -2647,6 +3114,7 @@ CMakeFiles/TanksGame.dir/src/Bonus.cpp.o: /home/frankyshelloy/CLionProjects/Tank /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QPen \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ @@ -6862,10 +7330,13 @@ CMakeFiles/TanksGame.dir/src/Wall.cpp.o: /home/frankyshelloy/CLionProjects/Tanki /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h CMakeFiles/TanksGame.dir/src/main.cpp.o: /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ /home/frankyshelloy/CLionProjects/TankiGame/include/GlobalConstants.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ /usr/include/alloca.h \ /usr/include/asm-generic/bitsperlong.h \ /usr/include/asm-generic/errno-base.h \ @@ -7251,6 +7722,7 @@ CMakeFiles/TanksGame.dir/src/main.cpp.o: /home/frankyshelloy/CLionProjects/Tanki /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QColor \ /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ /usr/include/x86_64-linux-gnu/qt5/QtGui/qcursor.h \ diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameScane.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/src/GameScane.cpp.o index 191bf5cb9104731dfb8154f32378c511bddd2873..0b4e1455e9e644a3aa21b07d1b9b723c5fbd1c88 100644 GIT binary patch literal 435720 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 YJ*gf*bpN`NeC2QL{+VIM=Rb7*|7DfZLjV8( literal 432464 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 diff --git a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/ParseCache.txt b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/ParseCache.txt index e6d96f7..0ad650c 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/ParseCache.txt +++ b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/ParseCache.txt @@ -697,5 +697,5 @@ /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp -/home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp +/home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp diff --git a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal index 2f60132..dc3d60b 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal +++ b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.internal @@ -10310,4 +10310,464 @@ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake /usr/share/cmake-3.31/Modules/Platform/Linux.cmake /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeCXXCompiler.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/CMakeFiles/3.31.6/CMakeSystem.cmake + /home/frankyshelloy/CLionProjects/TankiGame/cmake-build-debug/TanksGame_autogen/moc_predefs.h + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp + /usr/bin/cmake + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/14/algorithm + /usr/include/c++/14/array + /usr/include/c++/14/atomic + /usr/include/c++/14/backward/auto_ptr.h + /usr/include/c++/14/backward/binders.h + /usr/include/c++/14/bit + /usr/include/c++/14/bits/algorithmfwd.h + /usr/include/c++/14/bits/align.h + /usr/include/c++/14/bits/alloc_traits.h + /usr/include/c++/14/bits/allocated_ptr.h + /usr/include/c++/14/bits/allocator.h + /usr/include/c++/14/bits/atomic_base.h + /usr/include/c++/14/bits/atomic_lockfree_defines.h + /usr/include/c++/14/bits/atomic_wait.h + /usr/include/c++/14/bits/basic_ios.h + /usr/include/c++/14/bits/basic_ios.tcc + /usr/include/c++/14/bits/basic_string.h + /usr/include/c++/14/bits/basic_string.tcc + /usr/include/c++/14/bits/c++0x_warning.h + /usr/include/c++/14/bits/char_traits.h + /usr/include/c++/14/bits/charconv.h + /usr/include/c++/14/bits/concept_check.h + /usr/include/c++/14/bits/cpp_type_traits.h + /usr/include/c++/14/bits/cxxabi_forced.h + /usr/include/c++/14/bits/cxxabi_init_exception.h + /usr/include/c++/14/bits/erase_if.h + /usr/include/c++/14/bits/exception.h + /usr/include/c++/14/bits/exception_defines.h + /usr/include/c++/14/bits/exception_ptr.h + /usr/include/c++/14/bits/functexcept.h + /usr/include/c++/14/bits/functional_hash.h + /usr/include/c++/14/bits/hash_bytes.h + /usr/include/c++/14/bits/invoke.h + /usr/include/c++/14/bits/ios_base.h + /usr/include/c++/14/bits/iterator_concepts.h + /usr/include/c++/14/bits/list.tcc + /usr/include/c++/14/bits/locale_classes.h + /usr/include/c++/14/bits/locale_classes.tcc + /usr/include/c++/14/bits/locale_facets.h + /usr/include/c++/14/bits/locale_facets.tcc + /usr/include/c++/14/bits/localefwd.h + /usr/include/c++/14/bits/max_size_type.h + /usr/include/c++/14/bits/memory_resource.h + /usr/include/c++/14/bits/memoryfwd.h + /usr/include/c++/14/bits/mofunc_impl.h + /usr/include/c++/14/bits/move.h + /usr/include/c++/14/bits/move_only_function.h + /usr/include/c++/14/bits/nested_exception.h + /usr/include/c++/14/bits/new_allocator.h + /usr/include/c++/14/bits/node_handle.h + /usr/include/c++/14/bits/ostream.tcc + /usr/include/c++/14/bits/ostream_insert.h + /usr/include/c++/14/bits/out_ptr.h + /usr/include/c++/14/bits/postypes.h + /usr/include/c++/14/bits/predefined_ops.h + /usr/include/c++/14/bits/ptr_traits.h + /usr/include/c++/14/bits/range_access.h + /usr/include/c++/14/bits/ranges_algo.h + /usr/include/c++/14/bits/ranges_algobase.h + /usr/include/c++/14/bits/ranges_base.h + /usr/include/c++/14/bits/ranges_cmp.h + /usr/include/c++/14/bits/ranges_uninitialized.h + /usr/include/c++/14/bits/ranges_util.h + /usr/include/c++/14/bits/refwrap.h + /usr/include/c++/14/bits/requires_hosted.h + /usr/include/c++/14/bits/sat_arith.h + /usr/include/c++/14/bits/shared_ptr.h + /usr/include/c++/14/bits/shared_ptr_atomic.h + /usr/include/c++/14/bits/shared_ptr_base.h + /usr/include/c++/14/bits/std_abs.h + /usr/include/c++/14/bits/std_function.h + /usr/include/c++/14/bits/std_mutex.h + /usr/include/c++/14/bits/stl_algo.h + /usr/include/c++/14/bits/stl_algobase.h + /usr/include/c++/14/bits/stl_bvector.h + /usr/include/c++/14/bits/stl_construct.h + /usr/include/c++/14/bits/stl_function.h + /usr/include/c++/14/bits/stl_heap.h + /usr/include/c++/14/bits/stl_iterator.h + /usr/include/c++/14/bits/stl_iterator_base_funcs.h + /usr/include/c++/14/bits/stl_iterator_base_types.h + /usr/include/c++/14/bits/stl_list.h + /usr/include/c++/14/bits/stl_map.h + /usr/include/c++/14/bits/stl_multimap.h + /usr/include/c++/14/bits/stl_numeric.h + /usr/include/c++/14/bits/stl_pair.h + /usr/include/c++/14/bits/stl_raw_storage_iter.h + /usr/include/c++/14/bits/stl_relops.h + /usr/include/c++/14/bits/stl_tempbuf.h + /usr/include/c++/14/bits/stl_tree.h + /usr/include/c++/14/bits/stl_uninitialized.h + /usr/include/c++/14/bits/stl_vector.h + /usr/include/c++/14/bits/stream_iterator.h + /usr/include/c++/14/bits/streambuf.tcc + /usr/include/c++/14/bits/streambuf_iterator.h + /usr/include/c++/14/bits/string_view.tcc + /usr/include/c++/14/bits/stringfwd.h + /usr/include/c++/14/bits/uniform_int_dist.h + /usr/include/c++/14/bits/unique_ptr.h + /usr/include/c++/14/bits/uses_allocator.h + /usr/include/c++/14/bits/uses_allocator_args.h + /usr/include/c++/14/bits/utility.h + /usr/include/c++/14/bits/vector.tcc + /usr/include/c++/14/bits/version.h + /usr/include/c++/14/cctype + /usr/include/c++/14/cerrno + /usr/include/c++/14/charconv + /usr/include/c++/14/climits + /usr/include/c++/14/clocale + /usr/include/c++/14/compare + /usr/include/c++/14/concepts + /usr/include/c++/14/cstddef + /usr/include/c++/14/cstdint + /usr/include/c++/14/cstdlib + /usr/include/c++/14/cwchar + /usr/include/c++/14/cwctype + /usr/include/c++/14/debug/assertions.h + /usr/include/c++/14/debug/debug.h + /usr/include/c++/14/exception + /usr/include/c++/14/ext/aligned_buffer.h + /usr/include/c++/14/ext/alloc_traits.h + /usr/include/c++/14/ext/atomicity.h + /usr/include/c++/14/ext/concurrence.h + /usr/include/c++/14/ext/numeric_traits.h + /usr/include/c++/14/ext/string_conversions.h + /usr/include/c++/14/ext/type_traits.h + /usr/include/c++/14/format + /usr/include/c++/14/functional + /usr/include/c++/14/initializer_list + /usr/include/c++/14/ios + /usr/include/c++/14/iosfwd + /usr/include/c++/14/iterator + /usr/include/c++/14/limits + /usr/include/c++/14/list + /usr/include/c++/14/map + /usr/include/c++/14/memory + /usr/include/c++/14/new + /usr/include/c++/14/numbers + /usr/include/c++/14/numeric + /usr/include/c++/14/optional + /usr/include/c++/14/ostream + /usr/include/c++/14/pstl/execution_defs.h + /usr/include/c++/14/pstl/glue_numeric_defs.h + /usr/include/c++/14/stdexcept + /usr/include/c++/14/stdlib.h + /usr/include/c++/14/streambuf + /usr/include/c++/14/string + /usr/include/c++/14/string_view + /usr/include/c++/14/text_encoding + /usr/include/c++/14/tuple + /usr/include/c++/14/type_traits + /usr/include/c++/14/typeinfo + /usr/include/c++/14/unordered_map + /usr/include/c++/14/utility + /usr/include/c++/14/vector + /usr/include/ctype.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake diff --git a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make index 4adbe5a..c54a3e3 100644 --- a/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make +++ b/cmake-build-debug/CMakeFiles/TanksGame_autogen.dir/compiler_depend.make @@ -10308,9 +10308,475 @@ TanksGame_autogen/timestamp: /home/frankyshelloy/CLionProjects/TankiGame/CMakeLi /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ + /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake \ + /home/frankyshelloy/CLionProjects/TankiGame/CMakeLists.txt \ + CMakeFiles/3.31.6/CMakeCXXCompiler.cmake \ + CMakeFiles/3.31.6/CMakeSystem.cmake \ + TanksGame_autogen/moc_predefs.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Bullet.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameModel.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/GameScane.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h \ + /home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bonus.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/BrickWall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Bullet.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/EnemyTank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameModel.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/GameScane.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/HeavyEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/LightEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Tank.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/Wall.cpp \ + /home/frankyshelloy/CLionProjects/TankiGame/src/main.cpp \ + /usr/bin/cmake \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/14/algorithm \ + /usr/include/c++/14/array \ + /usr/include/c++/14/atomic \ + /usr/include/c++/14/backward/auto_ptr.h \ + /usr/include/c++/14/backward/binders.h \ + /usr/include/c++/14/bit \ + /usr/include/c++/14/bits/algorithmfwd.h \ + /usr/include/c++/14/bits/align.h \ + /usr/include/c++/14/bits/alloc_traits.h \ + /usr/include/c++/14/bits/allocated_ptr.h \ + /usr/include/c++/14/bits/allocator.h \ + /usr/include/c++/14/bits/atomic_base.h \ + /usr/include/c++/14/bits/atomic_lockfree_defines.h \ + /usr/include/c++/14/bits/atomic_wait.h \ + /usr/include/c++/14/bits/basic_ios.h \ + /usr/include/c++/14/bits/basic_ios.tcc \ + /usr/include/c++/14/bits/basic_string.h \ + /usr/include/c++/14/bits/basic_string.tcc \ + /usr/include/c++/14/bits/c++0x_warning.h \ + /usr/include/c++/14/bits/char_traits.h \ + /usr/include/c++/14/bits/charconv.h \ + /usr/include/c++/14/bits/concept_check.h \ + /usr/include/c++/14/bits/cpp_type_traits.h \ + /usr/include/c++/14/bits/cxxabi_forced.h \ + /usr/include/c++/14/bits/cxxabi_init_exception.h \ + /usr/include/c++/14/bits/erase_if.h \ + /usr/include/c++/14/bits/exception.h \ + /usr/include/c++/14/bits/exception_defines.h \ + /usr/include/c++/14/bits/exception_ptr.h \ + /usr/include/c++/14/bits/functexcept.h \ + /usr/include/c++/14/bits/functional_hash.h \ + /usr/include/c++/14/bits/hash_bytes.h \ + /usr/include/c++/14/bits/invoke.h \ + /usr/include/c++/14/bits/ios_base.h \ + /usr/include/c++/14/bits/iterator_concepts.h \ + /usr/include/c++/14/bits/list.tcc \ + /usr/include/c++/14/bits/locale_classes.h \ + /usr/include/c++/14/bits/locale_classes.tcc \ + /usr/include/c++/14/bits/locale_facets.h \ + /usr/include/c++/14/bits/locale_facets.tcc \ + /usr/include/c++/14/bits/localefwd.h \ + /usr/include/c++/14/bits/max_size_type.h \ + /usr/include/c++/14/bits/memory_resource.h \ + /usr/include/c++/14/bits/memoryfwd.h \ + /usr/include/c++/14/bits/mofunc_impl.h \ + /usr/include/c++/14/bits/move.h \ + /usr/include/c++/14/bits/move_only_function.h \ + /usr/include/c++/14/bits/nested_exception.h \ + /usr/include/c++/14/bits/new_allocator.h \ + /usr/include/c++/14/bits/node_handle.h \ + /usr/include/c++/14/bits/ostream.tcc \ + /usr/include/c++/14/bits/ostream_insert.h \ + /usr/include/c++/14/bits/out_ptr.h \ + /usr/include/c++/14/bits/postypes.h \ + /usr/include/c++/14/bits/predefined_ops.h \ + /usr/include/c++/14/bits/ptr_traits.h \ + /usr/include/c++/14/bits/range_access.h \ + /usr/include/c++/14/bits/ranges_algo.h \ + /usr/include/c++/14/bits/ranges_algobase.h \ + /usr/include/c++/14/bits/ranges_base.h \ + /usr/include/c++/14/bits/ranges_cmp.h \ + /usr/include/c++/14/bits/ranges_uninitialized.h \ + /usr/include/c++/14/bits/ranges_util.h \ + /usr/include/c++/14/bits/refwrap.h \ + /usr/include/c++/14/bits/requires_hosted.h \ + /usr/include/c++/14/bits/sat_arith.h \ + /usr/include/c++/14/bits/shared_ptr.h \ + /usr/include/c++/14/bits/shared_ptr_atomic.h \ + /usr/include/c++/14/bits/shared_ptr_base.h \ + /usr/include/c++/14/bits/std_abs.h \ + /usr/include/c++/14/bits/std_function.h \ + /usr/include/c++/14/bits/std_mutex.h \ + /usr/include/c++/14/bits/stl_algo.h \ + /usr/include/c++/14/bits/stl_algobase.h \ + /usr/include/c++/14/bits/stl_bvector.h \ + /usr/include/c++/14/bits/stl_construct.h \ + /usr/include/c++/14/bits/stl_function.h \ + /usr/include/c++/14/bits/stl_heap.h \ + /usr/include/c++/14/bits/stl_iterator.h \ + /usr/include/c++/14/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/14/bits/stl_iterator_base_types.h \ + /usr/include/c++/14/bits/stl_list.h \ + /usr/include/c++/14/bits/stl_map.h \ + /usr/include/c++/14/bits/stl_multimap.h \ + /usr/include/c++/14/bits/stl_numeric.h \ + /usr/include/c++/14/bits/stl_pair.h \ + /usr/include/c++/14/bits/stl_raw_storage_iter.h \ + /usr/include/c++/14/bits/stl_relops.h \ + /usr/include/c++/14/bits/stl_tempbuf.h \ + /usr/include/c++/14/bits/stl_tree.h \ + /usr/include/c++/14/bits/stl_uninitialized.h \ + /usr/include/c++/14/bits/stl_vector.h \ + /usr/include/c++/14/bits/stream_iterator.h \ + /usr/include/c++/14/bits/streambuf.tcc \ + /usr/include/c++/14/bits/streambuf_iterator.h \ + /usr/include/c++/14/bits/string_view.tcc \ + /usr/include/c++/14/bits/stringfwd.h \ + /usr/include/c++/14/bits/uniform_int_dist.h \ + /usr/include/c++/14/bits/unique_ptr.h \ + /usr/include/c++/14/bits/uses_allocator.h \ + /usr/include/c++/14/bits/uses_allocator_args.h \ + /usr/include/c++/14/bits/utility.h \ + /usr/include/c++/14/bits/vector.tcc \ + /usr/include/c++/14/bits/version.h \ + /usr/include/c++/14/cctype \ + /usr/include/c++/14/cerrno \ + /usr/include/c++/14/charconv \ + /usr/include/c++/14/climits \ + /usr/include/c++/14/clocale \ + /usr/include/c++/14/compare \ + /usr/include/c++/14/concepts \ + /usr/include/c++/14/cstddef \ + /usr/include/c++/14/cstdint \ + /usr/include/c++/14/cstdlib \ + /usr/include/c++/14/cwchar \ + /usr/include/c++/14/cwctype \ + /usr/include/c++/14/debug/assertions.h \ + /usr/include/c++/14/debug/debug.h \ + /usr/include/c++/14/exception \ + /usr/include/c++/14/ext/aligned_buffer.h \ + /usr/include/c++/14/ext/alloc_traits.h \ + /usr/include/c++/14/ext/atomicity.h \ + /usr/include/c++/14/ext/concurrence.h \ + /usr/include/c++/14/ext/numeric_traits.h \ + /usr/include/c++/14/ext/string_conversions.h \ + /usr/include/c++/14/ext/type_traits.h \ + /usr/include/c++/14/format \ + /usr/include/c++/14/functional \ + /usr/include/c++/14/initializer_list \ + /usr/include/c++/14/ios \ + /usr/include/c++/14/iosfwd \ + /usr/include/c++/14/iterator \ + /usr/include/c++/14/limits \ + /usr/include/c++/14/list \ + /usr/include/c++/14/map \ + /usr/include/c++/14/memory \ + /usr/include/c++/14/new \ + /usr/include/c++/14/numbers \ + /usr/include/c++/14/numeric \ + /usr/include/c++/14/optional \ + /usr/include/c++/14/ostream \ + /usr/include/c++/14/pstl/execution_defs.h \ + /usr/include/c++/14/pstl/glue_numeric_defs.h \ + /usr/include/c++/14/stdexcept \ + /usr/include/c++/14/stdlib.h \ + /usr/include/c++/14/streambuf \ + /usr/include/c++/14/string \ + /usr/include/c++/14/string_view \ + /usr/include/c++/14/text_encoding \ + /usr/include/c++/14/tuple \ + /usr/include/c++/14/type_traits \ + /usr/include/c++/14/typeinfo \ + /usr/include/c++/14/unordered_map \ + /usr/include/c++/14/utility \ + /usr/include/c++/14/vector \ + /usr/include/ctype.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/14/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QList \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QObject \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QPointF \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QSet \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/QTimer \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qarraydata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qatomic_cxx11.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasicatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbasictimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qbytearraylist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qchar.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcompilerdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qconfig.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainerfwd.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcontainertools_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qcoreevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qdatastream.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfile.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qfiledevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qflags.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qgenericatomic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qglobalstatic.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhash.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qhashfunctions.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiodevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qiterator.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qline.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qlogging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmargins.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qmetatype.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnamespace.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qnumeric.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobject_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qobjectdefs_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpair.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qpoint.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qprocessordetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrect.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qrefcount.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qregexp.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qscopedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qset.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qshareddata.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsharedpointer_impl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsize.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstring.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringalgorithms.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringlist.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringliteral.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringmatcher.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qstringview.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsysinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qsystemdetection.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtcore-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtimer.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qtypeinfo.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qurl.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvariant.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvarlengtharray.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qvector.h \ + /usr/include/x86_64-linux-gnu/qt5/QtCore/qversiontagging.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QKeyEvent \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qbrush.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qcolor.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qevent.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qfont.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qimage.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qkeysequence.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qmatrix.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpaintdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpainterpath.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpen.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixelformat.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpixmap.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qpolygon.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qregion.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgb.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qrgba64.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtgui-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtguiglobal.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtouchdevice.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qtransform.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qvector2d.h \ + /usr/include/x86_64-linux-gnu/qt5/QtGui/qwindowdefs.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsPixmapItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsScene \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/QGraphicsTextItem \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsitem.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qgraphicsscene.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgets-config.h \ + /usr/include/x86_64-linux-gnu/qt5/QtWidgets/qtwidgetsglobal.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/14/include/syslimits.h \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5Config.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5/Qt5ModuleLocation.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigExtrasMkspecDir.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Core/Qt5CoreMacros.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5GuiConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QComposePlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSEmulatorIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsEglDeviceIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSKmsGbmIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEglFSX11IntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevKeyboardPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevMousePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTabletPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QEvdevTouchScreenPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QGifPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QICOPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QIbusPlatformInputContextPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QJpegPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLibInputPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QLinuxFbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QMinimalIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QOffscreenIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QTuioTouchPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QVncIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbEglIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbGlxIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Gui/Qt5Gui_QXcbIntegrationPlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Multimedia/Qt5MultimediaConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5NetworkConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QConnmanEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QGenericEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Network/Qt5Network_QNetworkManagerEnginePlugin.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfig.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigExtras.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsConfigVersion.cmake \ + /usr/lib/x86_64-linux-gnu/cmake/Qt5Widgets/Qt5WidgetsMacros.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCXXInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeCommonLanguageInclude.cmake \ + /usr/share/cmake-3.31/Modules/CMakeGenericSystem.cmake \ + /usr/share/cmake-3.31/Modules/CMakeInitializeConfigs.cmake \ + /usr/share/cmake-3.31/Modules/CMakeLanguageInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeParseArguments.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInformation.cmake \ + /usr/share/cmake-3.31/Modules/CMakeSystemSpecificInitialize.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/CMakeCommonCompilerMacros.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Compiler/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCXXLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Internal/CMakeCommonLinkerInformation.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linker/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU-CXX.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-GNU.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux-Initialize.cmake \ + /usr/share/cmake-3.31/Modules/Platform/Linux.cmake \ /usr/share/cmake-3.31/Modules/Platform/UnixPaths.cmake +/usr/include/x86_64-linux-gnu/qt5/QtGui/QPixmap: + +/home/frankyshelloy/CLionProjects/TankiGame/include/Wall.h: + +/home/frankyshelloy/CLionProjects/TankiGame/include/BrickWall.h: + /home/frankyshelloy/CLionProjects/TankiGame/src/TwinShooterEnemy.cpp: /usr/share/cmake-3.31/Modules/Platform/Linux.cmake: @@ -11191,6 +11657,8 @@ CMakeFiles/3.31.6/CMakeSystem.cmake: /usr/include/c++/14/iosfwd: +/home/frankyshelloy/CLionProjects/TankiGame/include/Tank.h: + /usr/include/c++/14/bits/char_traits.h: /usr/include/c++/14/list: diff --git a/cmake-build-debug/TanksGame b/cmake-build-debug/TanksGame index 6431d6297f1f55381d7a808583f7b6b5adc50ce8..679308df53f7572dde0cb71ea7221cfa5cf91d75 100755 GIT binary patch delta 87121 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 Q*7@D#h*)lpS?3q|f2k5p4FCWD delta 85987 zcmZ^s34BdQ`^WE05+bsaRaOxZu|)(y5KBm{u{H=|sWk{y^(t=cAwue4($*5HZE6h( zi9HC3r5dUPp;4;W9;%wQhdzBeb;Zb;Z`zRd9~;%s@!qIf7ipkn%qziziM)SRZmbg zxv?H0)glb_2(KnL)FZN*{54UwcN?XhP)pWhZnfxiRi3`_zw41vO>U@1W;JQPip?q5SW-F=kSrjD$KhMC(Nq00Tz&EYtIQ=&>v@Ln6evQW3bLfMAMGd!{!LbFKZyq)G#Lqr}?eo3oG zUsPm!em=&ME_KabxFNoVwje=dNsnHVAI;TWn`V5D;m=nm8lNZe=Y^9D&$=Z396VWl zwn|qGayLq{REcY%Ax)kt8EcT#w#rvUdlQvOn~G?!u}bLX26WtL<-^TGX~7I--)0wo zVMJpRzJyL27=i#n2BJf3}zv?SqAeETp)w_ z2u90bQQ@+(O1)mA%-FrT!TG6hN$N5`Zp6xS(JOz^J>Y}OASu*MOHf+uad(-_=LEQ} zP*5c7aZicc(>7)sml)EEh@*Vi7$k+d?)))ja}mmnPFW_Pwss^RBT%|UP~<&Xrrh5X zLr2e0TJMdcN}{6dZAzCUDyR1LqQCvB6z_9Y8tjXvKi^fR?Q7b0gqTC5&Xf)Aq7v7+ z#^-nS`bV?T+)IwXM!Cdc*&&SglaBaD=g-xQqIK>nAz4jn`V3`MmYY)(o?*W+O~O4< z)TXRx8h1x|nAOztS5XT?QPx#OeR4->w!Z;AG>wf+Aa2U!{oa<&=;g|lyLJ7?-QjL6 z)Qy1lKOB7iiC%fe#4#N)!g(^==4!G)Bx6bSiHl|5QoUXo^Lt&}HwcIdA&HD~F+`nE zqYfFP?%bBSe3q+G3%O#f6yu|tST+no?Pgo)rj#n_2O7AzyvE>$X-5ZZG)wb8sf&4$ zzE+A4O!7?ogKC!LFLX$;T8_{X9a(9$0D%;%PybK`Wp|>#O;eQYCiMC=B|kfa?wF>$ z%5FwKnWogwX-0cYQ(|(wX{~9>jGO>^KS9}$)3M$T-lI@d^GCcRMCBRA^6CWTX^toT z`=(OsV66K$m{4Gd8&YIeO(8uKl>Z%UN#{*gb{}j&?GltL2RqZU+e)27!`yzpfi}B{ zS}j?SLp~XI(hosh;%#N|p&|B@5%*-Q6xrQYemgXT*0`ZW9g5(C%Aq-LgvVHK59DG|1Vufkr&qxq))5f8b#NY_IYFIyD7@%JU7=MjK)W{)+i=*nV4)~#`dY%7xIP^ns6;U@W?Gn z)2?LG<3CgPgX6h1%VK#?Oj#x-6{LPLUU_jc#I6~iCgpgZb6IJc@9EW`N)pV2sWK%I*$XQJ-U3jPKIHfE<)aUsRvKkLB^8(HL)YTu9kW)d_D^6Kh=&#H_ z)tK6iSH3&d%)N#*QYcMXCV&#hj#HkVigd{-hNjdZNmyR<)t0D#Rq1ltpN{-N$v+oF z^<$K^r`>4mIHkDA#pye4Uds8_|j(XxF~<_mRpEh0WZ{Msh<89ZxDQ)J2R`>J&w~thw-BoBn%InONjc+ZHM* zMZxsO2vKavNKveo>#B0cmXXSvqV_cHoJblXldg;tNlW6)lKvH^Y(C%9tMn}Ijhn>^ zo3bq2#BCv?)?IL>mq#kD7Xs<4kxHiv?(|kSCH6v~lSXbD^3@UIJ4#u5!Hw2CD@r{w zOc+>q1TWQl>$fs(3@7tvMk593|cz3Ff>b9#$M ztHrmJm`h<6^H1wpRvB?sHeYJyF&FN_bXpIF2D1bQOsTb%ReSoqmX*HgU@QAA;%I5lZF{AJDD&${#)K@EiQMj-S?EpJr|9j zke4osa@m8T4fkGdN(1wite>2f^2;^sZ{5JCStbX{4xh{$KtjjG1sZ44xg7(qKYu1=c^U@qyW=D;j^vI zbnP2;g6;1_oLSQ~q!!yc49j&%ad6XuVIqGC@*5n{7`7o5h$V?PkjIH?T5#w{vKHP7XY$SDp3hmR>fKQ&r+)zz!l zY2G7d*UUrz(mZJ$ohnO!n)qSL%x|6PruItoRe!qin38a{XGikB743y6D(TTT+$B}{ zcegh;Yk4oF{AyD=`zVU;NUcsOBY$$ErLm%r{C3LfpZw{-qiC_kwY&G_ISX||kLcN$ zhSar5vSIbEr^c)~uhF2!uN)k$POT!ER}M~5`TXJ7DrModZd$D>%i^+m>OLHu!? zY1{;3Tw5O3-!!hhG0v06buf+dF~p@6My*G+QST@;W1+5AGmU0~68Uq#-VgccOBsm` zwLE|A?awPE_M3m@sco2=o+R^%M%h`FVm}Y689)C}x%sm{o%SKyUqW0Qp7YEo>EU6$ zUUx4~seiqd=cc1vcBad5-iR>PE<2e!#nEb4va|rQ9+# zMLEyR^`|6p{d~lySpBiWXvPiQ34;?-h9K2CnM$nv&bfNM+%*s9T1@M87#euJI8P`! zH|jbJtJ3+4F7B9e{f4h!??ZCa!%HudrSnYVkrY;Zv_f$y8R~t|XsxK;9Aj+@b?x(% zVZ z^A`Oo$LNrBHKh}#2AAxm#!{A?Q_kP?Y3yNigYe2@WHhLKF2kahOV25ex9YW+BYl!@ z=+``jth+2F#*zCyoYy7As@*bW*sX>R_3)(j#T&YB4l1d)T6HeVHuxftyRVur*b<|a zWBAI8YMS~Y`>>+F<=JK~qReaU46S@pL^nt;m;T|EZd#@8ZGjSV+ef?3ylKZFpP|wd zWmr`D9p-m)b@?YOgom+YpvxhT!4ru*oAiV%S$g6;FFM8Q0x-cLs7Q5#^6a*|gTiHU zh~Cio0OBP>_ zl+}v&MrV6cvq~tcnJlt-?^m;ZuV&->TXk>*omR*%9`xuwZb9fcHQ|W&^@k(sJ^g1- zi8_0!*__|kubdM41Ev1U`=tHnkfF*{;l8gC^`8C^q2G6fnoVn#4Q-AsZ$Ei{cNn6k z>5DYF=zYqOU&1{rVUKb2VCdPoXytrqr{(KFhj$B&o$ME#1`ae`2P)8&&DMbzdyL~J zsY1!W-auJY=B{1A>n@xrW{7CCox!)ZJWBR@t_+s&m=g#hT&P=M99JS|Ctd-yRR(gy zO>^?)Vn~&>H*|hHHBz({10ZFcEI{<&Ij~c%7st2(hS`JH-xDhM6y&*(*T3J<1t#@B z0n1J6ufgJJR{uS_tLo1qv50Y9=b!}E6)sS+?+x{KGuA>>s>JA>LfxjlO5m^lwRFNO z9UsjX%gFq_hFXjCn_;`b3Hzlg(UBYSWYQsO(I~QbzR~;}x{voLCx3O=#X?ZrC3H>s!I9om{>+W zGrB?4vJZ?jsEv_fQOk$Nl)d-swJ4E3$yb+=VLXMbyDUXco?r4(QmmBEl)vsbbeNAP z<9u0jx6`-z_ZOQM48um&i7Tdc9j0% z%gCB4b)$~*Wn}Pc^QJwEe1=M&mtj%q(Y$a`y>wMw)iN?bb_ateu70n?|K?Jw$vjc> zrt_4AzcqCD69pSAEO>Pq3s^_Z^|MLWex@vNuX!c{AUPqgVuu_apR z@i3s_Uc8}_ z%jNogAAKXux`#AXW{H(zOLujp$W_zqLmJ)AZMEcqG-0_*(hy zNmKiGN2*-)@`!TpNub^5vyAqKW2^Rb$OJdue5%2GXM(UW*hy}QdHstGuCi6vLkpS5 z;HstD4Rtdl<*wQ@(^%AkY~d==WvjND54Kg6tdn6;@7D1IxqsLp{fQJ&F9&%>0bFZ}3%NbU%az}CiM*KVyU_DPu1 zxjev4i_+h#Y4R3jUU{bmWue?Mcr|5+P94ThtuV32KqwmH^H$33av#gWEtp%&x)OKg z#Y^kQ%}h1$W!szOsEMWN3& zn-oUDqsC;D<&}J? zw0zUbHUdfI#$xeTLPeiV%JMh9fnTvI6^20u6$z6}R80Irx%j5lfbB?%sEhmLWDDiG#6;FL5UFdw7;}eOD_#{L z^z{b5c-d~+h%#aDdQ?(Lyz4@b3c2q%RXzgps_8^1a7Rby?;#yps%aV{jV@rLa<}4w zW$Xs%ssFdD((NB-<@(=)EN`qg3O=DPdMZc$X-h}6R{r=Wn6_xG`2HJAEm|wRfg54U zr~lTc4n37G|Ba&4!jyaeHlp3b6q~n=tUdY2!@R?~ye9t2f`2+trykJcqa1qcK^L@A zuDlJV16nEXfQGG<#_xjZ-=RWV%P44Tp?vqwm97m{PQGhICxj|Gpkt`wR2fLFDB+bY z$=2*Cm9d0cZ&M2NpSXUPCirp+A{Rzer{Kml78iKaE&2YeH-fJ|{gasn;6T z#)>eyB$fSWMSMc)u9Qx#y-KoGGG|n|ZdI!6b!NJMOJ?3R$fq8qNX@4Rv&avTmF+Je zbyXJ6p zL4BUOnjwKF%c)B|>Hc*xk)0~6<4l5S&H~oSnS4f9{Er=VCiR@B{twmbv$Bl$Hs8;L zi%Zzczersr>p(3QbCg)IL~l}qIl7R8w8?zt6XrA3tdS9t?`-EXW<5YrJqQBt+^HN z>3cCp>MNKd^(A~N^^J#K-DnizN=7+8e#C`Q#V5HHx_kfQ+QVt?Y^m6B-hU~+@QGBs z^%JSM=NzfHGYZhPM`^C4{>J*G?xfeE2I`$KI)qrhUSsvd85Y-aP8i-P^3M7f2%}TD zyl=jGu=quHMX%8qkA_%3#0#NUNXh-y+IUxdcQ*U1KB;GadUjR2%$dW+`jRH}pfB6! zNa{7r<@#|KfcGN2+0M!0)Wx+a>ds?WC$4B_L% z+3=ad(~t4~0R!_hQqyuV(z8?F5nrvmTi75RUCo~xy#K?WNf5s0&j*&|eSZ!>8Rq`f z&VnDGG~|;djtb%v0Jge5spUM5N2nd&4bFx`M9256jaNu=fp-az{&o{JHTpY{Kc>JT zVlxvgp5FI&odD_Y=MA`hHtG7=ynL1xkPaX(L=~?(g^@AvF4XXZid7UNh6^ zZ<-v$vKo$(6jJnJVj4UvVqFVtL7JXblK zt*%|Vg4r^cueX}Z1-VeZ+50|{i2cby?n2#imUFi(g4!DNgJ5Stxg$IAUiI* zXQ+~F$(}p`j2hgSwQflK>K^63G|jMn2Ak9n6RQ0Twx%JRru{`a?WA-XT^`Kp1z}iD zf%Bw)3U#(KnO`9Bp{u7!pM+0G?e3#n8ETh1OV+NxBVu^*)-w!|g}SEGAmbZf;cYS8 zUdn2iRsLrr(IF< zxF(blUe<7c!8Zpu&}0iVqsqw z#2h=4`m9A8V(*5QxXfQlo7poxh$Yp=(z~`XSwhyZ7R`wp-7*R7S5K_Z^uceeUoeRX zvX-+1jsoHglCM^$qY(2cOe|YF-mwG0q=8$1F%E`s-x}xaUnUAKxmWdz7S;Pj{!MOP zp>9GTyOM~CbZUayb-T$1G$Fq2FE^~#i$;sorp{&6lPsNx8y~`AYD1au;H-MmgV!dQ zdC*^q>Cy>RHBXW?ADhq!<*vke&AjH@gxFYf{?VkE?8G5XEW&3+3T_{KBL+9{S;UULs7q?ly0gSCorVUnm`lXpFHxowGm-O8+$W|D z4o`}isHsV+w^ysDiVPAn5q;5!*^MDy%IHcP$E}vaFRC@;tXY>(j4#n@2W;i|nmgL8 zt;b3+4H|9UYJv3aV`C?`WTQi|iW~`)GtwT+cuboQiSB9jG$#Vr>D}bOnDx3^BzeeA zg_7oN&hoW7bx1k)lsf+EaW|^l$^t~ccmCQilI@EiJ`LdVEpj{v=Ne63+7- zZjx%td#T>AuUeAnmU?V}jkCBTo9;tuhW}9Zo^|8-bf{W)3DNIa*EtSOHLM0w4|@?x z!YuEMKm?A2&Xy@IwLj*kvwCt_9@UCC(#3Hsu@zZFC&sZCLx~G@AHfzzkVdT8hs2uJ z9L{UphILv_9NG7+Nl&U9&PKJyif}Is$GO4cVI9pMCWW=ykU8|;hip+B5>K^)gY7%Y zt*UU9w~%?U{zHjv?zFaKBe6UlNHol8D7wh#YdAINN0Qo1>=zz2U<2lmw(LYNVrK=H z-)_LCE-zZzz_@DFuuQe;KSbIcK7`xdf;Jk=O+Mwh{489E{c^Rlf!$!$8Ek7uve5q1 zK|Gb519}f;O*)Yf`t~Xt*@+Ca{B0nTe(p}|vMud!&Y!gi)h_NtYSbNgg=ca{zA`@i zy5W&!#b9F7cOu`>`2&SBXyeZ8RAOvONm5xroBptn|50d_u zqlaGPnT(F^iANJhyZ4cfZqiOVdVjt59lh^9_lcRKb@!#Chj~dy|D!tkv6po8@%J1( z%hTM^)62Qi_Z+>$OFDYk2h|<@BpQZuN7p{>^WHhm-FLCb@P2B7J-b+}j zgOhMD!>83p*ohBtfZB6}?T^N`E8df(^(MYfTk&ZRfBmE;8-Il5_a=?(YYN5kXnrr2 zwLn(;?_Y5DNp-c3FwZ{3tMA1gRkF5+)v&m0cGR^%I~exM76?bL6qZba^@g4DYLo04 zhlPc`mUA`S9lWGl>KSfBU0zXH_VGOPat`)3C_JNEiLhGE^PbGF7cLz3f57_oBF*U4 zC^o+rPDPue*#2I`&-vaV@r|P`)K+j0)vt$%b4(tF=0CkiThfFjL=%rX^#FBa>BmJ+Rr^tBw_NE*tL{~@nJ`S$RrTZK z531_d5n;7{+oKF(+@5r+%6{vR^kY6(Q{9ibj#YmAOTIS4QJKFRaMZmpHq05_8BuM~ zUO`bTvOgIhr_!!{Ngdk8oek|vTGJ~BWnU|VC8j?5?x6Hh>OtWntPg8@6F)~S$}{O| z-Py_BB*^}hTa|}S4U!%@%df!H)_#;DJ+!M!mCP+i4Xc(r^fb8QjP5?~QnIH-!z+fK zmSB=SDMxx}0#{SrLs9ls9@;G5mKi;?0lE!6dU91cm%B<2oot6qA>SOiIvp_YTYFqF zj=J5e!C$h`0dkndKMQ%Qrvv@7| zh2f97N)Hw}h=kHsK`d3Nb)=lSPqs?`fphOd!XXBC2-ah<# zFw!y}OQ2YWYMkz<*PlPbo}a)D_r!HpGLQtjtbgBH?RDlhh%_RTS?57;)bl`Li^c7T zsuPl>XiVo3d(0cNHQda$eMJ1&zn5{Toj-_JxqEQerw)05t0%0&e4Y|lPX+AGAkxs& zU3Q0hDeonyVBUjC{g5?0JN$#INwqD5)QRH>KAXqYWQwCnoUI3&KA5;#ZRvoT@=g`R z&UZmqLdUW4MMGSLHhjHpBR*t#^nmXb)WM{2V`YPJ-r4NH?hb;#y@rqxw4*!w-w@KA z9?xRm4Vb2dcNm7rL!I6PN`EnlO0~OaJj=<+lKV8&lbH}UaX#J zD`s8S-!sjfnQAgJ62o!0xYz|B#G@uPSo2}H-uWK4HL^3@2!hcyHHeuy`0 z+{j6FR&HnpD`Q$#SvfmIS{aWEng7?yzRjeS z{hfrBHPf9mn)7GUSWGe8o}nc**_v@U{e9hnZ61eB`>7`E$8n^-_nIcS)A10F#-0?v z6)}7eU#MHsgxQTJ^*nCCYlcN(7sBe|5I@<(KfNAs_E&EIQ< zgN@mM38Xu%pU?j4NCJoUY%ClkCT7oI5ia7B^gX`47F|F*UKNjMZShks-s)mpT*4^j zg%AkPSJVr)Z%(qh6G;R;7{t4A!@6(2;i-)K>EH2avY*CfA3xgB-(AFhn%4Y_ZJR_Q zUH0*LyxJc6nA}4*uoru1(w!Z{8HMK9%Pn-xw>*dGStY{Gd15feZ7J9n9+(Peb z$UdAxLOKpPDvCCLC24W+ddsg<$^YnKd;Zg^L0;P-moIqs28q2_pOp{gdn>k%T}r_FN~C;| zfE%t^>sZZcWQk|eGhTUYh(!;>AzO5ZJbzpeFo!Y3uTFh#tjVyRtdqmq#$FEVTK25? z9C2rHBhX=wx5E*9`4H~lYo-hD&NfUt9Y@jQ;l|5@I@Ikcf069RitP~%C)c3^ zOrv)_sUH1X+p65`{B$yp9`|KV3rO?ak7tnXM6uG>5qCCt5xqZ=_>gm~I1zp7oE^7Q zOpbNv4|c3@78&I+Tr`$=6ZWlMI6%ygCkk1ok4f9sA&8b6S0S!1QX5;kj(9AD*NV{v z`>gyGyBwW^9UFZMBU)UijuvHllTp%=DbkWDrk2c9Evdw3VCq$usU^=ZNlUIF+QgEx zBDK+yL*lWTCE2!BmRMTAR_1gcSNsbMpLLvt0Wr2VUmr}CC32X>%prrFw8>mI*Cjf^;^%TznwTtCrTXqz zl}cg0!A}}bzAAb6V6Fat7p0qSVo|dEzy{5Ny?;MTH|&?iHkLLLaXxJ5$Hcj(>igPA zXVUy{Ynja>&+sU_A8#iO(#lB_o)x3m*QTl`(3d%UK>3=fuWPQ}QfM&tu0PGxTfe8i zk%@Y%U-A84nn`oH3h#-fq^h}Q!e?khV{>^MT`W4ouPbD8eI-wWqPb=Sisq{QGZqnC zR*kH{PCxH|q@zcQn~5$=UQ6;Fxfk9vWcKsO2^!|iF3%%ZXnj|)7R% zX^(AKhuO`?lD-nk3`_b*p;#Dnx-N^HPbO35Bqkbmb3VRWX(=D*(SKQ&1-NLt=qMuT zp?~E`BlfM&)AD35-O*fe5uJU$E1)VS;!f+klgnQSt8a~V?)mtkJSp!2NeigOF@GFZxRc67xTTz>ZEGG?Vfd$*Og7`#OiSxecS^Dc6^5z@fEY$UV zBf1by`}{mB`zn|B!`rqrzIZjG{Vb~6;e_9Mnb`3uOwg^fF}Gu#jj)5PV>?$6-*74} zxJ=E+EipCY&;K^Vhmm9w$oz)#bMgh^m>Zl-22r{$fBB>0T%scnoS25q#qio}R2u0;pV#8_XP44Q5Upp!-lUPZo_lZMN5J?k zA2x%9x-nD~&;M?l`ge^m!#JY268`G12>)0u=jk1SuDo)HE#^Z0kJZdu?2FGyv(c+W ze!dimT}$uEO4Now7V1W8c=fSZr?>=|7TFeQp7d0wHACW1B(D0Eg1XE!t7NAh5f`6x zZ=n?$PrL)s9Hy^ecfMt5*3_9LtRsOo%WsMonsy6svQ6tqBa0s>W#`rrfA45+i?BF-#uLV_K3|0@gIfkJg#|7F|OqrFxuq`OUYiPRoh!nOO^RPy-= zZ)!A@S*}MRHb$+YkfSEP(7u(041dcetw$l#|B;1EKw-Ku|L{Vl+1T8W`sod!zgGUg zLjRR_tP2eEzQk)^Rfh$}$3k6~f2De_f7!Pipg!bpsXhqB=otMYRQ_$BMaam$v z`%fj)M&PpL;$LjhkNCPG)oRgO_W4GfpC=n7qu+6f3$tdVB|kQ)2|HFw@f0rp=1uNq zMrKkU8~kNA{PBkM`TQ?9r1C+SYW2nz-3kpCSdrWGOX5Nzx7L<|sr(J1_%mWwgM|q9 zBUXz==o~`wBEi(tZ6B*MLc`h1>iS-A`o4^L%RoBjM1`PF8OjVxpT zD|TuVaq$g)C7t2_N2PeXSY+CL>|U`hFL3g<-%J8(ZTU+S=lciiu$gpp$h>VbPf5fyLm6UHn9x%f5jc^A-0I@+GaAA4lie<91iQdg$$spZn2Clqz{d_#hz~=Bk7%+ ztnXIb9Id;_@&l;{+rJg(opvwS%RqGBJ6q8>Yo4>L2iUCpWnhvTp*{@Cz)AOu683op zajmyVbivqD{7(uLKWTxH7{$k^-Q*H>3h{#nn8X*Q@qyY?NSx$&7DKlqBpA>4FrLeh zLJsmEnUVkKci{!D(Lo3tt!kFACfl$ee*28YZ6m#gPkGLLgrC%4KPlSwQ8^cgJ6T+< ziVa>M_qh45v$AEjba54EywjbgO7TmQfj2g8Cyg!JVhpfTwWt^SU^}U8X{$auGanmj zZTFbp(eob%r@Fkn&K7MaVYNQv#iw*kxXw;&Ck>i82#t7CSoIU)V^4&|nY<%Lz7XLI z9?p5j?7t>Wn)MVK@NGV~SXN-YsFVC{@?0546#h!xV>ap$@$Zs{QmSUF)F`2^!83DV zI?v&Q+@>jonhzd}dCkF}TZTmSo?@7~Jjs3bHR)qPC%(+>@Er*ww0?Q+%uF7*{XF-( z?|ERuv)ns7Nd}<}p5|(IlRQF)J!aZU(j|A^Uh*lSYjyl-UhcFk(uvTs4`tl*{bZQ6 zTf1wr`vV>6Ce-f|8(2VwTE$+36|9Rdb=&wO);E5k&F&YF?lo_ouf$b)8VhMaTyndeCAA41 zd!EId!~C_lh$WpP|5`39L|M4R@?=TPh!fjYNE%v(2w4j8%zaTvR>L9t*n;zE;^Zu$#V#?2tHBC zx{Svdk6DV(>;Epsd`ph!BKb4waP^2(eBme*pFP4lUL(UTzdwuuuKY*>*vV@o((Tl7 z#FZWs)*1JgrN@}-&txqfaoEJQKmCl4W9aY4*zFtSi9`ECQg>)B@;5ug(>XKWOT;0! zqJ&(ra&4Oh`KxTM*Z5bk>SpKua+mlK+Hx-=Wth1p?BhOnW8=z*OWowX$k7Tp3eG|7)9#n>QQ@}${Wtn)pxpE~Yk zukMjQEj;#AvQD#zAG5hnLTjx@Ud->)4zj5GWR%0t+fAnBq}}YmeKOPT-A-Ppn3k{Z zVj&O6Li+3Xd^T-K_X&FC>K_mXLT6<#$A=^|v{Q!ElK;vfPE4m&8=fXS%4C8>5=Sf7 z3^w~A4s5+LS>8i3z5nA(Zj{M9IC&Qrn9YOV?iQjflgX&n_aa-hdGJ|g?kB(FLblct zUX7HFrJLn!<|Ya;o6QQo5emd?7A=*D+2`1Id^YoK_l&AjB;49xXfvDHHgS>qR~M3G zSWHPdJLJrkj}lGiE1|o|cjiJdvjrlzX-c7Hzz)#|T!Oiku)zOYG`lx{z!8~kWu$ek z-(%9A`cxhv@9h>IL&h`R`bOO?D2JuM7hiCyy9H|@;=6@8BE)wKlYT%n@;%tj>t?k< z&DHuFzFTO>UOgjj?ry4Z0as<*GT=_7{&Q>@hT!iDaSb13$SuR&tMWxpo@*Vi4Ebw(zYIy0pPLTofV0$<0P0z@ zh}+z(1MBz-d%iC=Nt-|4441Folso4Y>2E<(b}%d^``O$#WC@M>nqfiN&-VU>2mLmN zMP)yGP=SZT84L@{xZF#Bla7S;+{&=J%*$Q&FJDF$Y!=H1!xGajxAQwL%Kj=B>kO8k zM_J@c+g10Lee2)AFAz2U>^9o;Y$y(N=%_Ht0t^9d{yV#2SqWf_G}lq%YFMM%E&Fh1d+^O2?L3Ted|?eq-d%T3AzW+H@W3XH6sNtQGvAF};7C z6}*?34E)bma)H^vzr0F_Ob7l5nXTHucUh6!w-&{~-<6CUDIG17<-qR@8=%v48}oDt z7vZ}74*!?M<56KA^C z+RR_Wr&=vv%jVm{r`?xGpFTh;GoOxw5!HN}AzfnX(`M2o)qMK<;@r>dxK9_rI{5V5 zTIo|KQHYsOPiRHC!lzxOGU0}xBxkz>FJQ)^_-MdiEqDN5F zdyZ|m$XqBK>xbN?DTSKe3#FR_xOs51R}$Rph6m~9*=vk$zMmqGVquQ7rRD7fX1<=m zFF#VP%2uFZ&2;cHK!#?04~xJdPN9~l--N}4Bqy&8s@dQd3+ zYreTq`1%z}HBBkhc+Zo&mN)ZI41E0@X6hczV;;^lnzoq7r+8=fsWa_CFK%EbovAxL zyn)?xrk&`_4a~!ZdeIRZSX&p`h_>Ir;$7hAiuG)W8?DdIxKLmFFCD5T?s@p6#)Y=E zA7UbF?Z#TW()QG2J)7wYQuWCYf7dFtH z20JXBBmFf0Q~2rAIV{DUdRvx!ZtRhTOJ$ENai=Y5+fP_+58AudJkj=6XFg%0J!ltg z*(SLjiW{gUTp^B7NBl60pWy%SX6P%WRlW4mT%JtKvS?v(%&f(mEERuJDis|@iZ;q@ z$>zt*7*$!9JU!GO&h@QF`;ofYpCEfmN9V8jh6&%5;?GvGd>!#<_92f*9g=3E*Yaa7 zk{_NXOKqY{y`9a@dD12!YvGM(^^;X@k+kL}mkQ$wb;o5`^v;(vS$!`WJnT;tWZEHx z%J|vlLR1ZZ(*n6oQwlZ9XPOGDKA2rNOLpm=vrs%TcZTu0_On=#7mcE4W-K1Gx zYOx_)yk=DY*tPH~5fSoFbt3buk8@+Z=@CK?%@kUFewiV)-bmzCHouHJGeaIMP8Q(g zcG;J5MqIkKAd&{txh6YS!r~GMyraX&j zLyJhasis2yX9UnNbrM8-INnAifBq=}t$cZ^I9|HrI`7nHa&vP8B5~9A{S@{^1KPFL zpTc0Pz0=r(2DC@R8aqv#_%~O^oru>qniKpVuKLVW)<1x{xI~Eho9%S|H-r5zfQHrY z#vR80l1kMjil5pbTtoNC{DRWQOH{{qvUzpjHr#%JA&uU4zRWqFNg2z8&B`?wKxwa)bmqC09F z3ZciCHq1|>vBDdlNqO(|lMqfn`A(k(W`dbu(Ybf}81O*hJAFP_=i)oP4jctq*Vkwc zfk9xWOYii_{29yyoB!}mUj&WJG%+Fzr&1O|cbm*455{WV%mA_9{jsNe!5bo~*} zU=WxLc_%OvOazO-tz3?u#;(5t#dzKcTI2Z@7zDPz3O(Q~Fb7NnuYr5P*WeA%IY6W7 z_0v0jSOE6&(-9a9!8-6*GmYl%?RWaOU|#7vy;pPmP#lZ^`#gYQpv`YE06g#zhJjBX zK~W2h=E19X`gpL;AMf-@p!MJH^gF;dU;!9j34_6b+4ALS{jzBaRLo4+O z;4QEmbhfP2C$`jRVy!ThfIGn~@N&&ceF>Q0RH?Vb9}ltdtkj2qgS{*DvEUZpNK_2XMXX4h|4RLCP}87Ne+j$=YM&wy5m2eO4by0Hz^35Z;7Yw;Cyk~M zTng&JKK(VCflXi_m;^e;Xf!{8As}gro;_TnaRjYLXf*A>An=!FNDn>-SA%ZNVE}ld zMWufBI8?kvrB+{ofPYA(elD7zC72HO1oOb*UBfw4IK=2s29V`Vaz_(!2_Q)Ts z(F_G6Kq0^&IgmgP2d6W z82A7z1>b^iL9YnpZwf=fh^83-(-DY+AOoBa=7F2Q67U#U0hWTn9iae>1HCXjXM+*o zdN2;m0q29if}23cPL=v=7@q#%Yj7;+jNvyIOvC6}1!jd{{9izz7=kj;5yR>g7y^cN zuGGhX(O?pW(4sqk zZUM8v3h)}(t2+t?cYs>2wi?Z81R_8hg@QppFbRwYcYq7Q0`NGf1JirJmEjn_U>IoM zvr<18Y!!|90*w8jQlA4Z=vAqI0Cw#S&$h$x1;fDDK1dIq=!5Y;8-Y>?)`J;+QA5zW zA2Nc6K+E>%H2vXXuszrv+#7?51-t~V1|NgF!A%1&vw=Q?(B@zS=-dIj0Wb_)3JwNO zfV08KAzE}69x()+4J-mn!RO#xu+C6)wg`o4}=@4%`8Tk3@b@8;8IH1TsO(NOTe~0Q4FK z1)$?-EJEO1a6Om@=7Dd)5->6zoe7)(x_3bZz;JLk7z;iG=YpYQFbcrMU>^7_SkeXK z{{jLP5WEK6yJGl^g#s`Fj0GovbHP<$I+z3Ifv)4A02~fhfLlQKZW>Ji7!K;dSkPuX z@`DLrI(Qk(1D}E=-L#m|K7s-W!a(=#7=~atmZ#G}0VBYCFb;eS&Ig^RB0m@k9s^@QZ7Bj{5qJx(2fd=< zLNEe+3dVtz;CwJ30Sdr2;4yFuSPGs4-+~vWVIukff8Yv?1VgdAjt3LLB=8?F1ALW; z&IiWL#Q1-Jz`~j6e7(>K!2s|o*c~hf$Ak8>(0f5Ya0l2QEC9!X55Q#5vNxt!FaV?< zBR?1njt86Ll$8wj2Q$HqU=et2wiYuQ0;4{`&ZQ5Q#ZR#V0`tK>;ICi;Snxmee$Zzg z+79domVilM1-Jop?~4k6;oz$Is5zJgCV>TD21plRn1c@%qFm5M3j?hCK`|Hv#(>e_ zbZ`=w1SW&q!A!6KECOdGK>>IIw8oaqauM=_<=|>CVlie!a4~oZ)PYaIYfG@GVarxy zDTXzubw?l#0o!F*B*0*>7>rzwO(-}PbR2-cxCe%S8^9RwJ1`ME0;Yivz%0;y1@ePU z!E&${=r|B<4TgYgz!>lZm^cvQ{~-ct5JV?K0XPpV2GhZEa3|O zp!E=V01N^*gVEqoa1wY6Oa}i3Gr{6Da5Y$aEnE!-gSJCaF|a8(3+w}K0u#VWFinfV z{WR1Z{1Yq&n|zL%gS|k<4>g))UIcpMonui! zFbpgJ2ZLMI!*k#TP`e3%zzrDBJOV5Q{{i2E4L4#w7^cy510%qpU>rCfoDZ%6H-T@! zW8mKmix(J~j>T&@hBfF1T7QB00MvYi;RsFumx9S(Vf^nv;7bS!z(-*82&_(<;7V{j z_!RsSw2i~mycwb=826WVJhXMrRz%=kPFbDhsyawihufcNAIUWXljkW~GgM-0~;9T%Am=4z3 zfu;Z(fu&#%@GZCy^csT+3XA|>fpMUA*f*G=5SR;QfP=opC;%6N{Qqpo{X4jREarT$ zDHsp-0at+u;8QRSypoBUgZIH=u-^BmIk*IL9EW)W3;`{6!f?u>AN(170R915euS;q9;^Z2Gq4Y+2NOV_y_gxn zLEvuiBkn7U;h!X z&V_;mbQ&-K3rK+9>Ez`y{o)?wralfm)em*7%x zH@E{l0TzH)4r`$Rf%_0xPRGgQ2WXgvcp z27|yYU^KV~oCKZ(lfkQCCfM;9@`J~;2 zdxJ&bC{PC;0l*M&|d*#2Fw8y!3SU(=z1OngFV2UIZzB<1CM~O!PlVkr&#|lptpky z!F2F4cntKph{Xw<4tAdl&tAsNITzzU{zptG5PS*dgIQo1IQI(r#Q#w9pU|m5cd$G7 z#m{ghmgt82|3@Kz{_n!P8(8SPEuZ-cmxJkG zI(Qn)1KZq#C&3s{vk3bHFaR9*D>^qg|5uFvNeGlfkOtb^M;n7#VEz*9P{1;<1jN0m z<{{_@e)s?iz+`X|xC2ZEPk@==C9nv*1?s@wzrkb6P#_orrh_ryf#0;~WC-L#kOp1` zv%t;|u^54gUk&u>bHI(@HSiT!0op!7!K*Mcg5lsCFb+%ui!mC$127q4A(AzN@nuEK+I8OBXbKoWLF8CCz1Z_XV_;2$Z7GpTXgE8PjFcI7V zrh!+%EO6)xGzmBf3_|aH1@-~s%aI;j2d06?UZRFzjaR54=nlrC^S0s7=v#fj*WfzP zc`+iK|G;Xu82fcF4x9td2Ty~Wz!LBnr~^yEO7JbX?ln3iI_EJk5_|>5g8_eH6oIqB z3~(J-hCY!AYF1#4d4mdoSHWm40-gSX%fLzCYA~n*E(62COW;uODL5CjMW@ODn}R36 zK42-B00#bz{NOxrHyHa5@`F>r`RFqP|3!ts?cgym2h^4#a20{KVDMY4|0y`JfDzzz zFb;eT&IfC}g96YUJO&1XrQmY#Etm&-t;YEQi~vI_kspi%=YtFN@CaBA=7UtD*Xqj< zsE;2rXi_okKtFI47zxe?xEMcl zngpH)lfhCj6Fh?7#T0?|_*K?Zun%av4ov_y1ugCM`aYl+m;gHB%ZxP8AIt(5g2iAO zSPp8l5O7p9nlW`?IXD}P1$E$D@EO6N@}Bz!fzE z$Kw}>72rDjaMN!CrerV@tl@1s*A$%&oCM~8_RZj0a0>VqTn~DEg}J^t zdOPS3jt7gtWH6uwY6$iNFM+4Q*I+5=ya{~_e^Nmkj=)_6;y`PBoH!qx5AFarf(2ki zD4GNu3R-W5>%ky!78niQ2NOYOeAAf*hJaaMFR&Pl1n893;G zLEs#)517^l<39m`EfA~*{{gc==eDpM^asnqg`o2`Y#hKa@LO;&Nb$AFT+j;)L2nNQ zW58%I5gY|xLf;zL4i!VXrC=VI16F_$+V-f?cC=|n)D(gwFdEMXz)9e*U?z{pU+gIc z)4QN;!M$JwSO&U(jd9);!xl^jlfZLP$OlIBf~&!SU@^E9EC+MIm>n4Zv-_b22t18J z+kj&SpeEooFavxA=7Y`y_4+a}5Y&8wf(OHuV4Wc_80-p80!xOX4}cl5=(OM=@EUjt zd=2vdoFz15-auAcM_ouFtFNPOq=L26(MBybTi@v&)g*@Gvk|D+@=otpvnnD0K`b7c z$Lw=tv+&>fZiC*!qvkb;`XSuH!o%t{!pqs;I_hhYx#u0z62ylQv>zUR{F8cE4aUP> zHtZ4gr8Rc3d5@?M{+7TOcqG%=VUC6DCSb8?msIXdF}@In@)}_XYj(5tkExGE`feyJ zryezDL%0SH4zHnoJsvXH7muM}$KH2r#!JYqLG~rP2^l%f{^oehJf6^C-#a-Pji;w= zP3tt+6a>}0eh$0e>HoyDI)frKK{Hcz7a$ylqsV&`JoArA|>(v-=l0hSqF;7Lxvw8PvJ6+EnCIu zZp(IZ2H3I-oFTUCF=x0fvv~owvXvF=j=tk>%X)EH8(X!akTr!KE<^sEoTH$J^8xg5 z?#ADT>4CBXtTAcZF`rtzk_h|RbGa*vFQ?Xlz3eOXx6xph-z~sjkF|GPPP^IFpjXkH zm>nQb2B`yEQx1iR|JT>K!1q}8fBfElzl{*4nVFf*VP=?(VP-M2W@Z?M#mvZISj<^k zhJ+-|@fJ%+k|g|vJkpZ1JRXf!NfI6*Noe5_+y8Uj-_K>+-Q&4?<@fo$ukZD}&WHQ- zTMcu&`aD#_Jgz?X)sUL2{20cI#eCd@ptsd9LvA8`V-3k{2H0v#`?)TGFBNtWzSL)N z4YRsx#VfF>j2{(sM<&%T3Dl~oxSwm2no8$T1A92+ z_hA|OSw*nQPyoAo|0Dbg!f)3wudDQ~>2g%XB!+VQ0d@xL59Bce47z$T^g`(CD2oa= zYN}r2<6Z!E*Ru6ncUUPY19n!*E_CttEkpokBH%@(LYgZ z`OtxAC8f_n$5}1qRZBT2go7RXAC%rzr95ML-F5YIZ&3p~g3ruZcVV9hz34M@km6a; zsb31ug&zB*xemPPZs>SC%$2C7M?Df8U0qcsRbGk^KBW*dWOGc$#rU#FzSIu!N2n)e z{`G};lB#?WpL)^Zz+b9RV@cUWz~;;eGwwggMJn_;3{X{?Z0M7ZOUd$}Z-L(cKLCB< zgn9Ho&}X0vXn!AiKka=zaJhi?QP6oO&4hcfPle9^+8hhrJ`uHb3r~qPLdl#{rk0gX z<*&9?K&u(1!0!4t4@%#_SahaOHUDwXwSEoN1nEB!erv(HtNwCz4mgH@lUE*;c2`~# zr&aXYQM{_9pcr<=S83P#zuT$$O{|3+SCf)wLhpfAwX+y{OEpzHUR6{rZc|~`%vpco zJ$ei&3_&CU7?*nPcDlyQ{pI_Q?RLCtwjAiwBh{ROncz!<=&z;Dyf<|^8pHy z2U6&bP_vpDS>ozf{Tx~*8Hx2#iG6Br zFLCv1?LR87El z%WuFW^Ml`AYr9|ZLNh#W&MbBHsjix677RM8gwLC4rK;q0&~+H@i`rbR!#7BH7Q%N+ zcjkyRP z+?Vi@9YhLr1b#!mnWJ6^WIL~t(p@ll*wbC#wJKIkCmE>30))>|?i~}%R@gbZ&hOk0QzcOYwO{51^T-A0<7IDqcAt>t}H>71VQ@xs0|JldFVtR*{EbdC;3QG z7ee>)k*RG9bhM8-HWG0Qpa=MX{`2q*bh?I)q)%nL5 z^Y@`Rn~1K0x{LD1AosIory8NCj5B_m5cZ5Qhn8Z-mWq~vCw#NOYO8PjezzH&}$;TG!8KR)H&5A=oSHHuo^vw zp_ef7Md;b&&L-GGkvE1evUoi=$aW1Str5^c4b3Xb%{=I_)SIBUQ6GlB-cZg7FGAn7 zwAZQthnrgrLgjzznyN5z*7naWKKV+_*>f=+ED*^P%DMV$ei#XK#9 z9#6dmIt*6CVBS5a|t-VUEiEufD!E-`=j z1zV#;e7Vxt99tWemHUO&?w4 zP=p_BDn(9)UKb=eodW%4kQ8|Z^pPMIc{jdX43Z)jLHBAVMZOE&u(=f38(WFY=E{** zYYYOTGKxCBc}eMc7fgQt9#U5K-4;7ubUIF`#aPvUI^qSjG;gB{E6syW!|y$SMiElVXvvg%4>6n9!G)$4Es?cW=DIX>v7rv8 z+(dw&R@UX2R+-Sgtx8HeA^nFlBkGm16IJBI{B7l3La>1t< z`Z|93S4}dWYGnzN(H9O~5-OuF8Tv*js~Y+i^$KV>wl+4qq34EKb8`{o_Au2NUgkMf zf?|N8Fmt;%I-7SZ!+7rpvpRaGdj#~^AIuP?Q=n5@n`w`s(?Bk4ZMCNRYUu6w`DA6X z54yOuxH$uzK{xlI*V2t|C^}XfDNYphk~UTm0#l)9w~-a?Va2)rYSo;YD6$cr9Bvgo zFb}$KcuA=jI>19)$K%!}OxYelczj!_jx*2+)c2u#w3RCJ4a0LE)KSo_s8gXEwv{oJ z4c&q|54s)vs4FxFpu?%pK(}Vx`_PTs$}HpCTG?}!iNcq-wld44LicJb6LU6nZd<90 zJm`%&0qFIXQ!n#IO^37kHq_vFU7b%J7Ll5gHiJyb+*U?Jc&4|F-YlhWz)Ul@B8>rKajwPk1Q9sTP z`j)k~s-t6Nbrg?iK2dVAodF#fW%{+ja=8$CcvMO0^z!xVI^K$?`pOoB?-yJ50_fY~ z!|e*Ri#f~}Ra?0Oo**=L*2Vcr5ag{WS*+rr?+VU}~Tq$s!aAy&_spQj(xgN6Va&1$`!3RhSG<_gsME(dNNM zSZQ`cd*Cy47?AC#RT`Nc^PIzS%s;0V;)2JW;LDZaK{E~I`aoo z@65bT?-9`BPL}tc0x}41Q9jE141_;}@c-srRr_j$kBFA$+6SE#ZMA;jDd_ppcytIh z4~Mqv2UfQIf$k#QuZ!v41YOxT3O8}ONH>jw-qb}l%c;;CyO{b$gVQ}5;6NAY!+Fr( zG139(Z>i5f7j=;_e;@i-7s;G@a|iZn8&*lZy>qk+XIJ$K&uOHhZf&U7crMZ?5Bghe zbO2v2(dZ2H4I15tzMzeKv25R>Q55ujTz2UMuc^@eV`PM6LwAdjvgScQ6=PlvR6`Yd zIQ1Fm9P0bfd9?TKjH@xCTSY;yjwvbaQK5cg9@cLQ6#X#5apq?@U+ZBGeSnj<*@*NB zovnxdSahX)=mRk&X1!mry*Y<3MKMwzMl@FN81rm12%CE7uA(ayK*w}tYFF@OP*+KD|FpBX}~<_s&SlOp&Q1@HuDVhILn5k`aZyrICFe+)R%u( zEOZFOE-Ww_ItDLRW05W!ub2cg(00B+=?I@+-qCD;8FaJ>`Vbu*hQ5I}w*Q+We>l2` z@Quh_5He6X7B||vnFCs2ifI9z-A$h~;LDnB=9(6$$4uzs-OT;aHBwPe*SqN!jguDL z0fS$8`XW#ximQi{dT;0wvCvWG*RzXt)hu~zv{hsv(o^WK)w-grYUR4JS$C0 zu94&e_W`etFDc!O8Y-KZ-mnIas{T_5_vGPUQKw>&}-mX4e)g6!`)?o&x5X%AnVm8 z=*kIdUyA#^aSms&dflsTLP=@=@>Qso@orWvTG!sMz$SqXDkosJDCfXE2p~1VoYork zk_f#d!Ca$s7WCBwsry{$KjA>_k9I)+L0t%aE5X_mxZi*d=^bVK|6bh&s=C%+V2n@qT&`p-%k*qH=wUG-I|HG`j=oH3`c%Kq1*S6D|kuJtF(XU zh4h&#+VZ&rdM<4Wp{FnpH=rl=5T7-BVm_wNP-x#o$wLx!b?Pi=gE|-bRuAcTJD`8I z{IlZ~0({p)`b05wP@;@*&t9l_>Tu{>I8%jA7HwsA3iKi-vI06gQ7UXV^vp!L@mvHw zhBn2}gQ-1xqm$Dn9QsM}Waw7ZQ=l6rN}*RkKbt5Oxf}Wz;;KtyMbM{32NpwLPQNQKtFGuXzr+ECjEk&G`sPA zd{679L=og>C1pogjIU>V%9SneJ}5~qxv~`j-Kkf(v7Z7E+Di81i+^s}0ke*Y`CBSa!&|}Rmz0ob# z2jYBtHohxLSLvsCL)UiJC+{YMqe87B+<@LYMQzG`s-HuJHtdJzgB|D=ZpGLXPeK=h9A-rQbhk>U6f>R$I;V#0LmXF{)2-m3oM}!E3UoIaZ1>oEN z5n%?xw@i}l=W6I%ljM<`eb84Yspj&k<&V;AL6cpbR8ra=+S$kq>FV%uzYm*|NpkbV zcQA(DWSQlopxq}+k4}ZIHrd?T)#3A4Hnb0_Z=QKR*5TRR7IvTpGcRr(2O+P$^W%@sbUY!K6HdP{JK`%;`NV&qTNc*6# zmXCA>;He=J={|J$5Q*eF#Nt+@Sm+f)%B7S6@H-WGNHrM%;Uq6uzDqRPn!5vucco9AHLP=s(0!8K6LC*@#mY4+8HYT zqM`GLioX%icZWVYuk#S@nl5?W2Hh)N{2haiPZxhTppT}DKhI&XANFW};RvrbO#G== zUsHyOzijBf!_2cIP+s*0?4T^UHlGijlx0>=zyhh>>7AB^*~C!80kvChfpnc**0C!O z$D)`e%SaIPkt}P1j)%OJCF^bmwBJN!QqK+2bE0gIwm>^4${be!eJ{%lNkNXTL64m% zJMU`GU{5enmh~3Ui>&^F2TY*zCYoz{sMdo%Hc?u2G4vI*LLcyL&==4OdUA6=22e;4 zii<|>*8mO4~OLPNzUuM^h-Lxiq^^ zpF8;d>QHn4Xh$Oztqna!_e65{0bYC)_M zy&cYwJk;F!@g=1nsNT`7NyXl=p{#clBVy15b%Dn##2>bvqp_EpfR}fmEA%Md((?t5 zfX&efs{QLVfh>Y~etC1(y_SDvIs@TTvZOn$h8~e6-C!T|@GSKlEiM}ix1Nr;3!OX5@HN-7JXlc~2r$4!(o)dJ|b zGQtC|K(9bDUCJj@?y*IE3qIKfHQw;q(x#tAKIB#ir4$+Ca zC_*{kcSSj!=AwZ}D;+ldr%8LxhK`>mmuS~Rk0j5BPMKy_PeFOlL2sHSGrThkbvWIs zlfcH%e$yX)cPkd*anr55yN!TOHDB+6TNCpjUzx6wmpwt>O#m;zPg42*qIMy2wb#1b zqFx{03Y(DfHry+yy4;6)-iPo=Xy-_?)6)*Go@c<0gN;*t>8W~UZLD_HL&{DR!zW^( zJ@@ExBqO|od9$mdUXLk|EnxcJW)PK)6$rnIaGW=kC1>4tca2s3O3i%xVB<5BC%>og zC1PgTEr7tg0DWhcl)ivWKb&SAQ>@&o*xr+{5qjS0#O@K$Tb?)P4??4+LeI#SM$LvE zn=Jz~4|+5C0qE7x*f*R0gB{M6+t9MBvr9^Ms^0Np-LeD|tVadbsWT6isBVJqH_(b{hoq_mr0g=KjGBzh1d8IStmSyo+)V z0nA36y9nQ<;+*p?OGfpHO;$>VKf+GI&)nJS8lIOKmFlSMejniCTe6|?MFvk(M?n`_ zTGqgv7N}(Z*?0$7^^C3+Q*d~d^^AFl=sV}pJ!2EXV-X&W`g>Rzj`r3GTVo*A9Y(xZ zQrgmibgtLYHfEzC4iEQhh&*<_oa|Pcij`-+ob0xMUPqn?z0cxa=8hrQUt|KDoG)j# zxzHul>NV-$1;S5353sb48J&jbG>)O&=PuxB>;*4#bhINNShZ{DH0;Y3J-U2J2;a3x zJ$d015{=5;2irrcugvn&WqI6Pji%jJk*)5%8gcr*TDEr!+y@Z->Z8viPa*uB@)7O= ztok1jyr<);bNL7n0N4IUgcOALTT+&#kQo3mOa6P7f>19RXqrXq`TXE?^ZHN>u)~P+ z!V;ePL1!-EsoxBXTjy3SppPvncS4o~(DXH)`ayf)$MDtpVyEua%2*2H*rE z-G|O+B;V&OZbeeR?ckqVE>Z@-^SP4JLg=x%lF}C8R-{7cqgEt8_hRTKOXXz5dnWGW zEPeFJNCd)1FO`##bm(16PDb&R;J6oY`pd72+=ldgh8p`-?~T zycOav3mSh0#5&o`g+97MPQG?SC$5y8U=eiO%Ci3DUJMXUV4VeczJLo!E9ER83VIy= z@Q6BHu}&^h0kT)h$wfBw47$yOo>boL0f6-KZqESpqFeQ28D@F6jRCgMZ7lRAx*Y+% zuDsiM0E^4J-2^a`ZjV8KR^IJ3fFioBmV?Tn+ZNDA%ezek*jL_dCctL8T><@jdAGX( zj8#$zMbLj)F@4;Np?_IvwVS*5Y}Dc^sq+YE-&L|fPl2woN^G*BV`!5H9Yvc1(807h z2R)oN>Zd+ZY2y!_K$}?TxwIJpy~~u#xbvV7o93b@?2926tt~sXs=fkMv)jb4dl;A^ zT}_{{xX*Y1%yTuD0K7C`J^F~pcD|^Q zns3shYt@RAdjp5H=BfoP7It16OG>9YQ9^g~=s3(}c}QXAW+}`8=*62^m^1iNw9UHG z>wX_P_+FPY8#ds_yAC#r&iApYh7mvlb!VZ4|EE6ea z&ciP3eO@+zhGXk|ahq^!XQ>`g49P=ezxPW@_p8V~Y>B*Ewq_M0;*JljB7}Ipggek5 zJo;9F6LotM;j3KW)74z0uJfiMPV`Q>&O00W;x4%=vmW~NF1b#U4_&y+tUlf`%H_T} zb-bg`-lO9k^Xr)See+Z^X})7il~r${ig9FZGChJ^=U3TMAm1w=Ro@4gR~9(7RP||t zgmEOcaoG#n#Kp{i*-^P_WJ|%BEs38Zgt>7xT7OwBo zD3-*+_-El#aS*BA@x_t((9(U05DVj<^|Z{R<#BE4TCjL;aIWLFOVuhaXagMh<8>J|%#;kON zR2}u0cv}6~qdX}F&RO}%Zc2Bb&7oJqb?7JGCR{P5LqrR3W zH1Cer9SdEP1NKI)am2a1B<`KF-cg#6legch9K$*xf}9to>Z^v)?UwKe`7qkF7M`Ck zK-;e-&#~FZwGsOPm&N`R{p=wRxnhAFLkBbumk92^RE+Qj`C0Ps>FD3&`>qPmyh&T} zv+P&l!)TvLUQ9m2;+Vw#j{$pGf_{vU&`umx`9pv%v1fbX5#-u_EBPxn`^l(6Riht~ zSEv6{#d8o)z<_29nA<@j+$6UiDMQ%UNa5z6VyGScNxqp}`G;X%GI;OPw;dl;av8Jtu@c7@zAjDnp73#&dJdZ$ zE%_?pG=loHj(5l-mP*D@Z`N^!d=j~~_vj*iw%P3C%&<^ro$gr(R;3M^Sh2KUk~gz) zzZkI(w(%L}Qn;&ooWU(@!9nJy2+o<+Rbq$Of=`jRvhk2uu@ANJ*T}J#y-^(LgkL0YOs*5YN8X=YCp@Z;_&G+N zgCB0Pj!O)%w^?XkiO}P%iV1HZA4IMb_U~B^#>^bJ}Cb(>2x(2&>aD)s%J8S5BW0k z737=AYY!CrNUlY?02{zn0ovIz`YU;R;W;pp&3Em^mC)Xut^R$%U26vdc z0O{bW0O8iJOW=Yk{ck1jMJ@$sgKHCmBtkI*bP4u@s}e-mO5ik?w!`c_V6a3>+9D;; z`Be`BSQSXF^P332s>aXR^7|aPvcFDyo!`&ME59rLb%l2uV%Y~9+Zmwq`!xboej{!9 zt#9^ekNi$ZlXR+Vt(e~*$-~KYen$?K{1)2sy9`|AcMI)xe$S8}BG>s%Pq*xIjEwgr zVI5(s1Q>J4^$PPFd9IDe50iw~kxyj9ZX>U;P5kSz*m$_uM_U{Ny&fZ|d(^4~sf?gA z^auGga-E^}&xrjz8(&Voj9h0({V5>j-|>FA3?Y4E;s^-{XMoPoZSo{?ouMux#eOWg z&d^KbGi>}k`FwJnp}0|;=s8!`h4Osu;@;3v1Wdxm}$Hzzn-w!HgXc>8Xa-HyX@~6o4Sa^P{_}NIVCOYf* zi~$F1j{L_-grhb`+sOlWNQQJx+#!!9*BMI2T{Tssy~uTjE~GPHtIbh!+=@~W4%-|p zBtL0$xc$=Tb*_4NsRPj_~1cDVTOozqqAz(cYm-GqNjx_U=FntUF4BwKg``9Yig59D`k z_O;FPDcFI>qKByb$Io)L97$q$)R4Tpjo&9vu<^lWm#47<-!n0{$}$otxO+EmNltTYHa@Xzr@^?=qFrLfooSx3uh z!q5IHTz9d>lQ!Ps zIq~z@Zx#J7Cik{D2BuEn2L{+3#m*E*4S%j!L+_KnX-nYo=f!?Ix%Qt*Ucrx=7(PdU z+JW!0?Z9s{g1xF^vn7GH*Cj)GKl%}QEV-W6!f`cTHNjMJ)Vy_U0=IVH*BHQA%22-y zY_*xK38s^e`@Leqzmd-**9nh-L*?f^a-HyL@`g8TJMf{iC4#g~S<`GM-*BU1!j0#M z{SI=S@Otv|um*?0Imvhcal_14d zf~IDdq3Zg{Vu^N!(R6-qlDpp#cRIhbUX}dj+VZ;tT;+Er?R9=j$ybo;3SYRyvJW;Q z?^euj-Pa_)gKYWDFkRA--%k*%(pkl5I=`)Rh3Av&{C)ziddO^Bes9t~{6CVs&ae8x zW#zvYxz6vG!gGvbTLkZA5~2D%aimw6baG!C&nFKipU58AY`OSZORmS_X7Xbe$B3)P z2(4B~ge#1oOOQkE`d7sa6_D4o@n$Qi5$~}|BIGkbXJ{??8FHPW zU&(Ki>lz9-#gFrT#f+{buSKpiR0?iQ^e-|%SJ4Zr#nEnZouNvv3oj(s85&4_m0V|N zJ^5W5cUdET+#lF>;NuuD{ehG~XXqF5E#x{wlh=x)&&YMcMdT;Q_3Se$PwYcV#Q(z` z`2R5=o&nlX?KdRC0CMeU3;C{xj-(UaCO>BLld?|yoVNM-HJt(NN_CFJQHM7rLK3;o z&|2~|a-E@&^nWU16=DHHEp}H%d|h-Kzv7#XeCdK%PBV_-XRG?}+~$RTUqH-->5I1_Ej! z;Y{9P#lmkLFEGM!R(JsU0rG8rl7McAKk29Dzr;}c4>UjZajWCjd<&9Ue$(}dw&_r+ zq@Hf#z?+UgCg1#+a9uMcI_5~PcO~X7^doiDX3S9XsAlKdZ6nO>zHU`U4yA2G zjHIcnJDWVEw(tz5`5`&(JzGRiUSE)B^b`AF+W!h}bqSa1W>|f#onr69l)8hf!7$HXig27f zL+rhb6(=Raj||A$q010w2KZrO*$JR}P6V@{b2xsd@TBVEAVrsrys(FGJrP|XKk~J3 zJ&QKoC4Q=XDZCN=JTE-Q*wsz~xF0pnGC~Q*@c>5f`#*8?_EfRgRWpoy)m<^HLHl{+ zbKS*W_lDoWRh7;EN*U(h_XQr47?1Ck1fuwGLn}IJ3a%pP2REXns*NPt*E}c*;5^?t z27f4i#xAIs(RaybWDD=Ftg*ZpVS6OP?=11d5|}3%poQK=uu9+eoWxU)L8;>lM$?af zcnLQCP2Q|c-%!?912aeZ1qN7~1d2Tm8R=Z;0-sO05;xO%wlP+HA~Zl|Fl~($=R7Yd2GIT-c?1_N&3o?`Kla6GAvh+1n1_$< zc+-)|2(`GFHYNWz`O7mT;i=@&=9~b``Mv+aQszvBQaR7yOswnV4f0DJE9Sh$0kQAN zsYiFtcyj%iiymEr$PfOX_<4>QnFY=|&v^q{O>s9CNrQ8RH{NC3WG>+zjC+whw5j;i zvyt;-$(wza`UiQ|Sh0_wpL@b<8FQOSKr;r!nkO2fKTba={@%`zU|rUa$bCl$Z^vj? z$e&|J)OFeF6Y+C*sMvR+{Z{fA&KOA1DAXV;OLa0Y@rJgs$Yb$?bD$pF@)HzPV!GfcCGD z=l(;uo&etXOzanNhRIa+mGOV0!@8sPfl?i{qivmiiQHgawPsRVRZQ4ta+1sEWU`O; zH4jM^bfbEHF8&us34fV>770%?W-`xuY%e+@5%6H1WvUy)BoBT}xUSr<$=A3F_hkZq zfXiar#hlm#-LBskl5_h`BLiI3z_i!IfgWPhXs@3tOqXEeP1@TxwAaWzKNQ0;%*aax zmj5(k*ANNNIe%XQjLV~h>ngiRzO%pZ@91d2my%KY!nO)r=GFozYiihXdr*eB9{82Nza!UM_Y3y(8u7fL`9 z1G=6NM}gcwwkF>~Uc%z*j9v$qou|u5iFtI2c>IAeL&z^S6s}`-C$~?2i@;U0E_zw) z+tSZw+IO|pu;Xhh-8kcrzeLDkgeC}3j&I!gO67!8@Vi^X6IwB>eF%?|(m*cGeapZ4(D{F9Q zuFR9s|l+W6#{0Ehno|dBfp&x ztkMbPCbkxXw~@zl|1gdG3-U#5m2u?0r^L^E&c1pA=uckwkz`9({ygDkr50`;Id9SE zsGk_=Ot^k8PCdDS&`wjxr*c-&UGE+8q9{+yEc*pBFT@Dr_)hm@_&O{L!++Sk9Y+FcL(!%9f}4<74v*cbi5u2Rwa#L$Lq}S z&&g+TmGma>dRFX5tr5_Sd@A{Mb}-$x1>`YoswT9*FFeg?mnkI*W40dubYp*xSXBjS5 zG+n3e7bG=rjyv7k{K%a=A?(21rIWYd2BstVI^l6fqMIbpfB}~n!ILwvUe?awIXMQF*(Du_WiXZzmw|(SCIKSy$ zb4z%Pv1z6_(g8s~i=%}7!skeijlq|M+fV#nG*5(~Nwy+b%@_rIQ9^HWK4-L=p5ks4 z-BrIV?(oWmMRW@{B)>2~>~;A@lDFe-^=0}wB|OJyVQZ46S0sUvJQ>s#m`Wc0k|fZQ zj@~9;7bILa;qT=3ld-YCr~>O_`90SvIeUOqTlSqJE_Cn}^23Q0%hc+s*k52(>m>J( zuVImN7Jnl@z;4-`sr&qD`9U3gTrq*E5@4h?6Rsz__sFl07p~j>Ci#>D!rL-|ZRozL zV4>_Qx>4?s7g!msQC1M{oKP|rH zwKZKM9yeGc^jMD`Tas_&K1ojy&w$J1y7i&DrBzPdo8m2ymv?kNI*|K4Bl!zpD({k? znk(E|4H0&Nd~Vx{_ML8t|E+apur;KgXTXt`x{#IgI&JK85o!S(idQSZ(`Mj0l zOn2TZ^m8^}?30<+ravSP)9MN57_nZSK?lh({1-|wYED`SZ6dpjnfP9dP@c!iQ zkk6bXoa?RePjc_)g^#9v(4XQzZKvXmteUWbVi^#{%~dQT3^Tj5$4oba!6&&U>cQ|4 zx&2gV-EB$dwv`Tk?~v}kAdkE&pegweZeg^B;|8($|7=@&R0>^srfA-b4{{-e$0aCm}k)i{$U8h`V+ydCWaY#_LJpcjUv^ z3a%EZ!ZiZs$Z#+|qy5^fihdelbmKy!xuAoahg)lWvFar!6-w31mR(}rkI6o3nR^)P zM~dI-gZ*LbwtAsL9p^V{0WIhE8`$}W6uA>B$jcSJl84q4al2dH?RC0 zZYg{Y`HSQi7YL6c|3Y|(G0Jv5=sW_{`NwQF;p2>O3*4%zy6wOUC{ftY z46cHlsw0UG+>v8d5o`EL>Oyi{P>RC-xwkn7A2~y5<=iI02Wd48TqXKdKk?d){3CMv zb<;n{m-QEWT~A?HsFk0M(}cIBpGCsG4EwtEGXkt~ySSNMojEwdMFl> zkKzywq37C_#r^>Lx;n6%vW}+Y_I>XlaMb`IPselfuI{rtM7jl^db8u6N0S_3k^>qR9Ee5EnHC;smD8pg3&ovbZ%M-Ff-@>r%b{HDbzU;a?I)`nz*QdaEtWKq zfOYJqeJ)$2GyS)&uDXMddAYNjN6+r~q7qABCiJ%TbMo*4@m7bCkKwYIvOg3j{0Z_B zaI1hLo7WVJY+hW|<0OxK4~D%ud>Qiq`RQ+kr;-=qBCJYj%UIz$XHIlJE2W&KP|D); zWU)wQ%vAC`u86zH=aI`(9%T=Cd`)g&%`cFTm?Qr6xa@?P73t;}H=dDz=1f3Mxhg}2 zp%t_ICb^SM(}(sq$zQackS5{8PWj2>BIZr|_sDC`RsONP(j|7*mI%{&OTs~n(A>P) z1-BZ9BG{_3p37*c->KIFZyR~=z=}ElH+h7uF)MlLM(6>h@_HdrV&bcH%p$LCyJ-9w z`Q4^ssJCu6!BsCl%l)+aSqXLEjS9}wfboK-@_-WX(hbj9V4*AcF6 zXzE{T&~^B>6`XUCZoOH>x|iN3-^5i?pC`8WmTaV8LQscpLiMbRD!zS^-%tMJ(_-(( z+y&IN?Bk5n*ea@{hI|;EB)|x2ClU0?_y^>HvxVzU_-}BlP3!ykNEW7H@+|MMAGi#Z z>9mNpb>wa2K`m{*$?cn{t~k$7h1I`@p?gmfc`{dioyT0^IYxFDNnj8Q`#B>7HWsc| zwoBk@rP|J|LM7VYqa^0s*R*U0NYPcbcn= zFo^SiIPL!;uRL86*3GESV^mGpFP(eexk(Ka;P<;;s%|S1Eqt@nu^Z zZ6NO(DfXl3=P&ZmLBer~$vRT-6asvj)8pJcT%I*2#^Fxg`(P@!n{m>h4qb{vV2MpMnDUNhA4QV79^5P?C#kBvDJYIQm_d=pNi z)R7<`#wv3A{qRlX)sBmwakRfm9{r4P-9Ce`8X%8@4Bv4QpzH5L2{6)a8M>qS$725h z6L3XWR)w`+hKn~(bjL$X4y<`LE%UsNevt4XMyH(RxKma3?EA__-?b;57ntZ@xxef123qvbMl_Ahq!vl=3)}8R<-q zE6D8^6AzN_IxQaGqkU&g+{#Za&OlAc`;psEWn#v;82(26H2nM#&u$rEBqPjxS`yG5 zbUXRtF~W5b-CIe*%lZk|MN9;@iWrtni)vq0^mvOr26K%%^u;(lA(Ds-1HG`vQzf!L z95IS~$l!_@`3l^6+@k&;v>4G>EatLkkB8}6?*OHImvWDwH`y`d_9rL?k?+7Y7j?9d z4`U+vVb;2y^iv|mHkp*%1gNFrJ^N~L?TQgh|u%FU42luxg6nKgjAqymGloZjJPi|jq*MeIe zpzepXus`En%k=1tEAioNCFx?!MCxcp$1jpcv9fg+R~I!^Z`p&gs6)?b5!gv8Zr{b- z1DDa=u)SC;=AK)7><+G)&;H!jK-$}Hf4)kd$dg5Vo<9cFta9MvE;*~sl6)gP&G;0< zTpc=Lwd|+}S8WkClg}Sj(f(KRm>}T+OrSQVcPZi+DCJQW?6UQG0r~ppC8plWo+JOZ zi*UU`tkF^YOp6z;Hwx>>v#=hiLr?#QgohZl2TOon>8fLHRvEHCt~Ul;vb;(uSZu!{ zF}tx)A2a5(eBrv%COjz~tIZbfL;E%0%8&hw>V4YV9}~~)Wci6PHe%4JL(i@6N`PU% zrTZ&+iY-IKO^?2~thKDO@e5yn9%jCDbgioe@d-a(wQw)vUM&ew7kJcB32iD>90sKtA@ZbH=qlbwUforA8;NLqM!xM!;ko3I zUB!=m7dMSOuCLhZrdlt&mf_P&0s`ph33FIKY}7}@x)>X9{^QRpb(IPAC;8PeT>d>3ju>wD6$r4h=C)I-oNtsu`BM1ug`P`qiW6hn9C5Dq z3L!lt^Y%4<47vSri=E_YKZu`BR*^BP5-mSDhW%<MsDOBO*zn+Fy8EO}-ghKXvG&?vmel zOt_w@TJ(`RxyP4c0ONS+xid>Hv1 za{JZa$(XlP73}#??Az0RLOzQWXM`ci;z&=lUGQBcuyu@ZJ>=db z-!w|NzU=%x`L+7O^-yer*+lticu4VqW%oi_4Um8%^Cg0wRwk0;mszbc=_&Cg^0TSJ zr?bQ#gG-w`F!`yZs<5r}C=MqN%$Aq|jQJ7ymCuFix(ZAYKlV#a?a4Dafkn{I4B;V0 zHzuI_ZxI62o_6-aihJ6#;8vEye4dtWUInXg`SgY1DJixmsSVh%0*OqW#DMpx@2 zr~eS~vw40Q?I!BT-CidTAWmHFNdQBi-VF=efe++plYEd1U?-U;Lx4lZk zp^||8L6&9U))|W1b||Ze-G8QSqsro3_xiucdz}#;z)S|Di|^Su2UdrkNBWt4hM-Dv ztdE?xX_dZ9taP(|LvCO1>J1aG-uuK}cjOksg;z&W)uDGc+2j|T!gUp%1rIPhf{n_v zW!|l7MKg@w7@_g3iWv$uJ<^cvXRVK%mCs0WlfD)!eG|oN1kVxqb8Y%;IRISsAp82! zmb_A=_|XgC>)@(C>0cjKzvr!vPb_8&)^0bFRb*R}CXf#gleF~7=63S= zwh~_=&!{B!dbiLY^D4@cV^p{Uip-6Y0Au~>iiIg8_u(nxM5`$HeR*(I$fL^y=n1(R z7A93$K}=W=x0k?`eby#rpHsFMH5noFSxNW@CUAiKP;=qK$iE}M+FH1-Ij;;!_&CRp z?y}3sE8Ow&hqG-An2X`B4t?M82XLA3@6uw2i&*Hhfx1|~b$H2#@z_{4(l65_f*x2sB*4(WbFCwcBtIJ<_Il%ag?tZ|B6a9%!_nhh z@HjTEnb>CVp5Urrvc#d0bi!{TK(*d@+vamWBkcNI642ZJ)|ukSew`-^-0C&^rKo@M zy3k76pW%fnYZ6tPp${0)XNDx8$Jk@&Ey__f7D?ZiZwanSV84$!g53V#+eziedT6+m z786$H|&#knKM42az{fw5t z88}#yF+QHCtKlywm4k);5~Q~bUXz5EpvBdpcPE3$^D!*dp{s2z`JGC_^(Dz2Y`9nD%GL?VFpr=x8e8 zlP$#F+E5^Uqca26VjrgtU8VEM2UHb4$O^?1s^s=d;y%+Q0sBLb%gMj>5kI;|7l7AQ zIdbQG)PV{7iU1iT4;XdTml9P^K$#exs=qa6t?IYjUjbJhR}_l9?oBJ76K+4*{D$0q z^CftuWuIo)ANQUp0mcPRt$GrF{&~qz!dfXqB6qke!BvLruOSyHdo>RX`-2vzs!5hR zvl6OgOU%e-!gcdbCLb_cxW3c%Px29{0(I!~a(A=KXf=SbMyMJ)v`zfKBUZ)&E4b$; z2v+&D-zW{hI*+^?Q+-OJx2pK(tN^+fgwxiL`e z^~B_uYx&2iEoU;_A=LAMD&atOu|`a|h}{0@@D+0Vt<|0{N|ot9*`ZI7M}RB;vbIhz z486FXVZdHYEb7oD3z#Pn7WxU-ePc0sfAj@)==tOTx&8IjFTrKFU#G?Jmn5d%R|Mm` z%37`F!ecGJhS8Ng$yK;M#20&eBl=&g*)WKI3_&jZ*q^%)i(;>p#3c_11ssxV-ah$Z7h_kjdov2rgVevCbvIpbxOy~sq~7(d~J<5olM_P zlG`tMPb9a$*mQ?Hc(mj|_jT{ZGRERL1oatEGjQZMhnHE(uClawRWj6fggDyA42>nX zU;FqDT-Ce%QN^pY-@~1=p2iz45&!8QEB{y=KVSkaUz318F&5OJ)=hQ1N*)&?T({P5 zOEnT#&q19JQ2{tn9}TjRN% zZeXQ?KXxxX$C$fQ67Ix+_ZVT$$%^G`yFwh@Xe?aMc5jlWHxaJqn%~H`+1BsDE5(ne z)dM=KmlNbz!+@&TxT`}ClHK5{0`=cz(iM0FTvjrlRnms}mWsH?58Z*1v|) zo7}$J8AV==In$^8cr!5zPvpOfVAV_Q53#Icw3A!_bf?QVCnB25Pu54yZCI%q%;F!> zik3VXm0lOG`fp|Fop>{FRZX7_5JNpkUm>^O$h<;+YoyrgeQd}Y>$KPWVj|u%Z;LO= zX;P9H={g%k-tG(Gy5#5Aiv3?hD%!{72|w_SaDBc}{|({x*98U(&oS)Jx|xhn#9Zq~ z8Vbl)cuE3?*>nxoNdkkq2@fDoC%69q+3VoCka#~0Yn$6A3R%0}KN%^8^PPU?pv#+* z$f7-x$UG)8mV8sPa9!#*!BxiyMH8q4v!8W*W}csfe&e-X+}R)72m{9zJtM+)-}6ax z!(@z@LS+v1o}+e(B024qQq@qhmjpm%Ank>d}{SpltRzX@EmX;Kxr zilBcI>?rNSxCZN@SKBQ11=uxME3+QQtq`C}VE@gi-sC@xlZ17n?jgT5SGZ2#GI{lU z;SHJ5r{59(Ri~A+SBv&~2ITdU06mreL>|qW(EF)-5Et0^2c;UY?;cvlJ z4K;MHSVOnLU8EP(dsm{`m+w??YcAxv8X=yIakRhUDnQSquabZNMa8Vu+A99-uO9Rk z9%F2&UNORaMzFu8aff`{VX@bh-rXEF9gh?Ydr#6y*d@Vwpe-Z6{-JO^fmGQh_8!kx zO#WGN`^}|y!KKD-(&7j+-b5T2Ti+LtO9BMw1z!DS4%NHXb3>qc^mgI)RpJfu%%kF` zEgSQ)a6Gi$TmtmYqS6QAsL)n3{mJcT`nlvsdWj$1iwemP{3R*sladSIy0&G4cBy8b zpMhyp{V5Dpw5UenN%d)UWP+>Cv*T6SltoLh@w^o+=OClmyZr-l`vXHkm_bxBWp7=by+8|l zofVVYeRkZ+g07ZrWlHsg&$b?yV$m$9m;ypz*PAbc=x%9l2oH zR*vky#1lzA8`YX$-^@6zxN0Pq zO6G=aJZjZopX9{;i1ldlwR0rJsZ8+*x%~oo71QMfT+i$Mk+?HBIV@qc?c_9b`t@Twf7nI7B9_2(BfnAujWZoBgngaCRwomVC)WX)dll$ z=BN(6pFTwUDlID((FIckYB|R63z7icAA%*onC4kA!Z7kI?(lWlXPM{cVCvb$;0iaA zkdISVaNEBae0rjI)v;grT#AD~U2SDscY?*>QbC{4qR-fh`3X3}im#_e$bS%B9lAk2l;AHJY=6$y z-Q0lKIrR&rcI(NJ*yk9bJhQ3C1g_Fi@MGerIeB1_Bs{ymaNR|FlXsm}G2x};$My@? z>(k0_#7|yJ#j%^v``P^r$WNCDcjUup@U2AH%!Ks}+?D)Vh#1acM&AOLIq?uJVnfAZ zI4y3H+aEK`!gQeO%Kq5FTyRzA>iG$EG@zfO=|^6xMMs6)5sTjch4+i#HDUo3C-y_Bhim-M6Q@?mthxM8+` z+0A3*QhZSbY>fq79Y0$C8pdWU;EE@*Q|bBe|H$pnFtz(Z?CrmuH|7kRr0qf|<#8+a zpz6>Qle(d*_<&U5y4QUKZZ&58U!c@RYoBdE+|?F!Yn~M!d6UIQCzhgzdGlpl4H?hi zEw4$iE=)H0HBL49C56X-5_b`^#a_2eKk@-XgzNiX^TDmGw%wo<3KO_oETZI$-^gc7 z`>%pu)iHA#os%?c*#=Wz^6XggsEf9cyzeu@^?Y9Gy!f&I8cpH_$ywn_shbp5(Kv8a zKi<)f5=SpH;JgGFBjyU%&tE?IZ%JSePGZ!toc28~N&>ll($Dl3e+am0-@cW_UU%oE z-)xERObLub~b-76+2spZHz~Zna9-30kp#7lB!vCEjS<)TlAi4b%!|#gNU%;MI9ol|9`LWg& z`B~vPe|sVK79-df)r4Op0sBus3?%=>Hm8iZD)#nMl4;<&q43n(^;g}hxV&wie-+c# zw~SJNsZ<@>Y}l{j%Kkex^{xrG{}GUM@`R7Yk6tBqkx%Ylu`axRv$ABqvjj_Mnz>;K z@-iDtwaY48Sy6}X5;w{1FLu?tF7~5GRrH-hUS*_kKJ8(DicLs6`kghztvWFoRvkadN))-{(iBfGr028bg znV-IfSIZZJDIbH_!F1!Sxg}{H`=>aKl_ZRRf-Cz2{}Q0DP(1Yq?5&GsYoL^cdI?<} zy33v-KM*Edr_{Ju?ClTQe@*@_Q_}WN{wemay(E4{NCu6=;HV`pqu52}6MaA9q6)CG z=5t%3wz6%`)|2OQ0@1zVS8!GFlQ8Vnp(p1Wcf?P28{v9e5>9R(WTS=0{p~l8)-uA& zSrzN#BKgJ=Dcle8VU&PNQR41O7B<*s^8#}FyPKW=Blh+eu3sSc-6c8D&joBIm&vwl zuFVHWm8AXc7udgM1p6a_Ki-ps`}dawba&|dm+%?Kh3i#ezc8wMa$hH!_0ao+`P?EN8ApXz9-y#_l6#E`>~pt`?cHmX4n673o)yG?bd(6 zm?F2mV~X5+=I`CNqSAVY>&a#2pw*Q^s^~w9lN?|!TV3ghOSt*;>y=v7x^Y=LyZ*fR zlDX#fN+BLa&&ozZf6g$!hxucP(*-A*9&0MKe=L(mNlIlI9JIuH9 hDm8yBW4S!b?PY$SSE+rKS<5O}7JXgJK`Sfy{Xg_aJ`?}| diff --git a/src/GameScane.cpp b/src/GameScane.cpp index fab8dbe..8ba784c 100644 --- a/src/GameScane.cpp +++ b/src/GameScane.cpp @@ -61,7 +61,50 @@ GameScane::GameScane(QObject* parent) UpdateScoreDisplay(); } -GameScane::~GameScane() = default; +GameScane::~GameScane() { + // Remove items that are owned by unique_ptr so QGraphicsScene won't try to delete them later + for (auto& up : m_bullets) if (up) removeItem(up.get()); + for (auto& up : m_enemyBullets) if (up) removeItem(up.get()); + for (auto& up : m_walls) if (up) removeItem(up.get()); + for (auto& up : m_brickWalls) if (up) removeItem(up.get()); + if (m_playerTank) removeItem(m_playerTank.get()); + + // Clean up raw-pointer containers: remove from scene and delete + for (auto* enemy : m_enemyTanks) { + if (enemy) { + removeItem(enemy); + delete enemy; + } + } + m_enemyTanks.clear(); + + for (auto* bonus : m_bonuses) { + if (bonus) { + removeItem(bonus); + delete bonus; + } + } + m_bonuses.clear(); + + // Remove optional graphics items + auto cleanupOptional = [this](auto*& ptr) { + if (ptr) { + removeItem(ptr); + delete ptr; + ptr = nullptr; + } + }; + cleanupOptional(m_overlay); + cleanupOptional(m_gameOverBox); + cleanupOptional(m_gameOverText); + cleanupOptional(m_restartText); + cleanupOptional(m_winOverlay); + cleanupOptional(m_winBox); + cleanupOptional(m_winText); + cleanupOptional(m_winRestartText); + cleanupOptional(m_livesText); + cleanupOptional(m_scoreText); +} void GameScane::InitializeLevel() { const char* levelMap[kMapRows] = { From 76f4f0ada545743d6ed5f4fa67420bc1c2831399 Mon Sep 17 00:00:00 2001 From: frankyshelloy Date: Tue, 9 Dec 2025 04:22:58 +0700 Subject: [PATCH 06/13] New update --- .../TanksGame_autogen/mocs_compilation.cpp.o | Bin 37392 -> 36472 bytes .../TanksGame.dir/compiler_depend.internal | 961 ++++++++++++++++++ .../TanksGame.dir/compiler_depend.make | 961 ++++++++++++++++++ .../TanksGame.dir/src/GameModel.cpp.o | Bin 10344 -> 535840 bytes .../TanksGame.dir/src/GameModel.cpp.o.d | 46 +- .../TanksGame.dir/src/GameScane.cpp.o | Bin 435720 -> 437040 bytes .../CMakeFiles/TanksGame.dir/src/main.cpp.o | Bin 31624 -> 31624 bytes .../compiler_depend.internal | 920 +++++++++++++++++ .../compiler_depend.make | 920 +++++++++++++++++ cmake-build-debug/TanksGame | Bin 499000 -> 663000 bytes include/GameModel.h | 65 ++ include/GameScane.h | 8 +- src/GameModel.cpp | 75 ++ src/GameScane.cpp | 255 +++-- 14 files changed, 4070 insertions(+), 141 deletions(-) diff --git a/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o b/cmake-build-debug/CMakeFiles/TanksGame.dir/TanksGame_autogen/mocs_compilation.cpp.o index 88bdaba48e129b9c654c8039351092c8f22772a1..6199d90882260a009b6e66e699885e185c4ba22c 100644 GIT binary patch delta 7185 zcmajkeQ;FO6#($})*uPlup4lByTPzY_)1v9Zd5+hBpa-j4->Lcv|ynThuT2F#8xrJ zBpbA7fP`#3rQ;tkvDQx2LbEg-t3zvO|EV3t#5y{(LL)6&?WkF2`e9pQdd_+0!Q*s> z-kIF@-uc~o-o5wj+kLx9J?r`WkSA4I@zP_)g;K+NHAci(WSF?0kAE}pkM;xjH;eZB z8?2=T5}b|Ot7X3sw{v7aEZZX77R!Fgv6sI&b*MBuoe!DZAaoT>8QNU%hzGV#3qq`L zj+qPj*@4+t7(Q%&Y2nivK1dc?A)k>Y=xo>Gv57j!TH~?#5RF;N6-GdETTbZ0wj1}T zw{H&R_DfQ~_>gFvHKz1a(Pq|!(g==#G7qq}C~XoQVNEH0T6B^%t@M;=G)!Y2RT{t* zpz}7eW|ZC`+Q;gjVo%hW??KUF)|k@MqT{RyrSq?_&l@hHQMD+&PqdyjrSwJ7Bx_pf zzeERFN0r`!Go<;Bv1XL^i2928`d)eIe19hzXN@VHgSjYkGiyTWR?z|07NtX?BdjT< z{}7#IO)IU&V>)lNgs-pC9??eDjMBG7`&j)`FP(1*9#iIF)|k=ZWM%+dLLeU+{jZDh?T?Gx=|_2UfO^L5Sx1#VBRa;KQTnl{Zy{e_Tvzve ztEb!NjkCs-J}KJFno#(J|JH(vzaTMSOknRpy>=Xr`Sx&KgtNB-+fHQ2Mgy0BeiVFGNRJQ%b9^vd=ro znpXORXf(ptSLth_jjS1^L41y)wd!N_ibfnzM^%?Jpu7{5b!%(y2N_;}OP98MzVT#MU(xY(+jdYpPl_9xqtSgir z5FKW{LFpOMan?$u%kW{E)-N2T^HwYE6|HBjQ93S~WW7o0UHEuTnFm>KR{Eys80(jn zZpFuX>g$Wqs8%cen`oSMtT61SMeAAbR(e`A$$F2{WhHjzLDsEGQ=((6_bUCXsP9@DRg==2=h~U$tlO3TRm!v{y8|lt$I5^pt2lYnRfpMRw*S>!V8lAUeqU9iwC1N}O{(oC#v82fqtbk9B;rjPn7r?Jj@8bF}*XOt{g5pZc{3_SL^=njDM3&R&>31o+w8-`bju*+1ap5(x z2F`LGs(12!H`hn04!y&@=+`W}ICsqZtp8@kw@sxvL*K9Jn*&!hmcxsiZiA~f7DC;o zYS^;5U})av7RSg@P_U?9vcyZnew+ zJlGnA#jRd*0vcK^c(v6Vn&awmx7@(AnFgO=K3Xehjn9hGSOQS^uoWtH=@+iPB~XXz z?z>TLV7qUJ>bpynQk1|^)PO7V4_#UeXOzBuiRQIgp?R*p%j7nu%t5F^b+6D@TpEI% zZI(G7_OwNzvdx?KbC;FDN$g2KPC9E*AU~;4-nl~)ZOcthjtSGPS>`OLYhPtfgOgpB zxd4u~uL{k@eok@T7^q(ny)^h?lz(OQhY z=Zf9}M={!t(Tpp)3eI5k2u7Xf3>w)Q$ium>#nq%Yx+>hac!dghg?8XvX@%-|h1Ssu zK_$jc;ol+rd#N3_|8JEbXnChJ;K}^Z&^{Ah$9{MvJh$_Oya?ucKK&g-b&r1A9LhYl z!i1@Nd~pAsF?gu=oitpOs$LP9A4_F<;XY_ShC*w$*de>ekD(D(~W%;aiz(Y0l-B?a?DGvt2!I zyIc<_?Y75Td)Zb^-To?|ZytyKl$EnWIuy|`Ja3t>u76g}1_>JQSt?xqhP*gxIP=A-smtD{ ze-}|H#lHnm)gK9Lp#QsJ@fY#Nz;6{sHgxnya+)gb$SgS4zr1vGw|#U@GT2A-Md8x& EUrcTLdjJ3c delta 8111 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

3n-wXUlf$tXh&jPOy_#T1p75MK0 zuM~I{{Ax73Z_{(j0yqUn83%sSkTMN9cz}pEtRp3Vpyo11x5qL*|cNX}u0`DsDZUR3};N1n@L*P9H zo+j{K0`D#GJ_7G6@O}c%5O{xq4-oi3fuAJsOo0y;_z;1gBJg1X=eKnQr$lFjz)utS zNP(X&@KFLkL*QcsewM(;34FZ3CklL$z|R%(n8@T&!Wjli!J_;muGF7O!wzh2-s3OrZfc>?-BSsf!{Ci0)amy@c9CNRNxB){)E663jAq-7Ycllz!wYr1%WRS_{#!cD)83? zUL^1p0$(ZcRRUil@V5lMR^aalyjbAx3w*u6Hwe5$;2Q4&DDbKR-%sGx1ztno z2MYWkf!7lFAp)->@MM7>D)1D6A1?5E0N^}|uJS6bO0&gPlW&&?6@D>7Z zDezVTZ!Pe)0iJ)1`<}EX@IEWNcG-Cy{7E1G34EcCx9sS~dCJEJfj{lzmx4dzM z{AC}137p?+%ad*w=U6xXQXd}({;H2Z3I3XoZvtQDpw}@lN1x`1l#%t9*P8_-Y^j6nu@3@88W`@0&i}8T>6DpA7!Ck3SE-*2l}i z*ZKJI$GPi$$Hy-Pf7i#CgBSbwUhwyPd_Z?M{`)?DE%*mM{xJxBB=&X>NJG^zm-s+kAWi_*XtY2fWP3mxF)p zZ^w?2N*32vO7K0X!vJ0E`xyxhls1OMK~&+hHU|G~%K z0sqm*TlI1Mclr3k;JbaiQM&8@laF5o{-hJz2FHxK0L!M55H&K8|Pv0sy@C8 zyqb^q@9)Oh&&MAo?l^(N8K*>XdP%u&sy%=Ky-eCS^;bOEM;&Ln;wb_ClH&CP{L&K{ z9U0&o6mJmVM-ODwFu<=?JQUz76>k*aHwv)1c^^epZ|YIp1{Ha0Y7Q z!YsWNSA`1W6BR!zjPcBN#m^1!wN%1=a ze39aJ1^5Sw&kyh+BN;6S@CAxL9^hLQeFR1N?wd zjGhVbQxz`^@CAxL8{j`Hz9_)^k7o2-fZwI~ivjL_LwsF;*FJ;M#sI%w@lON%XT^5} z_=GbVeHY*x6#qTI`;TE%Mei1k{T0QN0=(5&cBvEKa}_^4z+Y3mO@OynU8Q}1&sRJ( z!0VpP>+KfcqZIEE;Lj+|U*ig&_9)&jz^9I5zl;FisrZlp?{*IR4-4?y6hAep!kIW{)*z42YA9pIlS{!M@%aRJBwF~Cnz{PzH# zt9WIA7b{*pfunh+su%KHD8PFw-YCE?Q@nA2Kc{%>0RLI>HUXZR#p`Vw;1?<0HNc-x zyjy^8SNymDZ*&pI?;hZ1DxMMGcPQRJz&}=eK!Df2nB$)q;HM})JiuouJ|e)^Dt=mk zSGk1aj|}kR6(1kqmneQwfIqGHl>xp}@tFbMI-A#fdw_RS{LTQsLh*+K`~}6I3Gikl;kPQ>l%J2czwkWHM|aZGvY})h({hL@Bu20{jOzuEHj39 zZTdZ+4)F+-i-kDXsyOyN>gq6wmRX~?eeb&FbuQ)YvhQiv{B*_bd)+mERB`(rc+Gbx zZr>ZPhId+T=(5Q5kV-t#cAWtJD7I7A!%!j4DB_Jh-wkPtrbQ zwSS$dZh1Cf`L2*7h&OiZ`{!$eKM#L>MAI0&Soz!c&o=rbJe7)HYPPEr{4=lM`1XDE>M($8cPnn+SFg)itaw8cCk1h; zUCD8Ryqn@7Q99`}Xw}geCB&A9t!r=Vu9cV{l#m zA5|Rtetup4ZaMCHN5Eg_;dJ7S9sAyX-R@s1Zr|Il;~#e|``h>S>paX=d=8@Hd)!pw zHxzGXxX!~$fp@)*;~!=Gb$J#l-rVq>6q~0B)7d}Bw<+Gz`0G48b%t9H`px$`4=*C# z*s&bRG~KVahPd^_%Xj`N`5I^S{?x9|Da_4$(G_PYR0-OX}Z+`w_{ zcMWvD4I<9@Q@xt&_#ynWmB0NifL`x%#UC~0(dA6Kk>lI<{OkIBOL6<2e?6`an#un5 zJ^y!Ly(@`xdGs&Nn}C0={O$Yybv~!&y8a3KxsE!Y2ZJ{S*Y$G&@y3q*UVyHjm*KB} zv8VI7%1!LQ*le%PpD~Kt?+EDl&na%dBQPH2|6OtW9f1bm$L4YTRwlmA=L-b>h~lk{ zzb;SRSsbU0;ky3U3B3Po_HSqW>!Lg_5a;^WzxdJl{DJacX8d(NH@unStT0^Xb3euH z_Xu>J%u#%m@z;6vnd0`l1G+wI-oo+icM5cSO;y}}XF=!lJ;b^E`pJ$Dv0clQzx_^u zUhe_<9N&J|K$mlv;`X}(x;|^(%KrAd13I5)DZbup*Bw}|bDLY9QtXkMfHxrC*sfmg_49;^W4~XZ>*q)KkAnXY#8123Ezi^7x_!?AuX&*BsOxPO z_!e+o{%64Vs~KL-4d5-nbvb_lKLdO?%F}NS*Mt3TLT&KJ6}R6_&~Yjix8F_B{cF%2 z9LIh)LHDm*#oL>9(f#Xnf&Zp>s`1z5$-0x{A8okKht_vR=1(YojPb9F?W#A|t^XHL z564t-4c&-0cI@{WbpOg#+gqpt$|+gRal@iq|&&O|e})ALjV`8$J?z3~?@hheKSj z8GO3(x8I4->s_mOT@y!_^RW3Gznj(?8gqs)4B{VW&wk*{%_(Z*lb&v^oWN%1oS{?0Ov6XgAf^M2vB z+U~%%0pr_P;z`iG;u007o!P&%g7GOK&T8<9bzH}5;s1>gzj{&R^)@2T<@^S5jz^s1 z!Ap}}a3c6{@D|{DKb{SKhL7hHkF>oD;6KL~f4SiQ8S%!>SX2M)9e3KT_*sTe1aG;V z{kxg^Yydt%@$LcssN%;Pj%IT{RlK+1Ef6PR1;-y})~k#R$h(BF%`@JC@zf5ua-gO;6btT8?5Qu-B;=%g`Zz-rzX) z{p~vbMT&Pc{<{1{iU;pg9Jq?(WEg)PKTC1@9(WypiQ=7&zm8vHHOC3w9~rE;{f?53 zzesWWK6xGgC&jx2;`dp@@dp~-9qlq*ar-@{3E;0Qev@c&kOL&6rW<^>-L?mxcy$0 zZpTj)x8JMM?U?dDulGt5N7qlD;?oS*$?lQZ*`~b zia%+#t0(xR^&BU7y?uw`_Ip(W;osv!_P5`w>I?p^;`V!0>)>pVQUgyY!nRq6W4SNs)I4}(#jmlU_(vC?_? zqu^ivV~!uZo_xIG_PbZQ{;yE{+&~`Qt$2|skIuu_6<;3UUn@SxY_HD4Ivcq>cN(tq zu%F^{4cB>it>X6>uIuM}#qIaAbopC-!tv)Bf88z<6u;ka9cP2$@0#-KIO&@>PVhQ; zk>bJYzx{re&cmA(f6%N~=i!l?+5cg~bspv_Zoi+U^RQC!$Be(u!_z+FIQF|& zdV7~CZohk_^RQhh``hnc={&qo@uy9ET|b{IUTW$`=ix!0bDTose=YKJfZ{>_OBD}Z zcfD8fMJA4}|BZ^<_r2@=-Co7NH09BG*m4V(XIp>|QQUrqOXuM=ia&4GtMl*$#qD>v zbRPbwxcv@SBW&;ZFL=E#n>f1s4=HZH!=>A0i{kb>TsqFstsG~UDZh@hO7Yt}-E)r`N+!&?-$-{-m(XSm)k-=KJX!`ouJ zs_kTd`&}@dheH&%-v!foSgQEvCXUX-6Tjm)Ul>lCqoyLozcgIu;o;@%-^B2S@V`*; zW`?&0e^T(@B=8R3M~;8C;>}Hbz218j|H|-sSnqPhgXQ^6@s`HF7W_N^!0Qdhzd-Sz z|6_``GI4ZyN(FxSj~u^Ez<;E`?^Qf_9p*#D%S;^IACK9^@q_2@If{Q1@c%;b;Q4r` z-5h5}!2b@#gXh;<72g@~@AnhO37#+Ct$2CBze4fg`ETE!InEEpU!Tt|P`sz%N248| zC*H{EP#v>QmnyEdjChiU9=S<~^R?o=O#Jp(<|oB}H(ZxzLeqZ1$@Y@uxZTx>m`FAT`!*D&GoVADJBpa^RyNYOz{=_VKdDywLVt7k6Ewwuj5pq_`&nd8x-$r z{PlWQDqhdT*Y#Pi3dgbE5!2f{N^$!gF8g0}{N+i-?f0Q{yRvox< zxczRFF6W1epC4$KK?idj`<*6T&Sw?3-)YkAa%e5~x9_vn?UJFm{T`EE?+nH5_nUM* zFIN1}{r%(E7RBxNo3wulJs{uM2_B!{sJQ*ElV0y~#ji5ktJ|f{AsokkM@et*V8!is zlytjHQ9O7&|ApfAdr7)o#@6Qe_PzJIT^><9c)a?y;`V*Hx;`7%;W+kvxtd?CxP4!) z<{v5E($uHs$0Tzc`@USw^Az7`@?W>_SBl&3I`u#U^{UHp^i#Huqj`bir6!K%dlk3e zb<+IwLphH9u9N03C~m*&q|0;gVeD_e>!kT)#S_hXk3uKP7GK*zf1|#d?=1Zodzu*W0EZ`yXW1tIyXiRlJtr$0N>n z0-tyU$4N5&x$ys3-~;Njzx^)Nm+*f`ar<2=UCyr+x8J4e4F7&davb|zDqa7NC~m(? zrQ7ji#rK$U)B z`HJhO)$R5CXBAI0<(#DJLGfya*9Gs|nB%uM>pcp5mf}YnuG{4Y#XA_T`^&&49H*n< zx?LVqytCnb5x+}Q_U~f2uAdhK-mw|`cQyXHex49`=qUEDX}0%EtoJI#?RUQPcD<>1 zE#t5AyiIeCbBN(O&u>xu|JZvQ_&SQ}aX(-MM35IzP^uOzv_gU0G_P2(w7F?R(>84i z6fEA}Cb!L{c_X<=TPR;ZtAJLlh{{Wq0##8fRzXFriU?W-#rWqhZXnVBdq=WUyA$h5!Qa*{0`Y}Isb&>EuQ`+cYG?2k@90bd$gS` ziqG-nwVw|v-s*8ZkM|h(QO8RC^E`PykAnt&r{ZrZv*&5W-|BJg=hc&>{&61Hety2< zM|ga^+ux@ZKhop6zum`4J#Y7Tk1PLg#n1HYKicJUj+gR_Jg)V8Rq?YtuH$8&6Qq2` z<9dDTd^PehyoY&tc+;+!TN%<2z zuKU%kc%{d6yxgO>|9&(bFUN@uy&^w&@;YAH6|eQUj+d(xuk*NWcZ=c;9@p_QxmxP) z_xh{HGpBgL<2qh0ReZ?fI$jv(xi@$)>c z=W#}@)L+imE56#3*Yo(Kf!EeaJtvjfbB5yY_PCChYZX7)<2qiRP<)!lb-c8S3uxlH zgvWJ%?^V3f<2qi>YLN0D@a#X@9k~x3 zf6+Uop36M0$N5nMUpPg|f7FxLp!@Yl#piik$4l!; zQcs)5b-diH_^BS(@$!t~r+Zw-%Te!^dKP+Iw>wL5{cSYy1P9m7I~D)5*IzxJ|4{r| zkL!3jVye{dzh_y;OSgf4OY!SHJxy-A<4=})-dkp8pW+)mc^xlTDgHT+>v{Z(fj3W+ z`akc<>v_D&z@Jn+Q)bTr)1{up9@p`*Q1K-m*YR?l;_V*S@p3?;)YIW{Jue?qJm+y8 zFGr@O{ASPoqup^kNAa(DTNzGEvIUd*j`k>2Vz|Hz~f#B{_62uq4-ZduH)ru#qajGj+fsW z_%SU~zyF@-CU<;3ruYS(J=)G+Dt@o0U&qV86~Eu(dLHM`mio*2=M;aylh^b3oPnP- zN9wt-%$~)HU*vHeFP~NX{T|ox@|5ChJg(zq!Ca~T10L7?eL!*leS$h(GObeHe{Z1n zhmDG_Ez|R~;vez2z7BKjJgMiS9@p)zP<)-owfq*v{r3iH`B%@EdOltzKSS|PcwEbW zT=7qOTC@hd&9<;S&2{a1Nh%V!n8#^ZV%u2=liWqhaNPkHlxjO%Zc7D)X!c=D&X zyi@UV`Av#HQ>N#42L9$#rT%q$yK24r6y1t{)@xViv8{^x?;q6tdfjPKkN=)QJw7KW zuD^BcKjE=i@m-#sIv!UW_*WF)?Ah~q*Wi6lm+kuRAJpx>Q}6?Ir||DICBK)aN00M| z75}Ek^*G;ckblEM*{=VdYprLVfqz8tPnM1I6N-P!YgdnR`V6W6J092LyiW1&dtCST z8;alNaqWjcSNu?q>v7)yOsT(|rxm}$lh@;XgW~@C4RyP}Qrv&Pq1M0nJyO5_enWl# zcZ=fw`wdTZ=caLyl)uMox6|e4D?Y*FdYpf#_=6tT^R>rWQct=348`B!$!k3q8u+&q z_urGE??=4uy;A?rJw1B9mMi`XkL&rmS@BwF^?ZFm@xOZd^?co@ z_}@IP$L&SMU-Gz~uQzl^{bzVwkLPRy|A6BD`xf^BqMomJD_$l8oC)AMa|I8oD?YB|r+D&jaOHofxc}b93tawB#oy`4>w5c`K55U*-ni-U?@@fJ zC$Gojg z&&L&S^z`WQe?jpkk8Am32Bd!fJ(7C-TNH2h&>#bQsFhOxB9H5N%qV`Q$Mrm}Q~bRi*Yo(K;^pTg4vQ6E z>hX#0JYKB$)86>&dAv*UyeF^c@wMkl{pIp=75}5BN6+IW2L1!ZJ3ak+Jjb0U^`Gr= zZGXGs<@MD@#k)Ltt>;i6H9spT(LywB64=kW`Q_j_E=<70~Z@5j{h zc=-8JzyF?1J&$u0_ureT=kZI5m)9*j6!+h!smEdB|4IF;JbQFJ&R2YIkL!87T=DZf zuIKS*2Km=rAoah-lh^Y&-N08Wey%64$MZqOS9@IBfAED;e|g!Me`U+OQfPo^q_@=)qSbdv&G|D&({?%kL$lE{=G8!1s{@nZuhuu z_h!YndR(_#`(Y{XzkgG=d#>W;{&|z)cYAuY{2vv6z~g$|Ie4wq|B%PEe2?M}m+^ZQ zzuM#adnku}MCy6O;|tvhJwx&J9@p}pQ2bGk>vnf3zO9U(d70FIqsO(L4T?YJaoz4? ziht4LTK>?FNuG>9N@!yv5ZHj-x<66&A>!h9?9@p(IRs2?uYx(OH_uu=e+kMT) zq@JCgyyi<4zr*8N&zBT`%Hz7-or?d+<63^)AM9@qNculS$J_>UC-na6dUJ}CGR z6_sUi`fG#yQ;Of`>CtieH^razxVC4?$EBUmmGKWM{-VdHxPJ9h#h>^1GM684h1Bzs z$MyQPSnFPpaG9^HWlfep;o!AFNGr|2?Ey|7OMg_mFD-qT>GhMs>Tj zS4#c<`$=`XD-`$NL#q3GhvNQwNVWdATqX7R?;+Lv0>%CJkZL_QDek|ARP)~|?!Sjr z>zR19)bGECRLh^Cxc?qfEx%rI|2?Ey{yxRWd48_t-*}DG@4tss%Qq?RzlT)IU!wR? zWqP(N?!Sjr>zS}#>i6G6s`+xo{r8Y+{x!w@_mFD-g5v&rNVPq+pO*Ul_mFD&m4Y8p zQSI4zm>WlH1P{9YaGinQW#E4_@WVe7tpB|R{$&IIgMlA#twFzmUtr*y4g3)Uf7^!O zcC!Y4gMsfb@Nw4#>u)viiwyh+23~P}u>PqA-ecgOG4RI>{4F;Gx0^BW&l>o41Ap_z zVEqdX{2Bw_Vc=Dt4c5Oz@FObf%Hpd_@e|AVkU`J2O1{>U*S~zpAb+QlZ_r{D`hvi{ ziccxy9p?vskFR1zwmUbww+qKP`7@?vW}ng}K2+cQwe_7nzMYSrJB zN`>jul;P8wXtf3{ptg{dzFnPW^B<207 znbDui^_Uu+)-`A{xO)1ktm(MA+1X{eo4s}B+LdkI0I!iT8(6g z;p+1c<5MZwLU<2^uL+sZZlqER`m;R)ec66762V=a+%~kVr9pURdv1wwpp{UnO1NhJ zoWa}*vkNJ~>g+j#hGBOURZ4;GY=6GTFtJLkCVTE+f2hEcTz*-YK<$$JfUq~D<26gn zvEtZTEhKu{J98b`uI}C*C#cIj*y(oE_*F`Qp?q&wE^IDpmh|_oFgUepr(wxpf7hxN zy}e<^G_+?sa)n5X+B>uTh5p>&K-eHPw0HKl_jZY#7B-UYz5Us)5P?*+kmy+|VlLMo zVOPDB9LRSWl9(EWy7vBj_dsvhKvlOJvx8Dm-yz~B$`mORp(iz23N7pH>d5u zahWl}I@7C^nG>RK`m+9YatOk z1Dzp~4PDt4J&{vU)s+*4hRBLbmxiux4PCO}j)>P(rILzTn;l&d%UqSC%X7#`Z*jCn z_@--N)Uaq>q3-7hML1U~rG_MWxtQ$8S*#aTj$~x^OjSFAa%G7cmLk#6UTdv|T&^q1 z9h|;L&YWnxJFM6f1Kk~22h?YQ!hp*!DGXz$NuyTh_%cYdI-s=qh1^r`ReZEw#Go zNPJRepi`8fAyZX5kk9q>gcavPqH8F$V5^Hh&1tYX`E!IK)^RNqx`I~^^q8(hy5~3p zRtdggz@i42EUqwzjBs@!7kU||uFxs+bLe7MTj=f17Q!m?2AgD28+m41v!XMX4ZW5Y zmHShbN@Ae9cX?QTuZ^sjQYlBoTZ6@I0q;gZDm7o!^h3F6>Rh(9LH&DrR(SfHS*Lc* zpVd}KRSx#ZORJf_LVt5xWk!(dj@;7hU{@g{?lj~IIZ4y$bf-ByFw{%c4fqM{(dnH{mrc<`u+BUnwcz`X)DwY<=W-3 zZMB)Uto(n`b~>a_ZQ?N16(N~PFUYjbl>b{$DJ?BJtjZmV!7h0jw6%7c^UKRJ5N_kc z8HJMWSPw&;GYsjTT=yz>2>$EGBB)Q+15$$lS&$VMt6Ce>;HckU7Vq%eAC7~R_se=n zbk^wY85~Hr)=X3XzAQuGv^|_*DDF$x5FnY=WHP;d1F2LdBkrk+OeYdrb5SzUTFdfk zP*$BBm{n!E6B#Q#N95O3Wu{rQp;~KRAoF0OlW9eM-QBrX+T-@0R)uuGcu>8AB}5J_eXAU%X6%syPc|}q`-Q4Qh~Rg z#Z06&j$1wiBR9M{%NDIeub5xjWGZlZN;%8Z z+&RK$YWvk$M5aHtG$%H6wCCg+Rb5!smrKuWn=V(X@+5D$c0||~8ZXmR>9%SA-&iNx z3RSh@8eB(jcP883o*NkOPNFh}>@s!I6*SK!t43H}-_5fe!?Mwz<5$A6op6SO)~{F4 zG{-gXzj>~M`Wlj)6Ha*fdKytu?B>9ZZQtlmxj#TJcYTv^&Wjg(_k263&e_d#ZEe@+ z&+*G&Y(>uP%TohYxi!$s(t3MW^PIL!@TK2+QC4~vbHyLxVs5>xDaFr{1u<*J5vwK= zjMhlCy}QOLXqgJD7{X&W!GMjZ0lRC|MtE6EFl-}h!R{Kj5n3V=jMvDtJiKvgE7WJi zZL&f(-!-{1lM$Ota$?dE=lj~?cJFRYh#yO-r{voT%4oOu@ z69)?YgYAXYKl6G=tTE5_2 z5U?B?i{nbiNF36jno`|L(4g_?I71?D8rNs$FUb_d?jLbWxg(cZl6CfE#Zn_KT-COB z_V@PmHWb9B!OXd0hj2}%SxllD!8p2vMWr{z!?epdkE32~B#3iBs|Y1|(JjnxoDap; zbFm{r++J!EJB^(CSR!66T_~Q4Qg1RIy<+$V1ga=CpjAkfj#6;6JA$!hpjzD?jycf* ze&pyWv$L!(BGJtk8zXFcMDck2QoBP&pkGQ)+(_UKmEqffYs;|>(G~OXt^vf&tzs#2?}*eR6n6-#GZp+^1M+|rdwi~lP1kCUxLm%`jn9QL|vQkB!mfxcY3`qH)>oSsat z*l8tpU1iiht5m8=tcUsbjHo=s-s|ReF*GSzZi)pnn=cGBx2MIqw#@Qv;vSBgv;D?!b2zTy+M^tB2Z+3_M11KTf_bQa4hk$Xk8 z=loH~ii%m+^`gA<)kX^E;|TNQAX4+nIGTAv5UF`-9L*hZgmZC(V@`{3)jEbmW++}M<=lGnFN{jPK+$91~E>t@32YVp1Kp5_%T-KqNO>e{;M z>dLywb(IY@HL2QEjpzfr;hcO1N7o29Wietr7mO4Sp0+oIByx5qVA33iaM(c@&G{EEZ0y<(t+HUTYx%m+r(h+ODH0-#> zg=L}uxl&bJ0mD=U$d#&cPVk*HAEqimu2fa)ti}M_4Yfp&XsJSBl{i}Lxo;O2HpG>k zQwvMI3oXr!`F7c0TXklRsIqD@^KE!46j?Z@{SW2k#KxNRkTbVFmlwO5aUvY|NcVg* z?qU83V%#I$TeI;xD7=8*JaNXTPc~0BOV&nBtRy-RgqxQ0;YsFI^#5Y^y?zWoVLZ|pLmm7H{vy;g9I_(v5;xirD zLRR)5aP|}F_q;CDv686v?ey;FCYU{6OZaH|S8ar?rI%g*EBqlw50X1Yj7Ac9hP{4& zVh!$*L{+$t=p6T7>L9k}C-)B9781FJrSeF>h^;5wDX@b5m-y+I4txEP z4w6JwxR02(k;&rhm0oCATA$oEEE`DV7k0WMeIl-!;xbd-wF@dMiV%)HfSrw^~ zTI^TDNL7{zG*XX!oJFd#n;u_HNw^lDEcs%3MogcVs=*+;=OqEU%tGSCHSBBcrQe%} zqJWjBN@f;)C8@csMs0-pyX1PjFMi#fiMx>-$OP&`7a`IJ_* z6~UAog|CX!?WO(MZ0ISsICFN-Xj7R5Qm?a7CzN6Cag~{w zxon4X*+pFE7g1Ms0_hypvP9eg_LrKJ_`b7z42FCNhGTH(SQrkJr}WKX2g+7UTQ0f? z61F;tT+vn~Q^m+#GVn7Onz!b@C14`3O&mCCxwSk4pG$=Z@H3IyIVE$w88cSW_Q9&i&is3kodMsta} z7w+w&(Zk`jn5dKH033}DCU4E@ob-sIwWl)eET=6?D*c5fA~Te@RpP{;Op=>lbkS_9 zn5j(!+HCQCZ|9nMwy#e-jJEj{brn86)Yvyytn+hfGcyLW{T*U8Y!x4L&li=fSci9C z!Ov(v4&ZATsIXQoD=KGJ=Of4p!h$q~uUkjg(5alOdyOzd8qZMBZ5m z?1ZD9OqW+!6OrQiie{&dY(g;nb8j15pUXdhP{U4Os_s@MCUfK z(&&i|UtLFgZbzea+v#Q7ab_6Djp!r~M{o2zn~RLmp5u{j*>-+)yK&~$J!VAbHK|VB zPf|n(R(JABv?xpTVG%W>Q>hHGkdZBw zS&OA9vB{A-;@Isgi#A^8-o%!ND~MyZt0~%Mq>{vDN9u@UxvwnRcpbN8SI;b+JM{QC zMmvhi3=X=s7!rxoI551ce!Rt<;n1h`mAgiH zhohS|_c{95@NS2PzF~sn98})j@T1LL4L{D@O~dU7nM|BZ3VQ7>5B=an{isTIyz8gM z2fHwCH~jf8R%hE6XHd(IycN>3 zqPtc8+tJlJ)Fv|gjF!36PHxG}ZE9*0529Ug^0bz8rsAAJMm(B-Kz^4_KTdD5cqK@4 zx48Tx?zxI<2I_(ho}AuTrEat=IL&{Ux^t7st7VJpIkPjdxNl79+cyR^{_qE7jaaHe zvR5oUzIP7WB;(8n8&q5{hus|0<61Xw?vk^`-fMUEIG^sw`_tK2spdlZO}8_(MXAO9 zZeF&{tJcK`vGjHdg)qa5k1dK4%ftK*HMHdltzFqwV%xH?!%CMNchPt6A);}POGiH% z)VZ573ntF+OjNfqOYhu--91fDUM8N~uMYDSrc%?pa@l^j+v-ExKFF1{M!c9$z6?Or zwbBKAy>%ydbf|=0s?Ag~MvY|Han>U_yi58Gec~-~;^w$`tKnR6!9FydSw(8K(iJ?B zrvA!N_a{<}uD6%W`QC%mus-|uK2&?!os=xkZ#^D;kQ?{2B2J{sJkitv^X(@w9O5x0 zj)QvphjQmMw~m1B^b)y4DDX*ZVv&=B+BPFIum7BdxpUgPItoi$D*G~yJ^If|_wV^) z_{0lwd&GLE9tR{IR;0hz><`iIv|9S%ZkU}8cWRK0>P0q^(>x$1t?~5Z#nX+C7xT7q zWk$TVNxa}!yqdbODl=563>;qQRS$^wuRE^cD=NOrR3}qW|4=Ti79-&@h6=$dGHaIP zmWfxC>ChaGs>$NcU%2H(c_rl}QqTXzot5&}!i+#b^!0@sEnykHUdheikH@Y)N z{^t$u$0rv?#1rx>9W{Of^OgmTry&*v)3B3 z-i0fPTJ&&q%#|Y0&PqG>&H7H<7l-Wlm2e~H7h1s|c zg*VC*y5PkR$Gbjny8`0K0N-TGcFUl>zQDB*hr1mq%07t}MCc6YqB;BmRz;|C&C@5# z{*qvPO`LRr5%7SZaf`k9=-kdpEv{H&sWcCwMT%(}!CKp@Lc%P@a){}vux}U`%A4@U ziULf$=ue#UL~WRyB~CZhoBX6d(d|^l#e6dY&St8+s=d?}TzI7_wLo;~Wj{jY^;d(e zznpgumN;z06+1C_rs^x=$l;e>5e?|rEXsTlb(f{ekfJL@LsZ434~gUDoZ5-0#8^DpT4cClRU-={ry)b> zl=38^YbQ%%$_uAdwWyr<-eP-KmE-QDegDYK^eD(1gr#@-qVFFI(@j-m^ufa~B%|BVDXJ*tN7Rz`T0_doa3xU{ zC610+R7M_|u&#vOfOW;3^sGzEqzzas52IaOj;iTSriph8B&k6`HKx47pi+&@5RqkO zc*|U|f-6lNAG6rRkpT|MmRYWt>rH!oL4{Pn^9G7iP@<|c+$3`h1{9u9Wv)HLULqvj z(pVxud&FD>ja|t~Y_E(H8(N2kt27U!MXuTHrD)Q=B&tTk8!HO3;T5Dcei4McGXf50 zx}Ya--}`CKP*2ILex8u7rbZ%#l-H-~#;ST%bxAmc?+pwo$ifdCelZrVKS?2Gr!k}m zGb@NHz}zEa7GI%9B`mzmeK6-K>!K@(a*HH5+6C9BnVqEAN@7ed_;6;MqTk7>v)QI*i$UW8Uq zX2UqcL1PqaxzJge6Bk-Jne8$Um_@?a?Nw8fek7`x%nflOYlc@XxtH&lJdCB1r9oj= z@0@lFHIkRcqU$3&Q*>=49J_d@Zi%N`?Pc^;$W6f0#U|kY@~3{AwlR;);5a$TA2hW? zdIVI9TIj!N+&#ZjPU9AGBjb+&k5?U0{Y9qhZ?cSx>BXu?(rOu(Bj$S3JL?vU(YKmp~dJyKnPgQe~djV?Z=35ZjW2Q;+dOBddt@CjGQY(&%8=VE)wnb4@1_;KZPgDAlFp@nms~zgO757l zdz6mco*-^F;T;`lB~{#t|4FKDc5g?1=_=;|HZA!faVI%1n}tYKm&DUMvpvgl9i^Yv zFUxl4=8A`TIG0~>Sjy4d*52EnD?3U&Dri<-KKY`wv6T2k?vYk1my}pi>3(>6Z%?}9 zvpQ*q`{>Ffk^50F7FXV#+!szm&7qVUJ41i zifW}S)gZ=9c78#h^KRX2q1PF}wnBZTF*i`??_E{)g_2O!=^^nnHt&@R!#C0IuOV;P zU;pw|`SncD(AjHDHh$6iV+>-nGQHiv@4jIqEl;t1J>kP>sV>rC>;hq05|}l2lbrY-!21=hRdA^!s(@i>D>1SL`_D=WrVE zcbi2$VNDD}QOOhk@ps+%w0OW)^t0TC-;%c#GjQ%qmdj$TWbR6qpyCIz8B;{DSZcCz zPxYcC@l0A#sEHQUFWWAjeCL$H z*b`bThpnncnR-#qXS_$>iO2X>W-^7&{@xXtu3XQuLT4t|-{0HcI;-7cyu?$~XX`T4 zeMp{P3m2OvMB7BbclEaG36akqsm{2sWr}`U$*^NVoc8KB^xIYVwr zOwSiyH$pi>q{G=_Vno8vWW}?V#nb=f>%BsAk$o9yk?~??s_?eWTU-;StEA0^=B#j~ z7KsZA^moHd*C<=dWn-kU@`L@WPhK7i5Q<}sWk&N`F{CwLK(4nkOhR&7xv(L@l?xVU zIazcRpST8%cxW;!Z(@Wq8X73S>-VWU zU;a?$q+LjdK9)IEBd+ecXC4`K(jn@Cbf#^lT2ObBSM_x{mAPM1Bp%RuT^mF`^G%jq zwIY*@RN)Z6DzUsaQ_iDmiKNYiRukb$ zEeZ-Kh^#5fWn+{TG?W;=fIe#usWQri4TVOzU}UXPen@z^ z5hy>B6$cs!h*xvW1YWWAl_jY={G;_Gm8FQ`mL6y#L2naPA4!|EEkKg$AFUcBsXfWc zknq;H+{C%G5xRz%V`4WJBjNovn;2P-ge&HNj&Mn0-*AGe#O{uNS-Kf^MPhE(JVgns zkt9upRw8DF7FCFQaAXBiEEl8tC_XTt@+c87RvpE1wiSnSl%d)vRvA)h6bl-vjAEh4 z3Zqy&yt*ip9m&eVRi0p-ExDB8C`wXMl=Lt9POyK;+vY||@*XCtB$6~|TSX+%Jz5n+ z5?hj059XG*(8Z`6%nHr*O=_PU~7iAAFH&_!7puhcIG<+>XF=f2q#V0imZZWOjp$P12K@u$?WvSr=?-Gd1A|+%e|fi|zOrqVdN5f4GzllB~_S!dLYqagf zU%ICM$tBoBh`rRG83r=ju%Vs%ewuh&BK@-AOPUP#3ml3C7}v=z8(-#WjAZRD@P zMt+$@#aqqAcg{o=BQ~zeuLf8*a*Eijl1?`+ST@kJqJ5}!s3l*S&Me6ES#2KAWc&KWZd?5=fFW-? zZ@iN@;};Li6}xloTb;uddxB}W8xc-HEOr|f<$keNHYIb*sbnG zsXG-RU!)Np<$aN+EdHFsPf`1Bts`r)imcMz<|R`W7&EfANc%D4hh_1>;`%}RayP4b zJuQjc=n7+`l2UX_qmh}STaA;RiZVvH>fxmgx$cyQn%`pDI%)XF=&&7je05Z#!MOI8vMKwwKY0cG6`9e z)p)yWa<%*lWAli%EWQLOs#vdfsZ}eG+^;L}v`pGrhZ-|&)1CED#+Ld%e?V!4(F$-W zCo#7!aP*jRZp1lKm~+Lc0wbCkjcgmyWa3mCqIWd%tlOM@lGXOb73J>zAul$({l$rEFV~on$)~z!dM0Bg(~`pzXHu;v!2k~@jfONk zf;lv#6}to)eaU8|a%gl*qmf3VTTPrv!&Q$)GWA=u&!_$|UR7h2QUi{QkyZVp(>96K z7Z;_ZwsZLBv{0KM`peR*uP!VmB8paTPu0jIS>Gl-Y{A!t%;&k~8WN{ks7f&2!^yVc zEstQr4R6RU=Z0T(4)d)zHEVb)qmgUFTTGm1&1y#@$2zUq=U3M{UF2Bh){_I@X>N4{bEdfw z=1Y0?t9YM6Wtux7{QKo)SMy4)oft1=tL92B_xU$tqtseluSl#rs*X>r*kZj(tUF>} z1NDlj68AFX(;qu?U46NJYD8IWC&Zr+(Ou zjro#Yg6*y1GWrZ>I7hwbqHOUW)aYH^Pv8)Ey{yc~!%-D{A}hB)xHoLmb80g)2F3Fn z#b!MDtg-I-;tsf22XsOAEWwndk?J^Pzhf*I}y|`N|R9)gE+JIxk z23}S?Wyd(Z=*f%6jyqe9-Q6TKEyJ5*F z-g;qJ4E)?uEbc$LG$LubhxsYWIa8JyTs)9p?rd?McsU$3YCS1cBiEC##uKa*CuiCk ztyYS#b_3Ud;=wg!_hO;oyzQLosm*D{d0Ra8)P2Avvsq%5G9!Xa`ui0w*O=7!a*S0YX zk1B8jYR+)&qf&S>Ad?Sc;PtfOm2u%?LFWrjMuDwc*K(uLdO(ud4I^$_)y3#>?9wh; zw@rN)twpCJ71nW!JYW58s`UH@oy$Fs3TrxN@$E^~Fr8lHh9FE?A zR37vw=fGt#sQ<>I(Kj+q<>(*f$B(<~LY@0qmyc13bPX9%%Ense%w=qaDgv(`mdi%SxT^aegeC<@(l|6Q<{BDH2LXA=5?pJyGtT(+*&WLYD_pQpPH;81# zU5HflV{hYB*CA%8O}OF`b)`HbbPVD<8%hQ{Z#p2uCkrh5fwryGZTlL# zOpj1(Q=>Jq>fTM&x!YRI(!BhrfVx}@g%#zl%xu*EIv?4oa z-)&>T?V1;-+SWY^bZF~RJ5)=uI@?oOUgesrk`XGhL)s20ZAZ4kPG&>A@;ZDc4J)p= z6}G+RBt>=%?Q!eu7^)ML+Tq&Gew`q(TU6WO)^PfRbJOq&?onyoy5=5@)&r7!N!dLr zt@;~JLpNf@XghZC9j)7@{*Kl%tPC(Si)mnaxeO-=Y11p(W*T}uEK>5b;0;H%q12$i%T@z7eB*^3T1$tED!8JOLiYU{| zC4-lRxRv^_^oA7c!_ga%$^-nIO-8V8$)$Sh^?4s6%dz7MNwL7)G4CQ-x^SiBr zPi#iKBHp}TofTZ%0^Uw*lH%P`bKJt+Qf=@m6ncH!ta*1A>}E?i)xlY5c*XjNw`^Ug zk95lcnZ2Y)AMq9~3v|nNV;AS)dTk2xa1FyM${p3asUUY6i&>199TZTAyE0)#xFfRL z3UIeM>*Bju-oEg5j~jN;9jeD%aEBc>s>OC#!@-5NdqhN$T`U!x%HtN;iFJk)*GY8- zq~F%Wx}3!7#3OerI|}0z)UFAEZfsplhbc)`NNbHRLlJFmdbbtOiA)G8o`r`LeJj%D zdH-_zQ>S?BeOkUT*?GumDx<&t)4MeG7l6F)=+tN2@6g0kF(kf36m3TM_8^rwgq~qN|zVK15Ao`iw zzLHr^3`sM@Qw#=s^5UBhMzq9zId<)~hcdy3cer zcuB|%r_*I#qLd)h`d>bBzlYUU@N=m9q4snCL|&9m<(nxT=^^P70he&Y5AnZpCk!n6 z0-~ciVl$_>iag|e???`1!1&Fwv|m@4-MQ}ezE$p{CCVZzJc*0Yunn(BMNu&psld0S z$o1)#kvd9@h_`R8Ijj%99Jm5{FdbxXBeDU0Uu#^AQofYCGAiM8z&UL~TxrJO<<7U8k zA&)JqWvMfy;*60u!?l#;tHd@GWiAdutmfk!Skz)vt_-mvVWN!Cm?TSvsI*Lxt_D+n z)F0a>M^`>xX7mq=NQ80kv8uYQa+W#p5lKWsrO zM)JHFt~V-mnlH=6NSmQbO0rd1^%#1vMY;?CihSA{9Dvqn-w}IWa0m=a8WASBsv1Q*U%npCil|`P64_FnQWD z>nurmA&)}#uP2EMp3Xh1kk>4QU%u9!FAJ!m*HDK%YE@=8Tvqn)8x(8M4^>qU;q`5H z-<23}%S7Gr2)&lADoFjBKg&BVQenEZ_$;|uW6`oqth#0W5?AM?J-_E zZ3XA`UE;yV(Z{NMot`TPwYEQ}o;%Q=Tbk?7^|Z^U@VO7(o9jQ#nCn^eEuLC&vsT*pX$!?(?PPOU{aK zn1~O>eUd_FfA0$Muto7k(5|lDcJ&rh+glOt#s;BC+`G_^Ez0yRIXfrcSL;8SQGd-* z26U^qWH;ZvWn_8B!~JHTAu7YKT$Ve#U1<7RZQ|3H7GqI%A=k0N3m(xAFKBEIl(#U; zqTA*`uf?En4OcMym<`u2ha@s^qgBL+-f(5AzcE5MT3h@$_I26?voD|4D`jNh`o|2V zqoUWB6+0J`hOn<>DD8hkS7b=sk*FHEI}$QSFlYPCn*!6_lotQMR7yT=*ST5au0HaC z=%vx`Taa$=63_qiZde2?^AXqUoHH+-3heTjtI{TkMYitc6K1f;qXN@c5am``E8_SVDJw)%+b!(S1(i;WesL9g zP132#0<%-B7K0L0xPsy5sBryOX)0Ppj7$}-EN-%j))qfs`8w@VmM?FgwftkE6PGVL zoZ`xJ@YuzbcVtjZ$qBQ_VCX|Y8VpHd(Fa=QF<()1Dht25l_ZTh8f{WoRNG#)!^$e^ zpup4>b&%ImP}(vdJp7bp)@_xp!Viy;s?3Vwrm1jE@l%we&n`VVvi7OTk&jMGZl98u zQ@Wve)s)+8Ko+q~MP>ydX(;?4%M|1&DM>#(1vOqaRF?VQ4=p(#H0;sWSBzyGtKIo+ zg~{SPRK2S1l!$A-^JNJ-xiHu#UXUX87Lbw4oBjH~dQCCG|IuNh1 zsqN49bo6#-vhD5S4Mg4}f-{BevUI(^m=g1W!EztJm|?vcT|8{0L2srkyM`X#FX_qR z7R~J9t0A@%t4~IZvl?;ElOA2a4rzUN&u54!aV9fFP4G;*2e_xC3r=(YmOF3tM{XX| ze^z?8W9(wvD@SED6`b4rTJPnGZO_Oc19rDBgbzm?cL>)M>=CxH?XHf-Ney3uM>(?1 zjqmQsG+Pp9BF$QilW4Vo%cBjKqe6=t%L+>AKmjFuOWcT!`zkwmTd~wD%U{DAtlMAR zLLNq8*MO`pxO%Fu8T$Igr$J?jwM~&?8`^&-T%z&?dn3E8xC}bYu99uLM z(Fcy~Y&bc6bY>!Sy|7J5p-Mt#!1lPJ(GNc;>BtAB+VGXF>|{rYdj+!kOP0qDc8g=@ z4`XQ@z0u3xsOD`5DLr?VN}@A8cgX46CPmAZPxQD)>xeV-zP1q`eW)Jx z1Vm(JtHBS~5k2tX$Hy6TN7IN8xU1HFu!|NywR{95#bI67lo`xwN2#-&J5bzDoh3If z{9{UzWbnmpUyry71ds8aLQ`g_n?HuvtWH9fZTe9&yk>npw!L-SXLzk@&n_EZ;Rjah zr1HYFy$hFnOw{sgxrIMajh@Tl=)lAbM~yquMio{e;f%J8X9f<3b9kT$3!2@rl4WXY z^1K=1`3;@<_JQU?uDdSVF_aa%^V50x;jC1H_i1Z>Ww&_FgOEv8E$JQX>B#pin=f{I zyKm$Ul&l%(%=YENB}WqdU+9!p zq+4gTW#&}P6Iq2M9xljfyc>peSXRaMVxE3E3u&Fz!@ zmHq+g zFgY=IVuV)~X6Jeam9li}xk{?)ij_2q&l~%D#Va>O z7mONOa@irLm+98n8YW8{X7?sm(9ognOVD`L(%$yLf#x2!`>E8tCJBt)ovh^N4vH8R z1CnlyJfNmi^sK*Vh^vc-c%~9Cj;}hN!xQUpr}?7!iFN$s<+)X@;+)bMk#uXryji(b z#?h$}()0C6tQwyP`R?AqfgJUVK-AHvoOrerFt#VYHzhs}8JzIL>(t@J2FEg>Dy1|u z_6{!T%1!Uew=Z|yB9@j^<%-T+uFG)f>E35S;a8jQ=^GSTpwQXd;VMYg&1)`!^2pLO zn&P4J26O$Z(kfTi;$Q~{wOg4N3&ix!Y|pZsdOC2uo;A5}xP1Ps`gx~i`}0{Ra~M{> zx`DyIzTW=AKzd~%*E1l}Z@M%qHuxVYTY^^&dELWCg_T(iBDcEM6w5DYR%L*&L;SWN z+p}E$cG?_K_Gj8xuFNjU52dQa?*sWvdskL$E|6<`-v|Cn@XNs; z1^*2AufV?tz770d@W;TP1OFZPK6^MH2vqSK@JZlLfVYAF0sI2+C&51i{uKDt;7@~J z5B?1JGvF_P{~P>8@Hg)1_v>%qM}xlvUJw2p_)KuxlL7xbpK z1K$O{75rb|_kdIWCGh`1e(bCK@!@zjgYWrjKVIg6a~#eG9|QSIz+Vl1CHP+88^HGl ze+v8n@Lk{sf*&IKD1YQX2Z4_VKN!3ge1GsJaN2Vg`0F8`2R{USHTY}6KM(!}@b7_h z9)ASRdA|#s^3sRpkNk)BpCsCnKawAccISZ~20j2z`454=3G$o3-wgg8@Wa9H1E>A} z0DlYQ-@2DFU)fK8m<2u#@@?Q8hYP@ug#3rV-wu8?_;~Q^!H)ue2K+eie}f+n{>Hui zew_e*GWAwTXlzWwxv+2ArZb$xOwILF~4 zaQf|9aQf|faQf{=aO(dPIPI+1*SDX3dl)$Vb|N_a_C#>{?J3~2Cksx$?FOgcUItxX}+!1*hMx0H^$A;Pl(g;Pl(?gVS#x0;m1| z2B+U1xu0)8{b4RR{q}Tlj>8ARo8adk1D^qY1NcnvFM&6MzXUGVG95?z?(f?_AACG` z8+bMN0`MmAx!|XP)1GedQz5?!{50^j;IqNM34S{G&%im44};The+5qYJzwXK5AAOS zKLhRNz|RD~6rA!Kz~2M;JHZ!$KLmaj_>?fw9qdY&@y*B=?&?mNNv5Z5Sl z-slD&3x2JE-w$2~`B%N&Z+AYpLn~Bx-!BKl{c*+Bb)M~lYkSBa2Y20B$^RLAlB-Xu zCa3(q$lH`Br~E{NJUQiC4D#fZKieQrF4u4QBm4C}$h*se;%f~2QgG_I44it_8Tco_ zspo2N>RE5#*MU>d=fJ7wMg#vcIQ4uDoO*6C@Na>;%bgm}d%$bd=sV;8Gw??6d%@>} z-v>^69sqBG{Da_a;17XQ&%@x<^9yk5c?6t#9tEeKUx8E4HgM{B44ir%2dAFx;MDV5 zaO(LTIQ8rRcb8c;k57OfkMaCH_=(_u0G|fF6MPOh?zvcOZ>NbU&oMI*z*$PIlnJ}p9T3B!3*Gj2VVoueq9g#56J%loa3hLmwEo5 zkmvYtUaFvn@*IE4bKG`8KimBm_>s{6Z*b}v15Q2v0jGZ+3Qqr&6Q%7GAIT~D#Pm;JE4?T?Q zqre&06TlhQ>=)yDBIFs@95-#hjO%wmz6s;Qd0|{rp5sq>j@vQN&vuVB@JZk{_E6qr z599hc=x3ag(|&TwS3(ctIt9+S=6yiMbrs|p*OS3*;<_60w7&^)!SSzwJmZ@8cc#D} zY9Y_K=5>I@kf%Q|9_yipaeX2<=W!P7r=E8~z6tG~1kSi_0O$Ce46er~NnF1hdKlMJ z!5P=nz!}%<7vp+5qf{oVSG3*jBCns{3*|IOG7`~Z8Go~;5PP9-eeEs zdM5NUPRVIMIpyVEBc1;l*Dc_T>oeh>jO*EuXI#$#w~6bykf;3}XqV&P3VFsg?|)5! zKg@$X<9a^$V#w1U7>{xT$2{z(o`sNaLc3>xGp-kab9@$o>+wkv*JnZx z_;6kr*Oce@Q=a3t82Z_6*1(s5+t@>S zlRb>2$}fc;#`Q9A#`Q}0C*!&k@{H>|xJ_K24SD*1mx1?zkH@^915P~y z2Hs=fL*Q?R{#D?N>+`@lkC$NFD1W{|{tAQq1qS&I2KkE&@|z6u?>ETb3VDv_2Ov+* z>w&L#$L$#L@5PXpf6E^kzn6eh&!yn+P|}V(_xba>qTI`>^DX0r*RiXihn(|8`ximp zbRC;|j)goq`}JYiNxl|51w9`DKh?mOfnNss4}nw9dhm}z{zh16~I^dB0`}IPcfc{%fI!_LI~84Unh(l&AgI zL7w*Sg?vRnJP7hOet13P7o)!>KfD3*^uvwdn>hLZNhjmzL@`cUz_z0`Aq1cpDYHae(K@%{F5Qi>yrz? z-vs|$4o*E6kYgOK0KW-*EBIHye*;eY8P~jj%DDao?4&hHt44wUe9M-SHVukbshYZ zaZNppYwBTKe;@i8*SCSMObFs`|uf&TCV=%+uB(;se!JpF<4^oJipp8hZszoxjp6Y`AfAAyg9pZpknG~#+I^xMSsPaw~EybGN3NX~h@8}gh-%5xs? zfjsB&XW)!$UPo=hc$(sx`@|TJqsfX9|8P~i%$+&(G{F8A_J&bGWVO-yb z@nKxw4{j6J++W1F=Kdo3!voMye;}tnJP3LE1Lf%t4?&*(uoUCQxaRdPo4Ect^mBeq zas4pl8P~r69|u2t1bj5&`j^me6W5PIp7Xd3obyP|dHglxIgga*JU#|_&g0|YjOz?| z6ULKq$Mu@~IT?@SjBEM{=biegX9fI?an0+KjO$g9XIxVc{th_h?*XU%%+KV1hdk|Pe)}87f%8kw{J9SDO$Pm) z;EeZ+z!~rQynavdxlmuRc3(%Z5%SNYU0z3h34AT&xu5n1@E0NfUGRT_?*RV?_+P<4 z0)EgQ&Ii&z{|#OVPWfrzmqC6$IImmg!T$sKPlN9Q|06l#f^k=|w;wN@_dUQ*Mt}DN zj~jOrpyyT4!~MPFX@mTk;A5bNas4;M5#yTsftNuKZ;TJ;i~VID*cbBj2Xf{C>TfcPr%fKG@M_q}Jn&j@=7GJynFn42&OGpU z_z&~I{*Y%L;C%|_fde7WJV1Hof%S-A<^k?YXCC0bbmoBr(5@*DOu&3`e5QaO1U)U_ z2ZJvLr(ZG890K`qkbeU>{WI=5{(9(PydQvhT!waOr%k+5596KOCf+H}c&Gi0cXCs_ zGky<-|1f^ZZQ_x2wM{(AXCmpki}A?)&y2@IF)xfqeh-@QI2QUDk8c8JJYI`&U_8DB z@{C8yGah+gkMa00>}Nc_75W*Ehl88qk@502$a5aYfpc9x0z7UUO+Z{62|Zkw$LILd4t?0Z&03jgZ49Tkel)b^T2WN zE9L=mo4Dq6Fq^oR&oI>aig8_w@n>A~z9Hk9&#z!yp9KAk>vw`Pu6h5Ras6({Gp;Gm zxc(}}lX1=akBsZ7(9gJj7q}^|880V8p7S^joa_5^@VId_0ddg?JzU?(8Sms=-_y{; zym2(flW}?!_%hfNH%_UCaY}9zr<7-$(tgG%xhYP$zRPEO>UiONvA>M#S&*kckaK;f z{wBkC+T;Q553$JuO|X-Bpaq`)jklQxEe7xlP`nJo5(aXWk$;}tB zQ^A+Pp15&JJ&aRwn>eLB#V;*=H^fM1k z2WKAWN4usxFah($@!|SjfSwk}4}vcSr(bb>Ujcc>DLLbPCFGf}&IKQbcFzN+pT}L_ zS3wW+M(?Zryt)kSvcER#JM}PcklW-9$}?}!e&!8wQ{G@6Xop`h50Kl$HTRj=#Pw>7 zKjWI;i)37{z`QW7`8-3$_4}ZoaeV0(Bd%%~$p15&J zJ&aRwn>eLB%b|0JvilW0H^#$aLRucoa6901OGhu+c6GbFz_#ekB9uv#`yKjWN_~L zIthFe^vnmp7kWMgPCr=>{>i=kc5ej#6!`7nUq-vklhjXty9x3f&#!=UUN(bsUcL%G z9roOV{&JnV8S?#*zXkk#;9m#d1pW>1d%@XXn|Ztj<2f68IA8p}z}{%L9rA3K{&p+m z$-f0|V<-1B(BHlTJ-gH2wxC@bfBP=v>2Kcyr@wt4oc?wjxQ)Nv4te_955ehgcYu$E zzwv&wjlUfYdu;sePRLimKgn6glFxXxGO7?}a?a?LKh&|NY?f{|CTr{Qn`y)Bk@CPXB)xd^G%@_iJqYehJpKO<;Pn5U;G^OHyq;;}|GaK&e)>N-{hyrv{}lAl|DOiu zJU#e<84?w;U`-!TUMD)1vvAMOJ_34CwxdhpkPPXK={IIoM6^EwGR z&o}pj9*)EQ;3uG6KF^KvuY)}Ogy-oCpyvR{cYyQ!oq3Gs*Nlq;p@-kIru^B^e-Px) z13wu2)8MA_)*N{)q}90@(VPR{Y?yz{)0*G~>bzIqe% z(;sTU$D`dw@B^TS>;6%Yr{7L6@T0-$&&PtZU&nycpC^ISpN|KpKaH$k5MJOkXupSf?4{yY<^`yz@Mc{@e*aq(9Ri z=+9@NUHbE4=%GKq7xJe09c@m3%fKG;EI94q{bHVvkhh`kS^_=e!1?~Nso=c7#&KJZ z@ytM;=QS(9Ux#+tuMTkbi}$tJFLL%P2R-A^F6+#x;JlB+e(`&S>=)~H_KW8i^iSSD ztwy^`VJG94oa3_$^5l7NjvMdqbKJ-|Zf8T!IM~U0W-2(Z|8v~FWAF#oha5N7u{Ptj z9CmWt$T>b;kbk{v|1sj<9&q`${23$uy9D-APcP(co*Ul>dFts0=X`O01?P*L^ECiH zdeLZ140U5@MH zYREUL-a7qd{%3#BhdkT;Kk&KGGo0&bu%(ofz8dHTcq4SWswX!r@=tH|-> zeglptzhBJpJZUG#^J2(zJTEcuOTkBDJo!F5jwkP5b3FNd zE{-SHFODbgcW~T3jDC@S2%O_dJ2{?fAaI^h-lp#Q6y#~=l?Hwl_*mq< ztHHTH{2K5RA5JFf+&og2VuC+lI_c^%|wC*^6+^^hmO z0i1Sj1gD*!1*e^?18L{yAWu6fPkTNOdGZ^_D~P)C#U>3U?=%E4g6LE|CWJ&+rYnL;9Cs*yWrwi^|Ocg|L^HP#P0_>xI%Jy zok9QTen~E`C+MGX?k|#mAABPCZQ%O*0#g15;PsHd9egVI55Z@G-vQnVekb@s@E?IM z2LCa5C-_$IKJcG_uLS=o_=VtifnNfCH~2d6d%&**{~7oO@O!~;1iue_Gx+`Bw}L+a zejE6M;9J2T0>2OZ=irZkKMcMd{1@Om!5;yC7W|jsFM&S_t{ho>CjISK;QL4*e&j#f zzz+ofHTYrRkAaT^e;j-w_;zspJvI69Z@~4hlK)o!A$~tl{3m}Tm-VOqIn4bzj$=UA#ObW4)Mi!yi{BV(?5*I4}p(!1^yS0&Opd<_+LE! zFCOErk8T*Lb#RA>M;(VcG^JlXq5lxS>(3?sJ-CgYKR|vsdUnRt^CaZQxrXj3{(Y4; zTKqfJ{ax}g?(g!S#qRHtzuNs>{&S)GyX3ENf0zGkaDSIv{-=L#bAQqNbMD{U!N2DI zuKtk&EPkZ?&FVMj|8!lX^*ro;HWl*nGhJ^jF5y+~-xrqfGu^*8g5QF6?*RWg_zv)I zfRB+zh#&dSH`Q;>|D6E-JO;WET>iSr)jJ#fR_N&hm%nav|6W_d^(1d9;YYfYe|HIA z=<;X5zlC-WbU&9Le;d3K{5#;S;9J1^z@@G)x__?%m;HU6d(4&KQvOkQ>~1aL`?yZJ zt%S>GuF0QWC45hJO&#m%le*=9<6SN~Ft^{D@Aq1VPbuNQb@`$a zzSn+^{OS@u(dFw)_=2 zT#iq@drT*|lz(b}=Yva1_+f6q$Y(pqA1N#Ud(q{0m+-L%NU4en`JFiVqvfZ%d_UJ; zG+*iRO7MG}L)HJcg8vL$U)zy-?gd{5`TM{(gUe&?bK8~IvgD6sa(tTPAL2)!%WFHw z9OUqqATK|wa`{--AGQ2}2RrgpN_efywO?!bGhMzK@((&H)c>yse+YaF_|L(&f$KF* ze!L6(7my$8#)q`$5%4MCzXV?d{wVlr@Lz$i2j2$11^n0G+rS?K-v$0S_*geyrTyE% zr-1(kd=dC>!B>O-4tzcM4)87DPk?U&|2_CF@IQc$b>mgqzY}~4_>z{3)03D&Z3kaT*!x<`1b`{`X#&PbuM7xO`Cw-|q6&;LkX! z)&H*t|0DQq;C}-D3Al{w1@31%!2b;SKY~m7h3;qjxOq7h1TN+E_4-NRe}Q}r zxRhV)e%1>99OTacm+~F%X9e)TLjDTy=fQ6Qe*yd<@E5_K2mc%RA#T2u>gJt_0r&`Rl-?e3$##7Vv*TejE6|!FPfG2Yjr1LM8iK;nvRb z*D2t8fG+~y6MQxJtH9TTj{)BT{%Y`T;Cq4Z0^b{ath+8r`}H+sWk2|9AioHFU+~r7 zuLb`AxE%jJsa*VQ0N)StUjUc#1tnckaR>PRklz9RI`A=W-je+~0DL^SK39`XG=l4A zvPs?nelYZ`0e?OCM({(x?*M-T_zv(lf{$_YsI*`HckCOaHRAjL{7sN=1b;Jl2l(OO zYrw~X-w6H|@U7r)1>Xt&Ht>DiJS}Y>2d>uv$&Ub^3Hc+zJHg)$eh#?wla=B>`Lh;$ zJmfzCF6CD%>57WY;739JKJcT#p9P-)exN%)vS0dIkZht7{2h>Q1wRJ75Bym0b>Nf0 zH-jGsejoVp;Ln0fTie~g4}7Dv*73Cz{t&pd z^BULA=fN8wf5@TID#!j4!K=aF3BCY)3U~qhUEt?~OaHl0HYR?q1V0J#*MUpGr@O( zOIsgw=W(pNky^4@ke>qH0=@`*Hu!4rIp7<>=Yrn`-U_}Qd>(kko8_oFex;wWDgPb^ z-Uj)p;0wSPgP#hX2ftP5y+kS(KWo5GgZxLprTkhYT~To(`00?}3ce70C-@oQ`yB2l zl=GsmO-eEm{5_DL3BCxt6Z|ajOTga?ej|7Wd@J~3@SWh&*4MguVV|+mT4%o6AwLnk z1AHcU4!je5Dfn9OW#F5@JHhV;*Uw^=_Wc}O&f_`>#m}?gXG70{?uH@R*X7`q;9cOY z;N9ST;632$zSs{QclF!PkIyf`0(~ z67Ua#-w1v&_*U>sz;}XQ3ck+~73xQh|A)XQf`1r%Ciq(LPVkR_Ujlv^_>JHn1>Xw3 z4tyv0$H4bF(zpL|@PojmpWo<+RZIf^IOJQvuK@1?{{;A2@K1to0{;~F-QZV(KLdUh z_0?z;0#3IC+a_Z#oqe*^SP z0^bPU0{&U>F7VHRuLJ))_*LL?-ZwdBRNMl7Bjg_f{{r~);9mqk`19aj13%1^ip!4}pIh{CV*2fFCx&w|@)x5#Vy(H#=e#Q^2MDY1ht0C0w7+tOmag`qzX1 z0DKGh?cm$Me+a${{0{K36a9YO2|fkvMe9pJwL-vPc2e9W=F{l5ku5B?Z9d?UCVyBY5M-ciD@cKHtQC!lA{B;WqugO3OQ19&6&PVi3fC&AAFm-8@7*Mk28d=vOT!S4p&1^z7fzrYVX!MFe4 z;FaM20dECY7oeTPEBe6qkdx{DtOMT@{1)(6fjwA178b%1o&p~Bf;+je>?cI;N!s$toH3c3cM2hXz*6>3E+L;6Tz7u} zZQxblyTB)dkFE9XuLhq2UIV@uycYaI@H+4f;Pv3Qfj59}2R{*fOr3A%JHf|;PXV6^ z{x0xN@RPtV0e?66jo?$kw}PJxz7u>J_&)W%{nNoGf$P1gQnCeHihtIwKZvvlzcJBk1`2Fs6*k?=l9DbU{vJ`21Lyajw6_-yda z;B&wq0-p>1Ja{YkAtx&H)zUr>yc&Ey_(JeD@Ri^Tz^?>975rB4)4(4AKOKA*_(Jfp z@AU0I1AHp@nc$1T-vfRj_#*HP;Aer~2L4{~?cf>kiYdOGi^0c(XTcl6CC<9ni#tkq zpUc;j@T*+D5xfKXw}R)ucY-ek-{)Pv{mZ~7f_H+?1kZzafu9Y&7JNDQCh#usyTQA` zp9Sv$Kky{q{$B7(@ILTX@N>ZX!27|k03QIq1-t2lQOW;G`hrQdke+76w_)74F z;H$t_f}ab1CHQ&ZTfkR?Zv&V3-Qyhlc9rlsE+0G9`CQ7%|5l81{+=?``B$ErjNOU3ih2R%~ZvcNE_-)|t2j3392E5|r3iTt=2f)XHe-L~s_{HFh!7l;75d2c` z4d5RFzXSZk;5)$Af{&Tz+y4>p@!*$%H-di@yaRk4_!{t!fo}xA9Q+ROkAv?3zXE*B zbl?6@fKLSfB=}75Pl0!WUkQE*_*LLHf?o~375p0To#5-i_iOa+|1|g{@Xvs^fL{yV z1-=1%E%BubxzXS3Yg5L?g0sKec zcYyyGdJorz+8^P}a?*P9Wd=2(n-3BCYa;@=8O7Q2vuLS=q_^sg2gFgcP0{BbdFM=P|>f8S}@Otq7N8S0r*FBwo zJg6#)tcsv2r6{^es;!_18d9p#KL|>aHfdARHqx|GilPXLjIy98il8VfGV93bETbqZ z%dE4qBB-sijsk43tUPmUJpSETc@8VzgOwMt@+?+f%gXm;=q-@wX;vhu96sWa{D__9Mk7wmAto#I4zJ`^b$jUR$iN`sNm1nc^0#=^S%1>hDrL6p9Rz8Q77qaq& ztb8~tZ(-%9u<|vm{8Uz+ac(^R5v)9$m7m7S^I7>wR$j`=PiN(GS$Xu{9oD#rm5*Y- zznqniX60*H`50E-Wn4V|v8=o=D?fvk4`bzLvhs3PeikdA%gT#c`65<+HY;ys<>#>S zc2<5aEAMt*JpOU4ydNt+kChj)^7C1FB`Yss<@Kz*l$AHJ@-kN5%F4&H@^)4}ft7bV zKOTQMEAPk3D_D6UE1$^9t62FYRz8oFSF-ZOtb8&nU%|>RVCCyr`Gu^!dr3V0DpuZ~ zl}};iBUt%VR$j%*r?K*RtUP*;8f#q4$}eKSzk-$5u<~`Rd^#)dUK)?TmX-Hswicn@JVE6-u&m$C99 zR(?4vuV&>}u<{00K8KYrVdYn{@|CRoDptOMm0!)udybFCKbMscV&&Jc^0BP^T2@}m z%CBSP^I3U4D__dWuV>|}SosaCd;=@Lk(Fmnh{r#VmFKbYn^<`R(U-B`K&yTmEX?Fi&^;{th|nu|D2UKvhqe&-ptDH zWaVwF{4Q3$k(J-g%Cjos@h@QId93^%R$k1??`7q6to%M!-pI-qvhrqDem^U3W91L9 z@{O$gK~|nMF&_USR-VVoA7bUjto&hCUdPHGVdagiyor@Jv+_q-c^fN#jFoR><&U%S ztV!|s7qjv_R{jJlFJ|RWvhq4s{uC>3WaUd(c{3}2nw7V)@@H82Mppg{R-RQEkAEpE z&tv7!vhre9{v0c>W984Y@{8!LZ-m2YI_zhdQCljHF(W950Q{MW3! zn3ccC%IjG9ORRhWD{o=t%UJnuSovyJ{xU1y#L8b`<-IP5$G@DF=d<$Pvhq?^{wgb< z!^(fh$``WoR#x7^%74$w*Rt~0Sb3KV<8i*u%KNhN6|8(1D}RHPm$ULWS$RDxe~Xnj zvGSFyyp@%|&C1(Z`8%w=^>E3aqee`V!Otb7eCZ)N2lvhsFT z{t+wB7%+X-l-jcK=CQUWc&v>6R8vt^HlVhmt~O&pd0A~)#(?qDr)NY829%sLrgmWN zVLwKFSf zrca(WH3p5TJ$%aKsl%rfj6QX2$(Vume};)hV#FiI)aDK@DVZ^K@!JLuN*z7(Qlj ziM0$CgN1c_d?#CQK-)sGCqxU0Y&i zMO8&S1QTMcSA#A;@`Ren6E56b{myFN?46&k>wkCzq}!xm7|8Q{$O$v5%o4LXW_q;h z&EDN-rz=@pPNy>-51VOq)7m`sSG2 zRP$!<>~uW;!yTPYbAnDzIQt}R-eC_}_B3aQ!yxk*-~a8Y?nHB{8#Qo? z{R=CMcY5T|=cFU`DT7xYujhYp@F?2R(GjFj#m?LDXHiaf$Fth8-ho{&jHU1mfVHL$ zImJ=t|IcU&+lY=1rLdlkj-!ws*xkY)>PVHTM^Ngc(f^-8q-aM+$B{zS(V-Mxr5Q~f ztTpw3l8<2je+E;?Hgt3#h17I(5QWod29TykdTqqMU|Uw_dBHZ}h0GMM)fT`*qOf)b zFSUYaQhYpWDh$7)YibR-#A~VyKhHI_hU@&G##rYMnlf!>#c=z=ZKyuBT~lzneGT6{ z$+2ijO~u5Dnu@6tD(uspL6Ijwr;j-Tyh_hs^tT7WkT2CIoD`E@R8KV)51&*~oAl~= z*oNAdy$9D+OgB{&nRg*#&#cDO3K^4L-cLVc9ho*qR?nDTY2MP9aG`n6WKeQ%bfj+c z+P|sReOn@_YovtO%t~DoTTz2o<`dqGNjVh~-?vE^<0DOE9cu3M$(KalQ;5Ep%<4y(0ib<2F zqTcLC&JM4bTF#TeUP0MR@0C?oC$&LJWy0LZ?cBLBctTZ0Sq*P`2m5Doo$YbYa_!&v z(p$5IA>h|VUusK8b@*i{ydd0Kl)65}g2XDKHxp8?O49FxrNo)MjP#t4V(SQ~w1`zh z0ecszWF%&gR;pwqjpd3};%TvZ%?e+22N$l?BKe*E)Tvxs1t5Xc!kap3SGb6v{J0&{84NOL4M z=Y8|ehka`!A(~DYB7@B}H0Ht={=N%7H4G{lGi38bpxDM!=aZkcLha?Ar<`4_9?kmdOI<-jNT2gP= ztk#b0*{q`UQY>!U;cIp?tlYU%i{uQav3aMf`XArF(`{BqxA4^7EwPI$B2aAP;cE@G zm#2Pjv{U!-)T$2d;o&L|w|~oZDfVuvB-Fl*eiv-7&YmrY$wzl=Hw6_IC5pYTfG7TX ztY&GSPW<&W_ULdeRPWE>s&#h`<=!ky*Uw7-*a67449A#l9P^#$eBN7R14|Gpeg9hM!WD>eIXh z1@?NjQ4?#*%2Iyl!dy(0^u|JNZpm1yD2ZG?G-66lK^T{}n%sg@%$DPR^f=N8bFou! z`CW8Zv3pZVVMSSa@NwZ0Q*zB`cLmmdaG7u?Qwbk{_FoGXgpjI^@E@Yab%nb2%bp6% zbTOakHtzwsm;ab7BwoB@GsQob9p+*b_-1+gz(7 z%;gDHiI)M|DrKAlz)dG=OPX6}+?E^96_*$ulQDE4Q!P4<)O;u54>FH(mgPvQI zt{kcB*DW8cE_x+Xy@r4))C);+9h%i7nKp|!WemHcrKnuDokc5(E@ayCu*<7AGN%H~ zF6N-2x3FZc^Y^c)BaL<2ej+yMWK8vSaOa9f742dN+IBh-hBI1$N)OFNhw}TbZ1ScKL3i}gHSbnI(^~qtgh%PrronZ73ys(xem?Fl}v};ydc{7`xn!w#$l@GU$LRx!Cj2S799falQagCYH{ZS%K8B8MZ6V*ha_3NIZfkM~ z^5E;xmX?k%>~<#Ct=r0|p6D8;-NqbTy@e(6n(Zr*483(FVV%Eiks^)N8b0d^s_Wo( zi19hnwQikonM~3mI>^4C>%1oGyt$h8OS8%E{OE0ApWJpv!(s<;(_;4` z#>o2^(T^N-M#Dl5BY(ThZ3oSTPs77p#2LA&qE!XMz1&> zRvq~>C3KO==rMWDdj(@^^Gb$Qn7@lNZI-!*MaXL#B1`y8bCU~qElpKh>i0y_s?sx- z3e+Kb2aLMP)T2VEj{4tRee1bkxHI}c{9rTpHmS|kjJ8uF!!7pOF27PL)HO7bL6PF( zDf6d*g4-%OE1vwupLqF3!dAntQ;Dwc_7a^=Sg%8!TE%zKLWOV6r(;TDO)zf}4tC~z zM{oOQ@^D(ogvyEu7nW32Of8sFbn1lIEBL-U(}Z1O&Kii^AQFt2?>w&R*K&RWAt z%wL0YhGNIMGX5zX8iw|7gmvh0z9UT6)l>w3sG+R7+FZ30y{2zw#P4B-0Y&D{LN-b>txQ(cZ1x$#pviz7d&CG4KTrE`%D0{mgO=om=6 zz%FU#+rKa;FJKNFW@(Bng0YM0O3H>8Q6=Wj+0pZQbKWo~1M|1q%$0Uy?G4zH*MDkT zik00=f8WaPM32@ao?JF@63OUQr_nrluALw_J`01E+x5zRqQxw?N!=B%(JoD?DoA6| zIlg4fFnQ5QY--BoB=J|xbt7P*2u^8Wp)gmG2A5Uxl=Fom-P%(w0m@1fC$~5tVjmGs z9=Oi765>dkVvOrgFMeP22~EPQThWp2J;H>qKkSwN(RE6lxM)L?mNdm-M$sJa>XA5y zRn3u)GHFbAI%80m@)@Rzi63|IRFAwG-Wg{CMK8cL2L+OHRoHxqNL)Y?P6w%5XL zVNYm{H2IGxt5!MlDKq|ul!rtP>-N%FQ+z^6L2zU@Tg!>?xbCQYuex>Wk;fy89uv|# z?}V(pgNL24mJYmZ6IS6}<5C`TQdoYRGfs+tw%`G$)1yeaDCs6+bbjDepht(co zqId_+FDa|&{KHFB7wY8V{4$gN17 zhnLhbZNc-)<_IL^8s!{eI?6DK_)Kso@L^{YNxR6e)S79@!1ruA>yGuM$W0GliZ2RRlk6}(OP6NEtn!O;Ch-yzPM0en{lB$NzKdB_PHuc*`iNEXJ zltD)=yWZ zw4exl;)ZP#n(m1{F^jy$WR~yfJu(NCm`*VNOTOycjs~!<+ws}?^T4yR2iJWDOM-p5 zIeLL(B*w%&!Q5w_?+F4KG;ZqT+KQUs?)7w)Zh^_Ty_`2Hh(850yLs|88A0tch3kNg zWKapacDf{YI9ZNAt&4kK)dM1ObG(K$ zSLk>JI0WS~?W-?*G|}zjJ>*(ufnG8 z!%IpgOsk$%GG*G#3iD|$y9aHlh$0uBnx{uO_5(~Pwj6pU51xAPe#W2dFPLdg%Zbgk zn@-ZUoZ@M;dQVPWS9%+AiaNL4ZtMx7qg%13dgVUssf`8Op-q@HTYd*7aa!B2#G0Am z?!D1pRc^e5X?9&gezYx@{F{HjjW#sRXF`OhxznbUE4SH{b#-Kqja8hysBfVSHbn$K z#_pP4I33wqQyA@r6Lw!s{kpMwYxP!_-tL;Z+AX)i`r}~RR(el&;}?g4Hzp!It9yA- z6>^7m+PG=UZ?KHn@ z4X3VM`Aj!;Wh~SVZNGtK%Wu7bH?3_~K*5$vzp31A14^^i2E>oH%?A3-zr|8B(|m#( z&}nY1snp7CHC0s|*;1qR{%G5&9KesUm8KO=2=ktuIWgr$E)rT=OPj><>dH{xR!F7;MFjUrCgFr^19g zZ$=`OU+08zaf)R(AVQ96lHl zrUCn9yl$rqOFbdtx-B#-;zD6+n0f2GDQZgiF)Ln!o#N#c6U$~))tb*AR8`bg1RvpM zFEkE{t)Avm3||wEw3kJ=A9)DY5q7yoZsd9m_g>c_qB0-zG|RTV^1@u~>)uJ5H~Zq6 zvg+ZUV0Hc!Pc%$0!Br|Iu*7j`x0LXSx0!<<%t6~yisN3mRW98Ml9xD7P3f&~DJt!R z#VtkcX|8NkqiR`;GX6C!`kP@FwCL}vS2F@VQ>U{wc(SFtjuHO9w21ja+N>*B3VEk2 zUn%NWtzD^~3x-?1I#5UQ3g)jYy+tf_y`8X*r52>Ql*KDmt!51KFKFzS!>(xzQ7>z8 zb_=a+abdcPTfBzfu3lcO zl3oLGo~eqjdfK_|&La576nzH&)BR4-q&Ty7UQ=S1S4ktjQ<@_8v)Gd8ORctd0RQ#jNVViPlq%E=c;s)7I3Jo{+>hQmx z5y@tVza?z%y1`oKymuhH9c154h`tDo-Uu?&X2#UX7nM}k)&y?`i8;2Ddx&|@*8HaZ zAaAUto)`bb`XbFXZ;yc2)so%@u$^GToKa!*!&BCo>irj%zU1*~Qx&;6N_-?ZotiK< z>3x#KQ5W)q?+KrE^WMTCFwHC|uW&y>ZSrD_=B4S#eF;jYjlaNrRM`Htu^>a{mQwVl zh>fzyyk0mu@h^=fkJ1p!d^4$N3jt?5ozs#Y^s z2~kc|qSUiA#wm6kVmfnvMypJo8ulVld$C1|x9Hr-nW8c~=8|S6Ur$C74Bjz|{+Aqg zdxle*emm5BPW{?YWK?gaDIGVfW_26`i&^B#oivV+sVnWk-1b+T?(~k=teN3)N;%2n zpn9HjR58`#SZB_5R%@qB_|)~mIUjwB0C(fq6Yo&7*YgB=GtJzC9P4HFnC3l zGM_vz?ZcM{!Y0TH#>6kmN_-)Kr#vBN@#ihlIbaJVE_EQCl|8>DR0{1-;xEWWZf%;n zZZigBH^eI&1MW`ho`Jp96^PZC4?x78Pe-0i+f~!te{o1n+0^oBQ%cGvOfdKAEU`Cj zDzi7Nt1X*UkQZf=E}~8yh`oH;%#`Rg)aI|P9_hSP>?SL6v3Kf9BTGz{HBPavj(q6k^aa{QL%d1rmkyCjoB1Yq&Z+y)TkP*{*&$&8nCGY>8vs9 zx1>L8Q`fB?x!&rw)Zk4WNSfm}b)~8yocd_Eg@&&jL}v}%)Q0qjtz55q$fm4nOAS{! zh%|?)T%m86x@RcyG#;tQeSM#wFh)ku3w4TTg0{AVsg^bhkKoX&1Ak^#^T)F7vI3oriI;S7F<8;@ zRkQIb%^N&y==rV-rnRio;)t$|svzPMwA125oAn15atQ$LC8FdD#i1$b6ITv(D_>m5C6;vX|WZzG-H}V)zGi^Z0 zIb+YH)YAFV{jZVAr2jUyZ0d#hzYUMqIxSMAF^!3rRaBJ?a7@AV?54K(@27ANkKE!Z z@wZVl_L}gj0mIHR4W2l_{6)IDx)SqeMyF4kT2?i=c2>#EoQwezrcJT$S7!{EI<2;1 zz{w-e`04c8vI(YLk$+E`I%7a}%`^km&Z4GPRF+JvDVtJ}FDYIo$)nzhpjSx z0xHU3|1my8VazsOhgQQ`~f_c;Hif-eI6TME9I`0n&*<9}PhmjnMh3cd>X z|El2Y0RN$ap9|v8SMc)y{|^N}AH=_2!7l{f2e|A5BL)m?cWIa5ek3CRzU^4|4&o!-HGSx z=jjT*C*X%E+TRQC7byIFLHjRM@HxOgMZxC*e}SU?!+`%J1wR7tCoA}|ApSxHUkdo) z3cd>PrzrS3(Ed{u{2aiKQ1JC2{?iove87)X@CyNdx`JN}+FzvLmjZs2f?o#WAFbe9 z0Y65;uLAs71-}Ng{|p7+4)`+_{CW`oSqgp=;ENS}x2==+pR*NwPvZIhbB==V1^9Cn zd|wd%I0c^r`12I}P!Rv?iv4F8@Sm^n7XiLR!H)xcse-Qre3^o;1^jpgKL_v=6#P8m z`S|^tf}aokYZUxKz<;dZ7X$uN1>X$X|Cxes0shYw{0hK-q2Sv9zfQrg1$?=JUk~^S z1;2@SKK}l#;Ja)StltT|V*Tk3_^%awPvZIWm#-D^X9NBl1>Ya=8x?#WX#aN#J|FnM zRq!JK|AT@r2JvsL=)Y3HcTw<_ApUI?d@bO+D)>2o-%i2L1N=lq{u=>5Nx?57p3mQ1 z6!9+x{PtbLzy7oo@H;5@WuX0;iuhXr{}Tnj3h+G?{2I{yo(jGl_;*$C8vviB;G-|J z^YwQR1>fC_Rr|%qUk^q9_avVC_f+_^0bi+@Km7r}x5A$X_1jhWmFt{l-@s@3-}8Zd;{@({Qp!DetAIaO!LI@Q5Cy*u@Pie+J*(QU zgz=~7{|w`@U%da1Q24t8{z4NIg%x|0=AYfGT>p^@zg=rw{%8en$C~}(`8!s@=K=mC z1)onm&;Q8^-o964zc^p0;EMr2T)~$E-md9k`@b6SQxyDc;(7m#Qp7(O@W(0U&pg2A zEBN`u^ZpyHh<_pA$0+#4fFG;in~CT7KU2ZC0RI^Zeg)vqQSfbmKU=}CC7!pxP|^SE zfd5>DeZ@hxHXC?c^dAlZsU4Qz6_$w5A9^fY` z_+fybq~MDHKTXm9;{ac+;46ve`JbkUzZ&r8n6j|_R|oiW75p6H`TA@3q_F;ZfWJt= zHv+y!!7n17=f76LF9!bU3ceZebqant;4fD2D?$4wn6j|_*9QEv6#lh z_B9dnzsOhgQF{JW3iw$Hz6$V{DEK3ceorzfth>0spOnUkLc`6#Qb){woyg?^3{T zQuvpF`2VZmTLJ&Qf?oyr9~Ar=z-O2A%%80k{089PTES;*AIx*Ues@vu z-HGS%Z>QjU0{@N*J{$1e6?}id@1)@KK>Oz?=1)H0cTxBYLHwBtek|}`sfd3Z@b9MZ zR|0-_1z!vJJrw*Lz-KA=d4S(j!8ZbaF9p8{@OvxxCB*ajYhM!$yM8qT|2_(SIpFtI z@GC+5`ziP~;6G5ouLb-;3VuD{`ziQMp#4`V=5LoBg7u&G{~-#0cjEc}aj1gN0{*KN z@n-{nj>6v`@VN>;5AXvO{4l^DuHcIRKS;rk1N>kGUkUgj3ci+jKK_nS@UwwGPr=s% z{wM`MAH;u*f?ojq$1C_Iz@MPtmjeDo1>XYNZ?91>h$u_%^^_py1aM&*y)=BLC}v|5Am2Bj7Jn@LlNO z&ClOgDELgkU#Z}G0sd+Q-w*KDDEL8u|AXT7yL`a^QNfP@{GSzkG2s8I;L8F3Hw9k} z_!|}ZpAC3>O-k7LUr#)re>W-k2H^jvf?ojqUn%%S!2d4=zXb3b6#Oy}|MiOXYdP?L zt?;h|{6+=88pMBtBL20&f1`q55BOUY@oxhB&lG&Oos!Sr8x-@mC*W^a__K-U^KZU_ z?+5&MD)>Rbf471k3jEue_q4;VKZStrs^G_h_~$9c-#FmkUg56<{EiB~7Q}y(BL3OH zf3t$G2mC#X{+|!{dlmdb(Ej@rd=v2Rs>uIR;P0v6mjVB73ceNayDRurfZs#GuL149 zMKONbf!}^6&ipU(6@8ShKidHK`xX74v2*hJ{eXh+4)|^gJ`3;lx-w41Tpx}!^{68~Ei{>r*DCMsd`0X{NQ7-x@@l}97 zM8VgA_-{4Rs5km3`R4%tZ3=!K;2&4?ep}bHE5_eO;J;nLciAO*{eMQ$|CxaQg@W$| z`27`pKfphy;0F=U$N#emekkxaEBHd-e?h?)0sl#g@iz|eCoA|$5dR&D@mCG}rzrfh z0Y5^)*MsN=^(MM_hUI6%IivDi`{I3=KQoz5Y;9H32^XE4Tz7_b- zQuN;{;4fD2tAYP)1>X+%a}@jrz@Mw&Gctp5#`AxtV*GU@o?ZruT)%mjg6|3VR}}r9 z4S4&Rw&=WxK1%baKj4p5@Ogm$oq``mJkS5D3VsCe|6ait1OMv^z7+T?72~f8@RJpM z9f<#K#rT^8{Pr_d(Qy-fl*Z3Iz)w~1jUfI7iue}-|2+zRG2q`&^nWwp-&F9+0l!kg zuOyz&pLY~|8}QFk^xs^`!WTeNj%U0y^8Ud1^o9Z z_`ZN&rRe`0z`v{DhXVd=1z!mGHU&SHc%J`1D)@20|Gt8+1pd_uz8d&%P>jFXfWJ|} z*Ms;MD#l*}@ZYTPF95v#OsokZ)cL;&#DBjc{w2WwfP!BJ_zx8Q-wOD@D)?1^|4_lN z0sLnQejVUHSMVDF|Am6@(jyoreEnXh;4=aLrGoDT_`fUoet`dnf*%C<^$I>8@DD1+ z{|LY@Qt-uqzgZD~Iq`h`|3<-A0sns$d>!zAui)nZ{|^d&9^f++>t`e2w^HznK>N2= z@QVSzje=ha_=gnZZy9KR7lpqS@Cy|Ew+h6+gTlWW@b;c4CIzAP&$S@_pD6hCz~4i` zZv_5_75&#`*W~s85e1(K_=Sr8>jn5;iuU&-p08i~DEJ)U@2%j60)AfwUkLbY1wR(F zzmI|+2l)LId^zClJ!!+vpDNJ){T2Q?z(1xKe{(_n2P^#Z0DqW*pAX{CQSb|aKUcvw z0e+x@Ujq2U6?`*j{~!gw9Pm#m`hO+hA61Os)qsCY!M6kcX+``S0Dr6^e;IV+AijPc zr{KF0&!0c!EBKy(KVHFS1O5aB-ygL9LI!M=SU`;2)#l=Ky}Jg0Bbs84A7uwEs*6zX0$pivDi`{9?uUT?+Uo z6nqQdUslAw0`T^pdM1QW=l?e1`TAL=;MV~Ecm=->@DmjLM!=UV_%6EzdE)J_Q1IOW zKT*N=1pJeV@zaZVzJEXzs zw<*@Ie#GV{_+67Qo#=c{8GjE zFCw1L-?tV1V&H#A!IuO6c}4uyfPYuvpAFjoo`RnX{C`yN4S;V`@CyL{Ck5XG_+^Um zzZCGlR`4x=e^J4&0Q^e|z76mnD)P4$@Eym zw<_ZA1^7=D{(i*s_O~ne9N_;)=|3<-A0sdtLUkCVC z6#QJk|4Wg-2EcDn@CyL{o?`qr5zoi(zZL!^!2h*^Uk3O;DdKMh{I?4KD$xG#6#Q!7 z|Br%i2fY28PG$&3zM_xP>kk_M|6c{4u~+i?yIe8;y93_-O~Yv1(MKu%EWm%P;QIpp z69u0G_)iu5P{6k<_(J0O{QE)Ce?`D=|Cntw@6kso|KosvD+ON;_^lOu72vxm_*%gK z)-*cW?&zb`{@KLy_kXrm`0IgxM+M&i{M{A&0^r|C!7l>*&I*1p;Cm?erGU48Q!d(X z(MPHOmJ!eU?#g9s0ltrd&jkFw3O7|U{O=XcW&KL1Wq@PhzfsNnMfe~N-10os46f*%X`Q3`$>;9pbBpK{Rt z(F%Vx@Q+pSb-;gyf}acgXDax4fImyY&jpJ3nM{a>!&y90iiBK|DES19~_ z0Y68<=K%gH1wRz<6BT?R;3p~gv4Eef;7bAjrlS9<0DpnPUkCVW6#QJkU#H+30Dqx^ zUjXXet8U?=;@M{$P*8=$I3jYeg-=N^z06$N`uLXRqf?p5#847+A;4fD2-Fhdl zzh5c(uP5N^6#i_$-=g6A1O8_UJ`eD-6#Ov2U!vfP06$y7k0YKxe_o+DKU4$%WeWdn zz+bN5>j8g-f}aogD;4}gz+bK47XyB-f^P==wF-VY;OiCqO2A*Q;8z3wMg`vv_?r~` z2EgB};4}73UjG^te0RX#s^GH#f185u3;0F_p9Au*a0e_c*A4|MJB475k zqXi0n9Prvelg%5Qt-`y zU!>rd6K{}M{vKBFD}etI1>XkvCI!D1@Q*3@^?-j=!EYkoAhG;CuHd_52ONL>V6lSF z1pE^Uz8CR4{wEcDU%)@5;QNF4mnir=;D1`d=L7#U3VsCe|3bl!1^%T9z7+VMRq&O- z|D1xa1^n|0eh!GgS;5x>{+9~A0q`#<_(s70O2IEAp3nbf3Vt#0|60K>1^%fDz6J2N zEBFPZ-CVXWRpS6ENamLn(|BPHFWU9@`cgl-;*wT!Qh4eWv+kctc zWY|j}BVY9Kgp32tzpUTA|nKzaQ;p5d7J|zYp*aF$qEW>sb_OZY=-7zcP~M??nRNpLn{B za1>ACKNt98i9aqz20z$X`Pav$0OdcA+Mh$eY{yR@(Ef)_huS*3IvsmC`RO(^F{Sfs z8GD#IE$^1!M*OlE8T{bJe=zZ`zi3qO`_b_qt;Y3C7Whiyefj@X;4dNGm;a9pkMds$ z@_&%|-RS&}w#(kr7v=v2^851Ndt1z}44J=k1-?CG{@xS#??UG9ZNsDdHG=&02l=yq z6CUO7sL{cQ@#Swj^PURgi-?c*lQjNL7WhiyedEu5CLQ@NA>KFsqMzw^_m5VPzg&<% z`{)T}3P1^y- zf7F<8={(&Ck#_y=X;_J2oyU;i%<`2J@EZfd4Gu-?}Gm ze?Iwr{r_LVUkLnX1OKanzlQw2{{QK2IQ~V%`}%*rz%L7#|62@?`o9#k|2)wCF9rYV zkp6bTUkCgpz<<>4IDh{k|6##2h<&$njengh@Q0ig{8lCZW%IMUew=A|l)nawzm$0U z`oVY*|6PLrR`Q?Y@!u}^*OR}H`OAU-3&FoGr2iAapZC*X{p9|Mz<<1XeHN{MClv>Q z``T~s6NvIZ2ly+2f4<;f7}9@>;BN)~3xNM~!T()I|Hpzqb3k(btAPIqv%sMIk3Boc zzuBG=zTEk9pTJKfo|+M>!<|2O86NdtF~wg;q@6$0K>VKw{ujwlmr;rS4+Z~9@|*u0 z`Lh0tfWP0KIDf0je^ksI{NT2Kf5W5px064IcR}{C;vo`zn|ez{tC%o%JNqS{8tM8<>dE`AA6q& z|0{z3Bl3^(wEsoH-vaVK8~Fb%_y?UEh$)O%6z=$4FZkD!pRfOy1OMLUbDC)VxtaV2 z#mvDEuKz-Te=a0{r@(&@l5Z9GuH%AudpirJ8~-bYN8=|iCzwBN)P6hvuLk-1R`B;d zF91gnAANBB_H(w#pP3u@`TV^G_)j;VlS2JhP5z>&m>ymKDTYV>eBi$h`0o|`E#&X( z@$b41j(;ujzV&Zs!=w1CLHsv>_=gMrz0MB;KiCuhFu}i&{CxeH2mE&m{$b?z))*JNY9xYW|-o;kL2 z*_S(hrex#s(?=AkDvR1f15to|1$Y~`_K1+ ze+}^85Bz5d{vP9l_V*1QV&C2Tzb)`Xi1)33D-4h3f99a%{4E0Uci#`^uZsM>{@c#* z$e$1V4+H;1!QV`NU;mW}{%YWF0{&kL{%#Y3E_3&bT}hy1?lkG>ZCE6LB#4^II9^?h;s>&bt+(_S}!a}AH$-%kDp z;_d$V6!7nO0QUDT4?y4fsjK0UzizNCP24}92L4jPUr7GGK^U>`Zu_4R_$uPv@#l`8 zUgiQuTjpN>b2;(8^^pj;gPvBdkzV)NZ`~qr!KD9rG<^KoJ{x=2xGV=S*Prn!Z)#NW_ z{;f=)?*6m?5S+jLE($>3`Kh8@#UH?l0e**Eo_3s74+f2Fr*9hX@6~zCw;IAXUumAoj z_*;R0H{c&}B+lP*^85PlWW%HOZv_55fd6j6-*ZOLVebCr_FvDVaQp`n?>j&3Vt5pP zzkFMok-^9RULgK=1^-0y`_4}*1%EO5vw}24{{BQS;4e8Ew|_qQZzn$b;O6ff!=v_B zlfQxadjtPp1pgs31JHMVY7_h!$J?k9-@nNQ{sBXA`^S>MZxBZ8yW9RN1-_2>ePd+s zgUio0yp7bI|5+gZ{XzU63I0a%AL{Y{Meyg4pO4=IfdAlQaQ>EuY=2+FqxP4A_8$cN zlLY@-^6%nl|KkF`A!Pgy3-Q;1`0Yoc-Sgu=1b@$qgTQ^`=X1f|0Q~kNA+G=EV{!it zBL5+t{0%WY>c1x7x0kfL{yBpGeDeFwua^q`7V`7)YcHvF{cVDONl5=61pj*Ax0h78 z{=sI0LC?Rot_u?HYk!X6QU0?}u%(InkG-VA_1_}+$AU z|MiAP{#M|(FKM{`KM4LoqwzM0{@0jM#TKf0>3y@vi~>XODz#{67`^ zb>u%RW)6OE{rv=g=7~0{#Q9^VwCgVr{7vNV7ieSOU4Opd&nG`0KeovAR}21?LjSq` z_XPfq5^LN5!fzr4BRtx-C;tz~P9{k|Of1%+~{)#~S zB_RF>1^*@F|JdWdSMbjvKOF-jub-3w{~Ezxa(N&g;`r@a!N2}2_&0*_GXeN}7vlcA zgZ#end#k`dPrTdzZv3kR{x#x#>)%_3NBy69k}b{1;OpNc(Eh!K!j zx%oTD@W|f;@>c`=(*%DDiQW0<`hO|#?-1`>f0qjJw}JR)fcXC@_&1W@xBjjZ{M`y| zRx>jA`g<|(A8y{@*vkB#d;a>%RS`VHxBd<=yfwMwXAb%K_?ZR#GX;Oos{?MCzwr1c86LI2nfxup+vmU60{?o!zlr?5{rd~SUuU0en=ih9 z*8_iX5pI9YwL#!d1`o0C?)V#Hc+~zT^7Hv~1Mt5p__MDIl)nA@H-bO!)a3Th1O7bo z0yA1aZy>*K|9(o~7ZUGV{~j|u%3meL&)45uK>Ys^{4bOL%2>|@Ke+w(wcwuv^7k{~ zKYBFI->~|?=dRzb|0;n$lX&0$eVO4={+59F=Y#m47yPry@7uqh5&Ub&&-d>;fd6a3 zUv_vCckg~Y!v)+$j|4` zqrgA)ES&#EHwA%Drud@|Zu=)2-nP`8znP~exBqeA|C`|7`R2g5TU1PsuK&DZ9DiTp zee=KA@F@O#il48)PlEUt3;vVHf2Ak>M+AQ{$lns+|A*jjCBM6VyZJlvY@EOMiTCZ_ zgA9-IR}bR<1&IG5!JlzUkT~D|T_yON$zMnLxAX5=;Qxi-|Cszkoc?q7zb6HMPLa(@ z;{N?S@P94%d(p)8jo)eK;Ql*?c(?!E_@5K_BI2KP+V75^rwwmg>dyZ{YCm6peg)dU zN$`Ikvi-Bp#qH1jSrE8y|E@JWiocEG&!P6)@$({x|6RdfMSkD@y;AUZvv1a!FYa#v z{+e;P{m+o!w|`GDJZgU)@V^ZF>jZz+twG{^`}e1UzmohdK{b*6dpYpi`}El{?Y@52 z<+cEvNqqFd9lsYE9<{&UXj__?|5t&(P4Hhre&780gWxYFKc7FXz+Z4aZhyb|L5qF+ zcfR3K``bbLUjzQ<1plq%_wC>POK|*6#QWC2gA9-2&$4eeo3E@O4UzHl28jP+!T%ch zuOvSD;Etaf!Jk8ZK7Zc={^tb$h}#3ByMDX=O#**D@xJ~08zKHu5dS+M{+v?We{;$2 z+rJMryzMD>|7ajT-@jJ@|5U+0`3_U5`SR`GlS{F`+gKY_;`n(F_@6L5T7MRj-#32u zE5rP6h~KgyQG(?=K+!I>Eo5{J#Bry5L^}{C@@hpG?5*AJP~k&bNPeH#};8roGt3 zeDU^w2>jOx{srXs?cY}k{(SPcM54%utiOK){_V1wQMpfVeUW(xc1YYIqY? zQv5j}{&w?=Zu}V)IR3jr`u`*NOM(A$;GZh^d)*zb{gVxk+TQ^D>wy1Hg8$x-{#Am% z1^E9C{3n|UipEd&f^h9W!SJa4>w$kg@INj1?EcmnS#cJj&I#2BL zpRa(w_axl@m&kuImzkek|DJ|N?aw1WU%xg0f0f|xdQTws`6mhfO5pz*_+JwIr-k&t zAov@Ber`sDNXCjvj1_>&yoX->w6Li{af+g2r> zzjg%iUsi?lH+x|O&+wi9>kN?M-#8uS`dbBm5&0{Lx8tt|@E<)DxBt2agZB0g9%A2} za59D%9<{&u+@SsZ{LvHm9~1l!k^khFIrzc#KP329lAq^)ci?|V@UJ7kZ~b{g@MqYI z-OU&GX953q({TRBE(+S~uK#ZTpC<4ViTA}{Xm}f`yMN_S{G~w{k>`JVgZS$O{~JR5 zZvU+i_%+1)*5BU=@i$QXeEqe5Yu!wP$X9e+ZdZ--zxJWv_loHEqYrNWw>CV=U*mbU zG_n7)f&VbUKj`7W*e7_1eRus=3j7(w`_}*2Lj0{D{{2DxUkUyNz<&Vn z_qqu8Upx7I>;EMJf8ZlQ%6;qq48x=T?{|K3|Mvs&uN3@C$nRVKUl;tvq2O;PKVLtN2L7|n3%s^Z+}B@!|74Iq z-}%wr=LWUE$bQ(&d`0(Z+keLZ{~Ln;Q}Ul2gc1Ahj-OV+UrByGevSkF?*#vVrvjyK z{{CC=Hv<3hz;Ex9g7SX{`Q7!?U4O0+_@*Cve|-Hq8N^>G_z!$Kh`)&1AANB1f1=>esR;ah{0#^G z8G?T%`TIo0^yvCm2>j29_pQIb6XGug@s9xUpD+ve-v{LPoga@eJnFv&;2#P67YY7D zo(U4>TmM%Hd?oR|_5Up){uU7bC=mZ)m*D(;MSkD{K^ub*}9uxe{A>Ma>z1Q%l|1v6r{PFeU91#Dvg1=3O-(5c@&BpEjoOs{(@z_ zY@DI8IxBuK10)Ow|A@4V{X+ci_<394mlE$= zzg8F?#ow(e7=L{IssZuud?n6*^Rl4fzVqw$hDZL)DS@AlzgpnW6a3wN9r*hM53%oV z|IZWngNgU8zt;)z=Y#k!2J!zO_^Zk9JHLJ>_^W|`7VsZ>74E-fV#J zcf|YF|7#78`hOvae>RB!Z-RgBi$T1;_5TCGzmoiX{l6Uee|j~}-|Uva?>oQtGdya4 z-n3x+mj=~D){i;Bf1cp~i2T0uYq8*OBtJjDUIqLg3I5#Q1cAHj?^e{F=)eegA0<#n0D|Ye4*u3H}R&__vM*PLF$EgX5n~yl?;5-S8;>%xYVj`1)f# zh<}dYUrT=9`hTh5&nG`$|8D^PPXzy`F9!+ot)CwX{=$or+dmKZFS{1!f50n&-?x5s zy$=l z4E#R_{&xlc3*>j#Pj~&vHUreg^w){RZ5Bcagsj z#Q!(JzxD3}q3`_qf#5F!{zbsw<3^mn zk>vNS|1$)B9`UAo6TaO1R~sJXZw`q65fJ}M!N2=!f!4SFzb^Qfke{#rj{^Tb^Kkxl zUJ>{wCbT~J`oS#2qxNTA9E_h*;_dqJIPez<{#x?;&abBm{yOp(GXE36-zNB9A-`|^ zI`Jl)zxRkg(38Jo4Uh8ILho6( z5dTEMKa>2v^}kH;XV(SekFWpF0>8aa0@^=ky&1IMw|>4N`1{$L?U^s$f6oK|xwl|{ z3;BKP*BXKUo_OE-^=HGQ{woIYzX0MtuK~wj|5lJc-}+T-c;v4qKVQF=0sjiYf5qE@ z-*6-Q9nWFg$91w@U+m4v}{KYytiX!M~RL zzWG}!`164OW#GSC@Q-*W2;5yi-Sy`qfj^&kU;KX&;;*FmOIiMY3*zs6EAGGF3h}%B zH$mXri1)2u=NlgNe=Eh$*RNI(|9ygg^&f(U7g7784{rYN68tM?Cy&3^fWKAn_g@tl z`$Wa`==%4*4d?$f;(hDy?uJMC%eX8#{x?AUHwpgvzn$TczYzF80{)qTe^N;QMS{N$_}2pe zYQevV{J!!3N5S7jem?#`0si9}asFQp=|9TwDE}?M-wymuf`1M94{_$7yZ=5Y_}hU0 zbKw6*@bB<`Aolsc68!6de;x22c_+^QAo7oQ+V8GEgA9-I-|fm^{*@AM*Z;o*|8s)> z4)XVK{BHgS+=b(BBK~6!f3V?E{FM}c9gF{;ApUuR|E50&pc}uNzYhfdKH`Ts@w@z= zg!tD`{8=pi4IuuL@5cFim;Ao@e}dsr{x$;t*TBC-@c)bazV-KU!Jlbwwr;-o`o9tQ zKNtKttAoVt8a%|lyZP_C0O#*S;(h&ps=%K~e4m&(_`x0j*9-i`#J}tCZv1l%kNPj4 z^4CDToxlGD`P=>;-2M@N3BdC_{w{_`{*~nC=eHk#zf|x)Mt(Q{ZvLJS_+7e z|0eO1o%Xx_Rfb3H&$>E!{BF}V`SX+e-;48~_dy`u&Eu~T_>si>_Ma(+NAVX@{CxfC z3gUlN@YjX(|3>ha0)IE)-|0S_zX!-a-pQZa|J@9a+FwWhQsV9W*#Y?H3;r&D4Zx2b zzdL?z5&UiB=lfT8;QvPOe@1?H{9s}H3|HE#QXYxmB2qke4n7%vG4Bq-QxkAzdsP~+rN4k9_4Qd<&W=QSs;H4 z1b@?qLCELDA`gDp%K7)t1%LiE!T9C-*IvNCQSf*DC=j{%-`eq?@*vJ%mcYC5Un=m2 z5bxW+W*Q#lzn!;9etVw=7WI7;1Qwze?aA2>go$|1|RZ&JT|W{yF65>+c}oZx{TF$?rQq^nDcP?j%_86L%7WdB&B`Qqbu6o~(E!G96?edmXV1%D;*j{*KYm*Do_LVn-* zp{L7WI==KZT{?Cc;OaADCo4?rtzw?(k z|8D-aUyA+N#QV+vsjn-$R1`X7c;a4+{l<&b(m!^7VHT@NX3SPm=$T zXyWP7&HujyeFUkLm+3jVGC9yEBo(|&jSTr2qN$X`ml zJwHqV{+*x0?Jp<4@BFa6;ZghB$j`^$G~k~i_=o=^2)u`<{Vf82F7ZP={I7)gi*8CD zzcnEKL!QU^`x*It=Z6CfkMdUu{I$S8U+_Oge&6}w7QsJ<{CxeL3H)yf{&nQ{oga2+ z#`*h!cwhey6!;$NgO2x|A1)I3!-;>_Gk&TJkNR&3<*$KwJO3^P`TI)ncl&1m`pyqu z3jX|?gYnDH50?S|DZj+|pGbZ;|L*$RDDZUx@2+3J75E#7_njYF43F|(PwnU9_e#+I z%olL`H;{ifr~lpd+xy(uHo5O#?(kIr_Vw_u3;Y1$-Tb@x8~ZEl&nMn@emLFmD1XhA zzdDNFj^ArR{?-ZpC&}+SKYS|qb8ZR7Zx-{{1OL&>aQojNzi<5=VtCa4Lg2pv_^%cG zUy#3t)BkS&wF&%xL+0-fLj0v5{+mGjy?>4K*Xv(F;J)~02>bxzef@9m^MdkU2jXu4 z@wW*6(?Z7I^F`eLl92K5Vt5pP1Bm}N5dS#Ae|gCGe)5ih`$NMe+P*Fd%^!y z$oNOSg!BKKknxW&Jj#Cyi2qIy|2=|#4f%U}=5M3mZv+0jf&VkX|9wdRTEV{_`0oM! zqgrtOdu<3Bp69gR-Twv~9_7DVgDp*b{p~*BpKExue~u-;@A=;qhDZKv;J+XEUlIJ5 zlm8Uc2L9!?|HT&U&m%uSe?18NJNyQ>zm@!xxZM2g?jPG49<_fC`Adnn`}ae@UoH3# z`*#5P#{Y$ae+|h0Bf$R~!9SAxgDL*#gPZ?lf`23MKMMRC1^?CL_w9duU&j4+JMsHQ z1Ep=X7<9FLX zTkuztpFe+E0{m+P|EuJ8`)_L}p5CwE{%a%NxBl&Ec+`Ixw z{{{Jd>)!;!qyBFL`TrI0zbN>3*cb%vTmOD3_}2sfuYvzN!G9e2-TC9r-$Q?k^EZlk z-}-l;;Zgp&-DXP@&krpi{xbxBHTiw(Uy)(;D;{KaYe4n72*mt-82N@pq-$u}XzXS3AUhqFl{@j>3_`&rr z7yOy?lgH2Rfj{SWxc#4y{|t}+P{X74_ai?aKd%G-D}sOMcY(Ol@w@%^qTsJ4e<|^H z{d)uWw`;}iUqt>qkAG{!qxP=^`F{)e#|Zw_?)YyL{DtH%W&U@8zu@<{|DPwnZ~x0TJnH`@@@Fys zAA!G7@V`fX-~M--;BNu`KLP*Sf`7+NLE!HC>E{0jf!~LC-~RWV5Putpe>I5zz}Im9 z4JE&C|LbFT)PL*A&&Tfvz+Wo(A0huE)c?^3H-F~}{=7Sa`NQ|WHNgKH!9Vi9xc}Vs zbF0^J{z{4O6Ahdm-S{^N@wZa^eEk0n#DBBkzmojE{qK6iqyAe1{2v4VSAzc;^85C` zF9rWb^7HZYDezyl0_VTm_d&udo&3A~cbVZ)`}2PujGt2C?f&-}@Z0;`**xC_1Y+O*caPxDYE16`e**tbZ{qx4P5$0a``!89&G0Dyb>!#$|1aR5Aow33zi+}6@%wu6_qq^&6NrB!i2pmm-;G`=z0mQy>&L$Ze+&8f z`27y}k9Z4@pXucH?SBIekH$~8JA?7d_rFcRf4AV@YpYiF zlHa%geI@wofq#48KjIyn|9i>r+y4d{9_4=_`Fa2E2>e$F{&wqi_HFQ1BPt9gIKT|GNNx-XC!Or;^{d{~d04l>buT{|WF{3;qYm-@}vt zdj$Sj;(hyHqY!@`h`%R@{}sW%iu}I)??u7iKz=@ccL)AWg8#TK!AO0?lfQ2Se;fH5 z*!qrC{)qEm8`8gz;Zgppf&U=j zzgF-+7SeyE;I9Y%gMt4`!M`S?zg_Sz1pY&T|I{{||J}9=#-F=>1*P#pd5ypyM7(eR znPYg=f6XBN0U-W21^-DQ!uz<8R;i z@AGHe{*#H{#S{N9fj^V@z7Fs9-zFg(EfoBXA=|$};2$I2xBmP?h<_s(e`kXD&;AhSf8XxG z`1AGO&jdb~c;EW-oWSQ3-!~)i%N_q;3Vb>7zV*l6XV13OU4Lg0e?_96-W7-!9$|>MKXLtg86Nqw$e%-@+Vj(R;6GCEFCf2f{Tn3s3xU5J_{RwT z73A+1Pj%!cxBd1$gQ)#=ApaAAe~#eaKz`r+|5)I=?i`FC-};@i7We;N#QXNYLk*AG z-vHWw0cig$!JkKdU;9@I{3*oy*6-Ja_?swxK7Xfx`13x-`Fkm3{L=;gZQ_0F_uT@& zhWNgo@%yg8ciANvKfd*Qw@+~U_axr8erFoKi;2ed~9z z;IDkZMwOAl`+o-TFBkml$nTp!FA4r7n|BpJN36K;rvGW>Nf`yMIm>_*01Ytv^o*d(gw{{rW)UC3XM z)o3&s8QU2i<*$_dJbyO>|181Zb=Sb;d;hss@Yj)_kDmtM|D)i)i2T0!^N!$eAwS>0 zZw3DRbvXa)$?uL|H~&W)9_2spp`ibH{^tY#GlGBTp5gNUgy1hCKhOUiz`xse$I{*C1SX?&k`R~2JzeMmiliwZxZvGz^{MDfS3xR)|f8h4N zC-~j=e=qp!f&T&EuMzwk$nRVKrWhXOe(Y-!@>KbwI6X2IWmk8tzvdcj`@{Eq?uJA(g6@|Sz&-y4Fz zf&4kd+w;?6;4k|p&i}pS_szd?hDZ5t0quVh_@5U1%LKnW{}v1WHsD_Z{QG}}+y6fK zee@xf#Tq7`MXr`H-P-V3H+A{{xAeZxHa6 z3geS&vL=z1gap-AT1$dSL`fM$7>ERA^{_rfix5hbm_*UrKJ;KOArc{^QAr?CYE&fl z&w7Z0iiiS>iZGK!EEb6{%j{h58JfL*hkFNEcV_3C-*>)yW_DJ&yHs~t%#we=fq&eQ-z4xG0e=YazX<%Zj`@EQ_|41@_Wv;8 zultSjA9JjKE$LDI-u2n}j{yE9fj@7V?myf3w+s9Nz)u2x_8(k-l=-&)&m=vnzm)mG z{6_)5THq%f>)$ExyFmS8fd5e7Ul91_`+vW{9{~LCfIoi<=YLP&o9};N(xdzb0Y3%! z`vv}cM}AD;rvQH(@YVNZsG7|GUrsQ;&T{>|F7U(M`uvNtUcLYQ0Q`)*xRlP

+)xR)-dVRxT;CqomqCh-iA5_dF5&SBR1Ut4n?{tD0 z>910KsZWXnDGsDKkm5j!11S!qIFRB%iUTPQq&Se`K#BwZ-5h8Wk~#gK{$Xk{x}z1n zfTjpc8L?{E31TM=?Ce=h0rKF3@ByLrB$(4m$;hiSb}mgT>* z=Nk&`n#8}YHwrMz+_pZlqEeu%%F|F=QPBFjhU*x~Ms8KhCuG4QPUoO~X z5kIM8ne=Y%BkN?sWBEIqKao(G29>#S@$1K*>nCC5)1N=r&*jtkmY>9zxEDBnQdg2U z@f&FQi7boXpcp@#p-UXU!$6T42{**?6MC*3UGDfvI4Q4$8_J*LPr^z0#qTQqT))Ge z-{Ow_EpFFOWIpz{&=R_CxLCK)+{KF5f#33}xuhxDz+c9Yrs#qEb>r^>{>Jk6Ab)fC ztKsi6{k9Zol_t`GgJ=e!|heF23bxQ&K@bWw8HZDU?!nq$4zoDVA(az82 z&Gq%~y(eK@`fd)5d-CLH^qqJ7=MC&4v*UlqXU!V_c{I9i-LhrATYj03p~nJn{hM!! zkDFeQKX>1K_~D;?;y-`<@x%D|?zL+xEAP6?cVB+_qmP!C`)%#e95sW#yfB?!2?_ z{;Pg`cPKP$n7G{h#6ExJm6u++?mGXu(6;Fh9C+PzM<4A!k4C3Y7ne)#p@+J4Td~4- zo4CGv{rU$VyzMsMeeb;s7v9Srd^dhx-YKWp=^cIad3^lmvF=c4<;u6-@}JL`5emJn zU5{J;9Xmeofd4!cTD;hnr;+;cpU1lQ-@mlf4*%S92l4U4N28lJH#GR}gAOV#4n7ac z+Zz4&;T!qb^rKPJI$VCNUj6vvSy_H~X^nRKb6cYu{^_TqQM-O(!%KUz^Bawh964{E zPyfv~hw$;;=bRG?-EoKSmey#;Z)o`JGa~_p-=Fc>yx9)l(D2=NzI(!iEnCFp=2!S< zx6h}auC4v-Gyi!*L$JJcb&>=B`DQ+=R{8F?_2ausOE+#TE%n{8&!f>7UtF@pe;$pN zm)r80mG#_nPd@2Czw54*EA8^#a!X<1Ll61SW8HJ-E?c%%mdKp;FS)O)^WCm=xX-(F zd-Kh1-TdbwT{b_Y>~{HG?d!(B`sz2|wDT*JZ2m4-FmRyVJ|1{r%$N^8@YCzr^ZDm* zywP|6{`VtBY~1L(L!r%^AAZ<(=jFZimfhaN;ZB{VP4l1c&1cLQ-~HWpQscf`^!LXf z2i-5cV7u3@efnwNEx&B}-@5g??`;0K(&F;ty6f(_=ir0=_|fR&kBiHF&cWJT+r4`A zm@)6Z>p$PPF%q%)SyuM%f0yZ&2_x^%KD&{RAO3?6#*DG`O*Hz|SO5H{|2!I9y?VaB zn#9C^^UZ0~PCLzhURCwR8@~I)56jCx{LpvLom*EIEN_q>MmGHLqFrtM+N;;dkv6}J zi*s}L*uxLMd2>O**s;EQ)27+8hYt1KM;%pMeDTG;I~x7&JG=blJ`MS5)ck=8JIvQO{KGw-;=)@Q3$&6{WIC*hVYKee@s z7uVMM@uShJuIkgrcjx5P)z#Ga?u{GoxWg{*ci*jD`~36%b7|jp`xJY{)_?9(SN7UQgNUc7L6+*WLcxw2zd%p0d|d_PXC+{O`5b3owS| zFN?y;xfS_q$Dd5z$sF}|{AKYcHnaGP-JHo^hU1p`a(T87fAU-YB#b>PtxIpV)Ne>IQQ%&mE)WzXHfgd=%WV?Jfi7YMHmKituZU5E12eV&?sPtCvE@{pQ;mkD^keWd2! zQ}ge3`$)~duUnUzfA{r6YW_VqAD^=4o3qK~+5dEV{^A6m(8XDCpNsK4J?4|8o+hXp z<#gNgbcc-Rd9g!5Li?WT$jXZIl-QOham9y^QX!!}z53;5op(|01)*MJM_w^1lsh_q z_}Hu?vo08ZQ~niW^FzNoZ(!ENXPtXsNcU}>ly%54A>Fd2ziu9WRsIcQPde%HewU9O ze#NL!H(Yi36=TK>A3f|RjB3oHh3PqD8N)1P#1V1=@M7{D@2CFg;<(-MR=VRp%)#`k zkbZKEyT`o-L&FSKjWt+soxz;p4m#ngMmg?l4dyxi1veUZXtaYJ4W<|5i0sOz`^B&( z)P2Aeqpwr<@u!a)HEMXi{+6%ca!pGvCt52wJsqtTG|CQe!{_pI+D!>4i zzbp#>zj-~UC5t`&xkv+_ZLs0tVvfcMIpd2^cFr-`dfMjn8%B@2NuHh9Z{+CVo+}hO z=9oMNW%(nF*KyVpL&^P4jSp=5KQ%r`ozJk(OQgr?jmYAvK)lgv~M7!@&%& zzitqZm{h`@GC%%S$OV4F}!5(j<&cme6!=%o``0Xck z9wv1jCbfRzw};sNDs>(vbsi>l9>#AUsr_@Z&!`=L|G%Dx39OGeLN_d%TxgUrMbnrPh~3N0|AN)cs$n`@ih_hho>0V%@3rrPTUT zYJJJqpQ-hw)cR6j1l6L$vCmsGC?Kdi9%yveQrLIacjPrA@^$3p&wKz7ivJ(==e&F4^r>{OTGWk ze*atQ{eP+V|E1pl=l2h(_y7G;@Bd4!2gDfvuG1Lutr-M3Ar*35hcjGr=6hXVcm7w0 zbJqGzOV8yrv^{^GIuD&X51l#>Ev?3^r=-q9r_MvC&O`g{A$1-)b)RhNK3Ts#r0$db z-}Zh$*Gz9MiY)MH#hktgc;e|}M_zTEzLdgv#C)ghdwV=0v-h@Jeh1ygW$ZPZmBxNc zy)Pp5z6c`~Mjle{i%7jM!j^~B`y$NhzdPPd+4m{?K4ssFhA{m_%Dzw8_u5~y*1pft z&>{D}p3I!N^5S$p9Xg~bw%K>Ple=eyLTT+np%Il^qa*lTws>o_6s!O%!0P2&qy53> z!ds(N;O=j1jYh!B!1Mz{p%=lf;HfLNMhnFaR)9ynxiwl1UIs?Md%*OALZKC4S1@zs z)@U9$1{?u4ikonI{sTAI6)eR6RIozAfz{w2#sA=zwFv zd0;8{4)_eX349Oi*d-J?`|YjK?%-%}0C+#R@W@bT?FU<z8Z7|Rf7}|K4IU3J1A8=)UvO%uDVm-g z3M~M;f(>9E*uQO4bQHK6Yydm9Yl@CJCKMW!))XxTp9JTED|cv$)`FvUYl^n(Mt=5f zie`fY_G^j`0v|n~DOv~KoYfQ^c5Eng?tx9wLh#Uonxb>S(7{d772s-c1K6`mQ?z~e zP-q@_1bFXZP0_4VL!mG@6^w#?&kKbvIGp@}1z<-1Q0Q$i8*Fn#Q#3L-6v_b8FX7!I zU{~;?BMA>~1gC?09Yy-!qNAIl`BzbHun{~cyD2&z{vQLDfqlSAa4=X4-T^j(PlB0; zP(NS~a3eSfY<~>#!7gAKcrI887J{|lzrjXur*6bQl>C7`!2aMMa4a|;ECb8HDzFl4 z1Z%-A#}Xgx4`%)*6dDiq03QGcfscXX!FRzja06Hgw(CxO@G`Jb+{Y2WE6>3m;PJ;3 zA1nvQgI|DU;PMliq6@(RJ({9x#0_o%*MOaW8wza(dx9A!HbsYkhk_Hpp5QF-0&pSt z7`O&(1h;@koJ9P?LZOSmo?sC;1S|t5fEC~@a0R#!`~+MBHi28feNHC+;p|ETdxB?z zL%^Zn1h4>{1wIEZ1lNIUz%Aewuyar1A3;9Bp5SP32v`nI04u>+U@f>1Yy{VUhn+%v za0u9$c9{?M1ZRLlzqnSq^pqYr)=NW)Ag9`#B994_*hBfe(X~ z;2f|P+z2*;yY@mJj-$T7p5Rz;DEKH?04@T{!IfYYxDl)acRjr+8af_*0%n2bU~ljn za0J-*4B8v`C^#2v1m6MA?oGPjY_RhQq0myWC)hTZbipjJ02~U=1}A~bz*oQsSav3S z>_NK)yMw#-X^IX2kIh3*fP>Czip~Qkp4}8(2cCWod_9qN3w8$w^(8#G2+Rl9fHT1I zev}VPKbLsmi(tExkeBn|FL)Bz8+@ie`UG47P6xjL=YX@$N1uWFUr2p}J;9DAheB6_ z-NC8g0B{kQ59SO+PQ)Kv2v&n@z>VM*aQBPg4~9l}uqRjm4gqVx3E(Dh7P$Mx#0R^8 zYrw(a7Vr+R^C_Xw6JSrU{UG9lCxH{d8n7JP>35VHyc?_o-vvYH+d~I8MRULb;85@j za5k8J3H1RU0j>kj2HUYCcPiKgY&Qfxfuq4;;4E+|7y)O4JuW3aI0Re=R)FntkPom6 z*!eQzgBh38?||dM8DJ$?32p&v!JMJU5qLG2*^B&xJ-|8OAn-GAJlO3D&C1RKH3k;Fffb^`VQp9F`1pMev=cGn_j z;GW<@@C0xTcqX_7oCS976AC>I_5`cIA>bF_1hC_E#0R^93&H;28t_VR3pfMpoCp8F zp5O*>2-pNp0K1GLK6pI15PTF|11<-*fUjSV{y8fYst0qxZljS`a12-gZU)Q2Z^j^Z z;E)@UJ8%-%?rh`_>;kR=dxH(&FmTtg$Ss%!&IZo|mw{J;>%c;=-8tx0unXAsCgOvK zfy2O~^09Zo^S}!5L9iNp2aJH1jl)jqOFwuE_6}GD_60uyM}f<3Mef1G8bHQ4$ z0Bi(jf|>ouKiC7jdjjPK=Yj>`GO!$MJCXJcuA4-<;7*fC_gv_LUBUif9yl5t0TzIT z;A3C~xD2cY#}*JDTm+_Lf3>@v_+SG#9qf4rdJwz=TmeSF4d6Rd=*O_nwx3FS1~b7@ zu>Cap1@JJi2F$q=dlS48%s4+3ngV8nGr|7gU%)Zo0FUBMs0JaDh+@D;oaECe41E5Hq4HQ25MzJi^>^nsKg>oDDt1&4Q2MFmMC-FxY+w`uGv}2sVNJ z!OoAu2k<1Y6wC+bg3p3A;7YIo+yG`=O1=IOK7vPs{lU}0G2mFR6r2Ul1)l+Hz_nll zm|jl&%jh4#Z18NbKbQ}W0lx%G!6-Nv-0x4s2M2=<;D3P`m(%V*x#Ra6us@jb81ca& zU@7=}a31&&_zqYJZUP&?jzdZR&(tG03>*Ny0gea10L#D~XHyU0Z@@L+ncx<164?0) z^b*(;{01BX{_b(~5;z_#2QPdA`3EO~5is*F@cl~kJa_~+6zmJ$4UPggfTiGD6_gwN z6s!UF`77lHr+^t(p)bH}aJwhTH+T>@1MCjY10Mrx!KGm4F!=El`2^R2L&1aQkWcVt zupE35tOEZDt^>aX+YQI=dK$eCehKykqu?lT|7XyL;Dz8Ea5%UEoC^7J9*U;|3Bf#H-eZhyoQQ#bKI=C2|1HJ{W z0MGmzd;*7o86y~9gW2HIV1Mupa16K>ECs&?=Yrck2cN<5;3n`vu;WPV60keC0UQAC z`8;+lI24=#hQUfO0@i|i&!gW0M}wWOC4I0bSOpFN_k01qgAanU!6o1_@FQ>?*aWt_ z4mp1jzJsH{-e55}415Hf3eE**gDb&h;6`vAnEn#+M(N_a7jVb<#0Lw(Vc^5yRB#SB8(ah~1K$GIfuDlyMl=3cfPM$( zfO%l(W%N6k1r~xQffZn1uo}D;jDWX-={Hbbuq*f|mfh2Sc%0z73Q@xg^) z1pER_A47li3h}`SU>^7+I0AeREChQlB0hKySPfnVM!*-r^c(4K7ZV@68SD!_2aW=l zfz!bws*oFS1Xu&!1~!0ez>KlbTY}tyv%vn~DsT*#z7)9w2Y_?Ia38q z16YLE>^iTK*R)8zOqu-_7gQtS+ZwrN91CIdT0sDfNya)fm zYr*N@*I?uCk*iwDKLLFL_5druq2O=cM^3@x!P($7;4*M6xB0hAl!7gAvcq%vp90tw%2Umb=!3|&&*dF;mek1t> zhl2gVN#Gc8HdqR-0_TDkeMNnMBfzf6?KfawaA*VJ!TZ5daN*aK58VD6$_HkGLy_C# z#f@C`1vi2BgB|any?jgm1|9|u0dEE;fJ?zyU@f>1jDTyvCU6UQ|0d)Rxm*b5fZu>a z!7ks?e!zUN9K0W_Lmn!?&|UN^-;;lE6_^K}`UCs|M}X78u8r^u>;bL-F9J7!@HTJ`IA}BR!E3<@$jb%)raa(d;6iX7xCUGWZUGP5LVsV( zxCHD8z6%ZkH-Qtt?Y9yi%mf#LhkoLnB7EtFbA9fPKv@0umP+B z+j63{4m?n9Mk=Abfmz^XU=BC|916|=3&6wLM5D980pK$57H}PSH`wkT>>{uWxEAaU zZUTpaQ`<(Ph2Udg1vn3^2EPC!;1)3bUhKN6p8yo?CofeJG0NZUJjm`sm zf$x9=z)fHk*s&D%4$){2a1uBOTn>&0w}55fIqA`8C3q=V3qAvG0oQ_ocY-@!s~4Ojs#*qMBTyS9%;H-LS?_V>eo@CdNouF+^;uroLc%;*q}mVyU?bHPbq z4Oj{`fOEl&2STAMb|>FpJ~#-BfaAfW$t9`GAn2d)Dj>`1yZsBf?oT+@kifnD~b zT;QEs1Z>IM2s-vh-f2@h%jPAM8pvT zA`XZc0TFS;2vem)C6s{cC-m3AhfUjG^pNkK>6lhBAe63Cax0 zw^43IdBRCJ9w_Ia?7bHIi!zGxFA*F^loy}c-Q9t5Cdw|9XAJD_-j1>nhr=qFjZt|2nK&qijOicqZaR`41>NP<|g} z7s@}O+=_Be1NuYxJCxzCU_BIN6y=~n-Q97N8I+4ro-(+*yA$P5lv_~VgmM?k_fQ6( zvaD;*!hA#dO_VJte}Qr?$_Ya--%z%p+=Q~v*%()pb5I^YxdvtZ)40A5#XLtj0Od@S z+fc4RIq)3pAIb?Rx1;<%%6%wzq3qX*`4z=}qWl15E6TcaySv*_wxjGqxfbPCl%s~> zc%Yn&vhEp-JIV%>^HGjP`D>I(l>LTd9-xe(%%U8JGLLc!$|A~HD8tXC>u~NLfL{cjdCu^XHl*~`8SkVl>N>}+$aa2ETUYBvfuM~PC(g+ zay`mPC<9H18)ZGpDCYSvlyQ_}Q6^DNL%ALEYT^ahFVyQmxf$gql>1SR8j1aR0mt(q z>?eLtp&X0fUqji3@kB7bFnIXD z0idOJTg`{(KI<-RXg=e|^tTZI?SJ;O?ugl5eoVW#FNuDd=O}x_x*{$8R6>@B8Te zF#kS=-sIliK76I^4X#-dZz-KIJ)iz1=HrQa-ZVfnbNOh*|7VPIaQU+G9J}JnwX1^5 zL$$xIDFtihY6^Y5j=sF+S_b+iA3X>CHRyxTmUAv7%41Q0{vGHG+_ao^yl~{f?xPLR^L9)*hMCYGh3<8{I-oxU{d4Z^$CbD5 zg1!X$nQnbrS>FnMnUB63`by}H?(J_YZyyZdo&()0{(;a}L-#sH&Cpjt@9%EkzTA|? zXD0Lx=!4z*^m6|l(*6Z*Jz3Vfpl`tTUdM1N^uI&*ihnoskD+^=Pr)AW0-$>xpMlVe z&GxSfPm+ljK{BJDlGokN??sfb+pj*B14()E=b-r~$?+<;5Tfe#7{#NJ% zee~VXqtLzj58^)51pP#J`xDFU4}?A(y4UzNLmvR$YktjyJ_5Se_;x@a0{!#u{wI|C z?}BdjZ>n1lTwSVQ&cChDr$PT(h2H7tyP@xfzNbR}H%AZF;c|Y|!R~Pt`X!D&5c+%2 z=TzwS1TLNb&?9}SZy&)njhKJqp#K7&gD>7!zD5Mzb^2I=HUdW4bYR& z@2t@6n}&&D8}#o(_qylofxa2K*Ew8w1g^tA+c!Yp=%bH?{sMHbW84OPosYf(`fBL$ ziv7F1y#LVOgnn&>Zr@Z(`wx8|^xfB?lDQ~|G`rmx?J<$IG-K+h& zBk|nrqc=eR5c&!3{_Rt+6#rQ0yP%)q)+d+aYZKk;nP&y`Pq6(k_x7{P+i!qwVSK#q zG25W;_vwGnA@sW5_V!-!H9+r${=MQG3%%YazBcG)et3<~ibLodME8ns8}u`L;@bng z$tS+Lqi~P#iLc=h`dHD=b|1f)<>S`|{bICVO&^7AreJ=)^EEt^<2n_5dU1J<$MyYZ zdC%IB!J*;AP%H4Wq2bz&nxPi{XL=}||7ibxyp#Og-G3lo3c%=lps&GmV6|s}2IxD{ zzj>yfiF-wGmaG33d1k$;r_)wrAI$Y{eb)VEMPJ`?^hwZ{y#87Di+KKZ&ehsyOR<{1 znlTpx$Wgxl&!)jquD+W*Ay5GO9b7C2Si(mT>KIm3opWLr^ld){^Hb=j;W!2t-c>P< zwa1nYr)B2oLe%@@e|*;c4DR8r0#p(bxr@Y1t=E#kj?#`8eI4{6fAH2fL;nc+bkudmBGBq=zY}^xQP!B8_7^zwWEZ_ zoe8dASU&bTr+#FvSoSq|U_U%N`@Fw3L;o)HAtn}m|8u>c&4m7A=;yd~*LqF|^!K6T z(3H1#t*3QC-wyo}x4yU(Ug>(a75XR8t36vpu+1i%hep2?pM$?yQ0`-i-G-^N6LtFF zxSKYD|Lm&cdWIWSQvbE`G2MlI8{F4>zL)m@c&w$P&MRoonHPbtl^QX61o{E! zvnq6Zam(m2=%YVZef&(kQOvs-^isT^-cjyD$Ilh-Dzvo|b-m6{(_a>K>ic=en}_}q zbgy`e(2LNk9dC25FCgAepf51T`#M*==K1dy`}xnr(S#S_k;heU$LLd_H~Hv`p^t$6 z8tRtE{p+Q1H*vIK-fn~bfQh4);#g3QBZqbd^!JXV06hYIkh>q(`nZKfzrjA+N1!)A zAL-uSyja?~55PSDbBVr}KE^r@7m?*KWs**9z!4AAJM#-O$f) zZ|_=T-3I+*=q4s-JYDN6d!T;;{ZzL;rQE-HSt>$raqBKmtpR%d3Et~dW1+V|_v*h5 zdK`MSc?Zc_f&Wc_-q+o~>lt7J^ceK>-1^*d{M(>UhJL17cX!IF&__Y{I!;;WF`w=8(tfq`)r?^g`V?&MHO65)0B(jpr(z84hbXgs6nfyK zgZ3JLKI`66KE`qAVd!4RC<%QObgyHShCUa%=l(-a`m~>i-s#hR5&CwI_RamOfSt@k z--pk^Kg}**OUAFR{c>0+zovUbgwZD;-WYXy4SUFAcPj^6>|#bwz>S6 zInfM#7Id#;J`?(5(7ld%2lVel_lmCz`ddEwR_Jd-_qxaJhQ7mR`yhZ9+5z7)FG{0PGQ?ttz! z{sW<}fR14-$LG3tHbY+t-7Ef?(6{^O9nkxnTK(OmwExh1L$7vSHu_fRCqT!ePB}jN z)u(h_-wnMVbX@w%x+|Y0h#l|iqYs20hVFH5ZiXI!ey+Ryw(>P`CUn#PId0wk{tta1 zbaVZ2j{i;N?Yp24f&PG757-L;rTvG#8oF0}yP>Ciwhx|;bwr=-2SVTBvwbu45d*yY zp9#GI`izSBZ3ErJ-vND&kKP4+qmRB7`X|t#1r6t?#|2OA))@acan^d-iMp!R_r#CN z@3U#tIpfTO-Los&uwPhB3|Z(&=w9bZ9{POfUh}jFz1>F-W5Wlbd(G1*^bQ|A4t*JP zuj8DAz7V?CJWNAh?z4Rs`XcCF^DGbD?4MWvMdj7I$BV?lsS%(BFjaH_s-a z&a(~P$7mt+=b(Gdvo+A)g6=iXHbLJF{Yw>dq&&}dK%X$kf1d3}odIWg&$IqRFkhip zn`gM4T6LI5^Pv9<wOJqgnkg)R~t_g-z4Zo=+)+q(HBDh)JI*y(jEkYKfL<*|)BZZ>uRxz=+Shf4fPF)a0Bwf8 z54ztz>_VM3pM5w0{b`?lsK*J}KHPhrjDo%zy4O5tg`R?L))LD5@cYsrn|*ADKB>`r zo^?W>2>m!*W1Q`4k1E|P&GuWMk3G+Op6!A@&PP80eLQrp`0Md7b&-!g3i>%ddMoq+ z&~aLqtS$Dm+wL+f&-Rr%l9eNr%it_fZbEp%-3(!6HA9@CQU-$O1W*hoF?I5&vs>%@uzH<+sAIn4uhhwzX<(u_x4N6`#A~vJ3jhC=zsRn*Fdjt^3I3e1ihb+z5{x1=oQ!2`^xd{ zgFX!Uh3@!qtjw%1`_~U9!Z$b`3t;b+zI_SAALXce$c(_Zdu2Iv*%cIi1KP|BP)BXSb-czf2Yvd5-eXvRehqZ5F|=R?&4ylW z49zoX5$8%9^!M>O`0B*+aWL1m?d5Z7EZR9?ly`1S8}u`vx1t^A`WUbixXrO%0euGa zyDRj0&Rp35{SBY(w?Y4lPyc(M*IZP6KTZF27vTGcuzj_AiP0ONe+vB!cYLn(jj_