#include <algorithm>
#include <iostream>
#include <string>
#include <unordered_set>
#include <vector>

using namespace std;

class Address {
    string city_ = "";
    string street_ = "";
    size_t house_number_ = 0;
    size_t building_ = 0;
    size_t entrance_ = 0;
    string doorphone_ = "";
    size_t flat_ = 0;

public:
    Address() {}
    Address(const string& city, const string& street, size_t house_number,
        size_t building, size_t entrance, string doorphone, size_t flat)
        : city_(city)
        , street_(street)
        , house_number_(house_number)
        , building_(building)
        , entrance_(entrance)
        , doorphone_(doorphone)
        , flat_(flat)
    {}

    Address(const Address& address) :
        Address(address.city_, address.street_, address.house_number_,
            address.building_, address.entrance_, address.doorphone_, address.flat_)
    {}

    ~Address() {}

    Address operator=(const Address& address) {
        if (&address != this) {
            city_ = address.city_;
            street_ = address.street_;
            house_number_ = address.house_number_;
            building_ = address.building_;
            entrance_ = address.entrance_;
            doorphone_ = address.doorphone_;
            flat_ = address.flat_;
        }
        return *this;
    }

    string GetCity() { return city_; }
    string GetStreet() { return street_; }
    size_t GetHouseNumber() { return house_number_; }
    size_t GetBuilding() { return building_; }
    size_t GetEntrance() { return entrance_; }
    string GetDoorphone() { return doorphone_; }
    size_t GetFlat() { return flat_; }

    void SetCity(const string& city) { city_ = city; }
    void SetStreet(const string street) { street_ = street; }
    void SetHouseNumber(size_t house_number) { house_number_ = house_number; }
    void SetBuilding(size_t building) { building_ = building; }
    void SetEntrance(size_t entrance) { entrance_ = entrance; }
    void SetDoorphone(const string& doorphone) { doorphone_ = doorphone; }
    void SetFlat(size_t flat) { flat_ = flat; }

    void Print() {
        cout << "город " << GetCity() << ", улица " << GetStreet() << ", дом номер " << GetHouseNumber()
            << ", корпус " << GetBuilding() << ", подъезд " << GetEntrance()
            << ", квартира " << GetFlat() << ' ' << ", код домофона " << GetDoorphone() << '\n';
    }
    void Reset() {
        city_ = "";
        street_ = "";
        house_number_ = 0;
        building_ = 0;
        entrance_ = 0;
        doorphone_ = "";
        flat_ = 0;
    }
};

class Date {
private:
    size_t year_;
    size_t month_;
    size_t day_;

public:
    Date(size_t year, size_t month, size_t day) : year_(year), month_(month), day_(day) {};
    Date(size_t month, size_t day) : Date(0, month, day) {};
    Date(size_t day) : Date(0, 0, day) {}
    Date() : Date(0, 0, 0) {}
    Date(const Date& date) : Date(date.year_, date.month_, date.day_) {}
    ~Date() {}

    Date& operator=(const Date& date) {
        if (&date != this) {
            year_ = date.year_;
            month_ = date.month_;
            day_ = date.day_;
        }
        return *this;
    }

    size_t GetYear() const {
        return year_;
    }
    size_t GetMonth() const {
        return month_;
    }
    size_t GetDay() const {
        return day_;
    }
    void SetYear(size_t year) {
        year_ = year;
    }
    void SetMonth(size_t month) {
        month_ = month;
    }
    void SetDay(size_t day) {
        day_ = day;
    }
    void Print() {
        cout << day_ << '.' << month_ << '.' << year_<< '\n';
    }
};

bool operator<(const Date& lhs, const Date& rhs) {
    if (lhs.GetYear() != rhs.GetYear()) {
        return lhs.GetYear() < rhs.GetYear();
    }
    if (lhs.GetMonth() != rhs.GetMonth()) {
        return lhs.GetMonth() < rhs.GetMonth();
    }
    return lhs.GetDay() < rhs.GetDay();
}

class Person {
private:
    string surname_ = "";
    string name_ = "";
    string patronymic_ = "";
    bool is_male_ = false;
    size_t age_ = 0;

    Date date_of_birth_;

    Address residence_;
    Address registration_;

public:
    Person(const string& surname, const string& name, const string& patronymic,
        bool is_male, size_t age, const Date& date, const Address& residence, const Address& registration)
        : surname_(surname)
        , name_(name)
        , patronymic_(patronymic)
        , is_male_(is_male)
        , age_(age)
        , date_of_birth_(date)
        , residence_(residence)
        , registration_(registration)
    {}

    Person() {}

    Person(const Person& person)
        : Person(person.surname_, person.name_, person.patronymic_, person.is_male_,
            person.age_, person.date_of_birth_,
            person.residence_, person.registration_)
    {}

    ~Person() {}

    Person& operator= (const Person& person) {
        if (&person != this) {
            surname_ = person.surname_;
            name_ = person.name_;
            patronymic_ = person.patronymic_;
            is_male_ = person.is_male_;
            age_ = person.age_;
            date_of_birth_ = person.date_of_birth_;
            residence_ = person.residence_;
            registration_ = person.registration_;
        }
        return *this;
    }

    void SetSurname(const string& surname) {
        surname_ = surname;
    }
    void SetName(const string& name) {
        name_ = name;
    }
    void SetPatronymic(const string& patrnomic) {
        patronymic_ = patrnomic;
    }
    void SetIsMale(bool is_male) {
        is_male_ = is_male;
    }
    void SetAge(size_t age) {
        age_ = age;
    }
    void SetDateOfBirth(const Date& date) {
        date_of_birth_ = date;
    }
    void SetResidenceAddress(const Address& address) {
        residence_ = address;
    }
    void SetRegistrationAddress(const Address& address) {
        registration_ = address;
    }

    string GetSurname() const {
        return surname_;
    }
    string GetName() const {
        return name_;
    }
    string GetPatronymic() const {
        return patronymic_;
    }
    bool GetIsMale() const {
        return is_male_;
    }
    size_t GetAge() const {
        return age_;
    }
    Date GetDateOfBirth() const {
        return date_of_birth_;
    }
    Address GetResidenceAddress() const {
        return residence_;
    }
    Address GetRegistrationAddress() const {
        return registration_;
    }

    void Print() const {
        cout << GetSurname() << ' ' << GetName() << ' ' << GetPatronymic() << ' ';
        if (is_male_) cout << "мужчина";
        else cout << "женщина";

        cout << '\n' << GetAge() << " лет, родился ";
        GetDateOfBirth().Print();
        cout << "Адрес прохивания: ";
        GetResidenceAddress().Print();
        cout << "Адрес регистрации: ";
        GetRegistrationAddress().Print();
    }
};

class Employee : virtual public Person {
    Address address_;
    string name_of_company_ = "";
    bool got_job_ = false;

public:
    Employee(const string& surname, const string& name, const string& patronymic,
        bool is_male, size_t age, const Date& date, const Address& residence, const Address& registration,
        Address& address, const string& name_of_company, bool got_job)
        : Person(surname, name, patronymic, is_male, age, date, residence, registration)
        , address_(address)
        , name_of_company_(name_of_company)
        , got_job_(got_job)
    {}

    Employee(const Person& person, Address& address, const string& name_of_company, bool got_job)
        : Person(person)
        , address_(address)
        , name_of_company_(name_of_company)
        , got_job_(got_job)
    {}

    Employee& operator= (const Employee& employee) {
        if (&employee != this) {
            SetSurname(employee.GetSurname());
            SetName(employee.GetName());
            SetPatronymic(employee.GetPatronymic());
            SetIsMale(employee.GetIsMale());
            SetAge(employee.GetAge());
            SetDateOfBirth(employee.GetDateOfBirth());
            SetResidenceAddress(employee.GetResidenceAddress());
            SetRegistrationAddress(employee.GetRegistrationAddress());
            address_ = employee.GetCompanyAddress();
            name_of_company_ = employee.GetCompanyName();
            got_job_ = employee.GetGotJob();
        }
        return *this;
    }

    Employee() : Person() {}

    string GetCompanyName() const {
        return name_of_company_;
    }
    Address GetCompanyAddress() const {
        return address_;
    }
    bool GetGotJob() const {
        return got_job_;
    }

    void SetGotJob(bool got_job) {
        got_job_ = got_job;
        if (!got_job) ToQuitJob();
    }
    void SetCompanyName(const string& name_of_company) {
        name_of_company_ = name_of_company;
        SetGotJob(true);
    }
    void SetCompanyAddress(const Address& address) {
        address_ = address;
        SetGotJob(true);
    }
    void ToQuitJob() {
        got_job_ = false;
        name_of_company_ = "";
        address_.Reset();
    }

    void Print() {
        Person::Print();
        cout << '\n';
        if (!GetGotJob()) {
            cout << "Берзработный";
            return;
        }
        cout << "работает в компании " << GetCompanyName() << '\n'
            << "по сдресу:";
        GetCompanyAddress().Print();
    }
};

class Worker : virtual public Person {
private:
    unordered_set<string> specialisations_;
public:
    Worker() {}
    Worker(const Person& person, const unordered_set<string>& specializations)
        : Person(person)
        , specialisations_(specializations)
    {}

    Worker(const Worker& worker)
        : Person(worker.GetSurname(), worker.GetName(), worker.GetPatronymic(),
            worker.GetIsMale(), worker.GetAge(), worker.GetDateOfBirth(),
            worker.GetResidenceAddress(), worker.GetRegistrationAddress())
        , specialisations_(worker.specialisations_)
    {}

    ~Worker() {}
    Worker operator=(const Worker& worker) {
        if (&worker != this) {
            SetSurname(worker.GetSurname());
            SetName(worker.GetName());
            SetPatronymic(worker.GetPatronymic());
            SetIsMale(worker.GetIsMale());
            SetAge(worker.GetAge());
            SetDateOfBirth(worker.GetDateOfBirth());
            SetResidenceAddress(worker.GetResidenceAddress());
            SetRegistrationAddress(worker.GetRegistrationAddress());
            specialisations_ = worker.specialisations_;
        }
        return *this;
    }

    unordered_set<string> GetSpecializations() const { return specialisations_; }
    void SetSpecialization(const unordered_set<string>& specializations) { specialisations_ = specializations; }
    void PrintSpecializations() const {
        for (auto& spec : specialisations_) {
            cout << spec << ' ';
        }
    }
    void AddSpecialization(const string& specialization) {
        specialisations_.insert(specialization);
    }
    void DeleteSpecialization(const string& specialization) {
        specialisations_.erase(specialization);
    }
    void ChangeSpecialization(const string& from, const string& to) {
        DeleteSpecialization(from);
        specialisations_.insert(to);
    }
    void Print() const {
        Person::Print();
        cout << "\nрабочий обладает следующими специальностями:\n";
        for (auto spec : specialisations_) {
            cout << spec << ' ';
        }
        cout << endl;
    }
};

class Engineer : virtual public Employee {
    vector<Worker> workers_;
public:
    Engineer() {}
    Engineer(const Employee& employee) {
        SetSurname(employee.GetSurname());
        SetName(employee.GetName());
        SetPatronymic(employee.GetPatronymic());
        SetIsMale(employee.GetIsMale());
        SetAge(employee.GetAge());
        SetDateOfBirth(employee.GetDateOfBirth());
        SetResidenceAddress(employee.GetResidenceAddress());
        SetRegistrationAddress(employee.GetRegistrationAddress());
        SetCompanyAddress(employee.GetCompanyAddress());
        SetCompanyName(employee.GetCompanyName());
        SetGotJob(employee.GetGotJob());
    }

    Engineer(const Engineer& engineer) {
        SetSurname(engineer.GetSurname());
        SetName(engineer.GetName());
        SetPatronymic(engineer.GetPatronymic());
        SetIsMale(engineer.GetIsMale());
        SetAge(engineer.GetAge());
        SetDateOfBirth(engineer.GetDateOfBirth());
        SetResidenceAddress(engineer.GetResidenceAddress());
        SetRegistrationAddress(engineer.GetRegistrationAddress());
        SetCompanyAddress(engineer.GetCompanyAddress());
        SetCompanyName(engineer.GetCompanyName());
        SetGotJob(engineer.GetGotJob());
        workers_ = engineer.workers_;
    }

    ~Engineer() {}

    Engineer operator=(const Engineer& engineer) {
        if (&engineer != this) {
            SetSurname(engineer.GetSurname());
            SetName(engineer.GetName());
            SetPatronymic(engineer.GetPatronymic());
            SetIsMale(engineer.GetIsMale());
            SetAge(engineer.GetAge());
            SetDateOfBirth(engineer.GetDateOfBirth());
            SetResidenceAddress(engineer.GetResidenceAddress());
            SetRegistrationAddress(engineer.GetRegistrationAddress());
            SetCompanyAddress(engineer.GetCompanyAddress());
            SetCompanyName(engineer.GetCompanyName());
            SetGotJob(engineer.GetGotJob());
            workers_ = engineer.workers_;
        }
        return *this;
    }

    void AddWorker(const Worker& worker) {
        workers_.push_back(worker);
    }
    void DismissWorker(const string& specialization) {
        for (auto worker = workers_.begin(); worker != workers_.end(); ++worker) {
            const auto& worker_specializations = worker->GetSpecializations();
            if (worker_specializations.find(specialization) != worker_specializations.end()) {
                workers_.erase(worker);
                return;
            }
        }
    }
    void DismissAllWorkers() {
        workers_.clear();
    }
    void PrintWorkers() {
        for (const auto& worker : workers_) {
            worker.PrintSpecializations();
            cout << '\n';
        }
    }
    void SortWorkersByBirthDate() {
        sort(begin(workers_), end(workers_), [](const Worker& lhs, const Worker& rhs) {
            return lhs.GetDateOfBirth() < rhs.GetDateOfBirth();
        });
    }
    void PrintWorkersData() {
        for (const auto worker : workers_) {
            worker.Print();
        }
    }
    void Print() {
        Employee::Print();

        if (workers_.empty()) return;

        cout << "\nЗадачи данного инженера выполняют " << workers_.size() << " рабочих.\n"
             << "Вот их данные : \n";
        PrintWorkersData();
    }
    size_t GetWorkersCount() { return workers_.size(); }
    vector<Worker> GetWorkers() const { return workers_; }
    void SetWorkers(const vector<Worker> w) { workers_ = w; }
};

class EngeineerWorker : public Engineer, public Worker {
public:
    EngeineerWorker() {}
    ~EngeineerWorker() {}
    EngeineerWorker(const Engineer& e, const Worker& w) : Engineer(e), Worker(w) {}

    EngeineerWorker& operator=(const EngeineerWorker& ew) {
        if (&ew != this) {
            SetSurname(ew.GetSurname());
            SetName(ew.GetName());
            SetPatronymic(ew.GetPatronymic());
            SetIsMale(ew.GetIsMale());
            SetAge(ew.GetAge());
            SetDateOfBirth(ew.GetDateOfBirth());
            SetResidenceAddress(ew.GetResidenceAddress());
            SetRegistrationAddress(ew.GetRegistrationAddress());
            SetCompanyAddress(ew.GetCompanyAddress());
            SetCompanyName(ew.GetCompanyName());
            SetGotJob(ew.GetGotJob());
            SetWorkers(ew.GetWorkers());
            SetSpecialization(ew.GetSpecializations());
        }
        return *this;
    }

    void EWPrint() {
        Engineer::Person::Print();
        if (Worker::GetSpecializations().size() > 0) {
            cout << "Как рабочий данный инженер-рабочий является:\n";
            for (const auto& spec : Worker::GetSpecializations()) {
                cout << spec << ' ';
            }
        }
        if (Engineer::GetWorkersCount()) {
            cout << "\nВ команде данного инженера находятся следующие рабочие\n";
            Engineer::PrintWorkersData();
        }
    }
};

bool GetAndCheckString(string& str) {
    if (!(cin >> str)) {
        cout << "Введено неверное значение\n";
        return false;
    }
    for (auto ch : str) {
        if ('a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z') continue;

        cout << "Введено неверное значение\n";
        return false;
    }

    return true;
}
bool GetAndCheckPositiveInteger(size_t& number) {
    int64_t value;
    if (!(cin >> value) || value < 0) {
        cout << "Введено неверное значение\n";
        return false;
    }
    number = static_cast<size_t>(value);
    return true;
}
bool GetAndCheckStringDoorphone(string& doorphone) {
    if (!(cin >> doorphone)) {
        cout << "Введено неверное значение\n";
        return false;
    }
    for (auto ch : doorphone) {
        if ('0' <= ch && ch <= '9') continue;
        if (ch == '#' || ch == '*') continue;

        cout << "Введено неверное значение\n";
        return false;
    }

    return true;
}
bool GetAddress(Address& address) {
    string city, street, doorphone;
    cout << "Введите город\n";
    if (!GetAndCheckString(city)) {
        return false;
    }
    cout << "Введите улицу\n";
    if (!GetAndCheckString(street)) {
        return false;
    }
    cout << "Введите домофон\n";
    if (!GetAndCheckStringDoorphone(doorphone)) {
        return false;
    }

    size_t house, building, entrance, flat;
    cout << "Введите номер дома\n";
    if (!GetAndCheckPositiveInteger(house)) {
        return false;
    }
    cout << "Введите корпус дома\n";
    if (!GetAndCheckPositiveInteger(building)) {
        return false;
    }
    cout << "Введите номер подъезда\n";
    if (!GetAndCheckPositiveInteger(entrance)) {
        return false;
    }
    cout << "Введите номер квартиры\n";
    if (!GetAndCheckPositiveInteger(flat)) {
        return false;
    }

    address.SetCity(city);
    address.SetStreet(street);
    address.SetDoorphone(doorphone);
    address.SetHouseNumber(house);
    address.SetBuilding(building);
    address.SetEntrance(entrance);
    address.SetFlat(flat);

    return true;
}
bool GetDate(Date& date) {
    size_t year, month, day;
    cout << "Введите год рождения\n";
    if (!GetAndCheckPositiveInteger(year)) {
        return false;
    }
    if (year > 2023) {
        cout << "Введено неверное значение\n";
    }
    cout << "Введите месяц рождения\n";
    if (!GetAndCheckPositiveInteger(month)) {
        return false;
    }
    if (month == 0 || month > 12) {
        cout << "Введено неверное значение\n";
    }
    cout << "Введите день рождения\n";
    if (!GetAndCheckPositiveInteger(day)) {
        return false;
    }
    if (day == 0 || day > 31) {
        cout << "Введено неверное значение\n";
    }
    Date new_date(year, month, day);
    date = new_date;
    return true;
}
bool GetPerson(Person& person) {
    string surname, name, patronymic;
    cout << "Введите фамилию:\n";
    if (!GetAndCheckString(surname)) {
        return false;
    }
    cout << "Введите имя:\n";
    if (!GetAndCheckString(name)) {
        return false;
    }
    cout << "Введите отчество:\n";
    if (!GetAndCheckString(patronymic)) {
        return false;
    }

    bool is_male = false;
    cout << "Введите пол: m/f\n";
    char c;
    cin >> c;
    if (c == 'm') {
        is_male = true;
    }
    else if (c == 'f') {}
    else {
        cout << "Введено неверное значение\n";
        return false;
    }

    size_t age;
    cout << "Введите возраст:\n";
    if (!GetAndCheckPositiveInteger(age)) {
        return false;
    }

    Date date_of_birth;
    if (!GetDate(date_of_birth)) {
        return false;
    }
    cout << "Введите адрес регистрации\n";
    Address registration;
    if (!GetAddress(registration)) {
        return false;
    }

    cout << "Введите адрес проживания\n";
    Address residence;
    if (!GetAddress(residence)) {
        return false;
    }

    person.SetSurname(surname);
    person.SetName(name);
    person.SetPatronymic(patronymic);
    person.SetIsMale(is_male);
    person.SetAge(age);
    person.SetDateOfBirth(date_of_birth);
    person.SetResidenceAddress(residence);
    person.SetRegistrationAddress(registration);

    return true;
}
bool GetEmployee(Employee& employe) {
    Person person;
    if (!GetPerson(person)) {
        return false;
    }

    cout << "Введите адрес компании\n";
    Address address;
    if (!GetAddress(address)) {
        return false;
    }

    string name_of_company;
    cout << "Введите название компании\n";
    if (!GetAndCheckString(name_of_company)) {
        return false;
    }

    bool got_job = false;
    cout << "Введите y/n, если в данный момент служащи имеет/не имеет работу\n";
    char ch;
    cin >> ch;
    if (ch == 'y') {
        got_job = true;
    }
    else if (ch == 'n') {
        got_job = false;
    }
    else {
        return false;
    }

    Employee new_employe(person, address, name_of_company, got_job);
    employe = new_employe;
    return true;
}
bool GetWorker(Worker& worker) {
    Person person;
    if (!GetPerson(person)) return false;
    size_t specialisations_count;
    cout << "Введите количество специализаций рабочего\n";
    if (!GetAndCheckPositiveInteger(specialisations_count)) {
        return 0;
    }
    unordered_set<string> specializations;
    for (size_t i = 0; i < specialisations_count; ++i) {
        cout << "Введите специализацию рабочего\n";
        string specialization;
        cin >> specialization;
        specializations.insert(specialization);
    }
    Worker new_worker(person, specializations);
    worker = new_worker;
    return true;
}
bool GetEngineer(Engineer& engineer) {
    Employee employee;
    if (!GetEmployee(employee)) return false;
    Engineer new_engineer(employee);
    engineer = new_engineer;
    return true;
}
bool GetEngineerWorker(EngeineerWorker& engineer_worker) {
    Engineer engineer;
    if (!GetEngineer(engineer)) return false;

    cout << "Введите количество специализаций инженера-рабочего\n";
    size_t specialisations_count = 0;
    if (!GetAndCheckPositiveInteger(specialisations_count)) {
        return 0;
    }
    unordered_set<string> specializations;
    for (size_t i = 0; i < specialisations_count; ++i) {
        cout << "Введите специализацию инженера-рабочего\n";
        string specialization;
        cin >> specialization;
        specializations.insert(specialization);
    }

    Worker worker;
    EngeineerWorker ew(engineer, worker);
    ew.SetSpecialization(specializations);
    engineer_worker = ew;
    return true;
}

int main() {
    setlocale(LC_ALL, "rus");
    vector<Person> persons;
    vector<Employee> employes;
    vector<Worker> workers;
    vector<Engineer> engineers;
    vector<EngeineerWorker> engineers_workers;

    while (true) {
        cout << R"(
Данные вводятся на латинице.
Нажмите:
1 - если хотите создать персону.
2 - если хотите создать служащего
3 - если хотите содать рабочего
4 - если хотите создать инженера
5 - если хотите создать инженера владеющего также навыками рабочего
6 - если хотите перейти к работе с созданными объектами
)";
        size_t value;
        if (!GetAndCheckPositiveInteger(value)) {
            return 0;
        }

        if (value > 6) {
            cout << "Введено неверное значение\n";
            return 0;
        }

        if (value == 6) {
            break;
        }

        if (value == 1) {
            Person person;
            if (!GetPerson(person)) {
                return 0;
            }
            persons.push_back(person);
            continue;
        }

        if (value == 2) {
            Employee employe;
            if (!GetEmployee(employe)) {
                return 0;
            }

            employes.push_back(employe);
            continue;
        }

        if (value == 3) {
            Worker worker;
            if (!GetWorker(worker)) {
                return 0;
            }
            workers.push_back(worker);
            continue;
        }

        if (value == 4) {
            Engineer engineer;
            if (!GetEngineer(engineer)) {
                return 0;
            }
            engineers.push_back(engineer);
            continue;
        }

        if (value == 5) {
            EngeineerWorker engineer_worker;
            if (!GetEngineerWorker(engineer_worker)) {
                return 0;
            }
            engineers_workers.push_back(engineer_worker);
            continue;
        }

    }

    cout << "Вы создали \n"
        << persons.size() << " - персон\n"
        << employes.size() << " - служащих\n"
        << workers.size() << " - рабочих\n"
        << engineers.size() << " - инженеров\n"
        << engineers_workers.size() << " - инженеров-рабочих\n";

    while (true) {
        cout << R"(
Вы можете воспользовать специальными функциями и свойствами объектов любого класса.
Ведите значение соответствующее типу объякта
0 - персона
1 - служащий
2 - рабочий
3 - инженер
4 - инженер-рабочий
5 - выход
)";

        size_t object_type;
        if (!GetAndCheckPositiveInteger(object_type)) return 0;
        if (object_type > 6) {
            cout << "Введено неверное значение";
            return 0;
        }
        if (object_type == 5) return 0;

        if (object_type == 0) {
            cout << "У Вас есть " << persons.size() << " персон.\n";
            if (persons.size() == 0) {
                cout << "Запустите программу заново и создате персону\n";
                return 0;
            }
            size_t idx = 0;
            if (persons.size() > 1) {
                cout << "Введите значение - индекс, в диапазоне [0, " << persons.size()
                    << "), с какой именно персоной Вы хотите поработать ? \n";
                if (!GetAndCheckPositiveInteger(idx)) return 0;
                if (idx >= persons.size()) {
                    cout << "Введено неверное значени индекса\n";
                    return 0;
                }
            }
            Person& person = persons[idx];
            cout << "Данные персоны до выполненной операции\n";
            person.Print();
            cout << R"(
Выберете номер операции, которую хотите собершить с персоной\n
0 - поменять фамилию
1 - поменять имя
2 - поменять отчество
3 - поменять пол
4 - поменять возраст
5 - поменять дату рождения
6 - поменять адрес проживания
7 - поменять адрес регистрации
8 - выйти
)";
            size_t operation_idx;
            if (!GetAndCheckPositiveInteger(operation_idx)) return 0;

            if (operation_idx > 8) {
                cout << "Введен неверный код операции\n";
            }
            if (operation_idx == 8) return 0;

            if (operation_idx == 0) {
                string new_surname;
                if (!GetAndCheckString(new_surname)) return 0;
                person.SetSurname(new_surname);
            }
            if (operation_idx == 1) {
                string new_name;
                if (!GetAndCheckString(new_name)) return 0;
                person.SetName(new_name);
            }
            if (operation_idx == 2) {
                string new_patronymic;
                if (!GetAndCheckString(new_patronymic)) return 0;
                person.SetPatronymic(new_patronymic);
            }
            if (operation_idx == 3) {
                char c;
                cout << "Введите 0, если пол - мужской, иначе введите 1\n";
                cin >> c;
                if (c != '0' && c != '1') {
                    cout << "Введено неверное значение\n";
                    return 0;
                }
                person.SetIsMale(c == 0);
            }
            if (operation_idx == 4) {
                size_t new_age;
                if (!GetAndCheckPositiveInteger(new_age)) return 0;
                person.SetAge(new_age);
            }
            if (operation_idx == 5) {
                Date new_date;
                if (!GetDate(new_date)) return 0;
                person.SetDateOfBirth(new_date);
            }
            if (operation_idx == 6) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                person.SetResidenceAddress(new_address);
            }
            if (operation_idx == 7) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                person.SetRegistrationAddress(new_address);
            }

            cout << "Данные персоны после выполненной операции\n";
            person.Print();
        }
        if (object_type == 1) {
            cout << "У Вас есть " << employes.size() << " служащих.\n";
            if (employes.size() == 0) {
                cout << "Запустите программу заново и создате служащего\n";
                return 0;
            }
            size_t idx = 0;
            if (employes.size() > 1) {
                cout << "Введите значение - индекс, в диапазоне [0, " << employes.size()
                    << "), с каким именно служащим Вы хотите поработать ? \n";
                if (!GetAndCheckPositiveInteger(idx)) return 0;
                if (idx >= employes.size()) {
                    cout << "Введено неверное значени индекса\n";
                    return 0;
                }
            }
            Employee& employe = employes[idx];
            cout << "Данные персоны до выполненной операции\n";
            employe.Print();
            cout << R"(
Выберете номер операции, которую хотите собершить с персоной\n
0 - поменять фамилию
1 - поменять имя
2 - поменять отчество
3 - поменять пол
4 - поменять возраст
5 - поменять дату рождения
6 - поменять адрес проживания
7 - поменять адрес регистрации
8 - уволиться
9 - поменять название компании
10 - поменять адрес компании
11 - выйти
)";
            size_t operation_idx;
            if (!GetAndCheckPositiveInteger(operation_idx)) return 0;

            if (operation_idx > 11) {
                cout << "Введен неверный код операции\n";
            }
            if (operation_idx == 11) return 0;

            if (operation_idx == 0) {
                string new_surname;
                if (!GetAndCheckString(new_surname)) return 0;
                employe.SetSurname(new_surname);
            }
            if (operation_idx == 1) {
                string new_name;
                if (!GetAndCheckString(new_name)) return 0;
                employe.SetName(new_name);
            }
            if (operation_idx == 2) {
                string new_patronymic;
                if (!GetAndCheckString(new_patronymic)) return 0;
                employe.SetPatronymic(new_patronymic);
            }
            if (operation_idx == 3) {
                char c;
                cout << "Введите 0, если пол - мужской, иначе введите 1\n";
                cin >> c;
                if (c != '0' && c != '1') {
                    cout << "Введено неверное значение\n";
                    return 0;
                }
                employe.SetIsMale(c == 0);
            }
            if (operation_idx == 4) {
                size_t new_age;
                if (!GetAndCheckPositiveInteger(new_age)) return 0;
                employe.SetAge(new_age);
            }
            if (operation_idx == 5) {
                Date new_date;
                if (!GetDate(new_date)) return 0;
                employe.SetDateOfBirth(new_date);
            }
            if (operation_idx == 6) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                employe.SetResidenceAddress(new_address);
            }
            if (operation_idx == 7) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                employe.SetRegistrationAddress(new_address);
            }
            if (operation_idx == 8) {
                employe.ToQuitJob();
            }
            if (operation_idx == 9) {
                string new_company_name;
                if (!GetAndCheckString(new_company_name)) return 0;
                employe.SetCompanyName(new_company_name);
            }
            if (operation_idx == 10) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                employe.SetCompanyAddress(new_address);
            }

            cout << "Данные персоны после выполненной операции\n";
            employe.Print();
        }
        if (object_type == 2) {
            cout << "У Вас есть " << workers.size() << " рабочих.\n";
            if (workers.size() == 0) {
                cout << "Запустите программу заново и создате рабочего\n";
                return 0;
            }
            size_t idx = 0;
            if (workers.size() > 1) {
                cout << "Введите значение - индекс, в диапазоне [0, " << workers.size()
                    << "), с каким именно рабочим Вы хотите поработать ? \n";
                if (!GetAndCheckPositiveInteger(idx)) return 0;
                if (idx >= workers.size()) {
                    cout << "Введено неверное значени индекса\n";
                    return 0;
                }
            }
            Worker& worker = workers[idx];
            cout << "Данные персоны до выполненной операции\n";
            worker.Print();
            cout << R"(
Выберете номер операции, которую хотите собершить с персоной\n
0 - поменять фамилию
1 - поменять имя
2 - поменять отчество
3 - поменять пол
4 - поменять возраст
5 - поменять дату рождения
6 - поменять адрес проживания
7 - поменять адрес регистрации
8 - задать специализации
9 - добавить специализацию
10 - удалить специализацию
11 - сменить специализацию
12 - выйти
)";
            size_t operation_idx;
            if (!GetAndCheckPositiveInteger(operation_idx)) return 0;

            if (operation_idx > 12) {
                cout << "Введен неверный код операции\n";
            }
            if (operation_idx == 12) return 0;

            if (operation_idx == 0) {
                string new_surname;
                if (!GetAndCheckString(new_surname)) return 0;
                worker.SetSurname(new_surname);
            }
            if (operation_idx == 1) {
                string new_name;
                if (!GetAndCheckString(new_name)) return 0;
                worker.SetName(new_name);
            }
            if (operation_idx == 2) {
                string new_patronymic;
                if (!GetAndCheckString(new_patronymic)) return 0;
                worker.SetPatronymic(new_patronymic);
            }
            if (operation_idx == 3) {
                char c;
                cout << "Введите 0, если пол - мужской, иначе введите 1\n";
                cin >> c;
                if (c != '0' && c != '!') {
                    cout << "Введено неверное значение\n";
                    return 0;
                }
                worker.SetIsMale(c == 0);
            }
            if (operation_idx == 4) {
                size_t new_age;
                if (!GetAndCheckPositiveInteger(new_age)) return 0;
                worker.SetAge(new_age);
            }
            if (operation_idx == 5) {
                Date new_date;
                if (!GetDate(new_date)) return 0;
                worker.SetDateOfBirth(new_date);
            }
            if (operation_idx == 6) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                worker.SetResidenceAddress(new_address);
            }
            if (operation_idx == 7) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                worker.SetRegistrationAddress(new_address);
            }
            if (operation_idx == 8) {
                cout << "Сколько специализаций Вы планируете ввести?\n";
                size_t sc;
                if (!GetAndCheckPositiveInteger(sc)) {
                    return 0;
                }
                unordered_set<string> new_specs;
                for (size_t i = 0; i < sc; ++i) {
                    string spec;
                    cin >> spec; //не проверяю цифры так специализации рабочих могут быть странными
                    new_specs.insert(spec);
                }
                worker.SetSpecialization(new_specs);
            }
            if (operation_idx == 9) {
                string ns;
                cin >> ns;
                worker.AddSpecialization(ns);
            }
            if (operation_idx == 10) {
                string spec;
                cin >> spec;
                worker.DeleteSpecialization(spec);
            }
            if (operation_idx == 11) {
                string from, to;
                cout << "Введите старую и новую специализации\n";
                cin >> from >> to;
                worker.ChangeSpecialization(from, to);
            }

            cout << "Данные рабочего после выполненной операции\n";
            worker.Print();
        }
        if (object_type == 3) {
            cout << "У Вас есть " << engineers.size() << " инженеров.\n";
            if (engineers.size() == 0) {
                cout << "Запустите программу заново и создате инженера\n";
                return 0;
            }
            size_t idx = 0;
            if (engineers.size() > 1) {
                cout << "Введите значение - индекс, в диапазоне [0, " << engineers.size()
                    << "), с каким именно инженером Вы хотите поработать ? \n";
                if (!GetAndCheckPositiveInteger(idx)) return 0;
                if (idx >= engineers.size()) {
                    cout << "Введено неверное значени индекса\n";
                    return 0;
                }
            }
            Engineer& engineer = engineers[idx];
            cout << "Данные персоны до выполненной операции\n";
            engineer.Print();
            cout << R"(
Выберете номер операции, которую хотите собершить с персоной\n
0 - поменять фамилию
1 - поменять имя
2 - поменять отчество
3 - поменять пол
4 - поменять возраст
5 - поменять дату рождения
6 - поменять адрес проживания
7 - поменять адрес регистрации
8 - уволиться
9 - поменять название компании
10 - поменять адрес компании
11 - добавить рабочего
12 - уволить рабочего
13 - уволить всех рабочих
14 - вывести на экран специализации всех рабочих
15 - вывести на экран все данные рабочих
16 - отсортировать рабочих по дате рождения
17 - выйти
)";
            size_t operation_idx;
            if (!GetAndCheckPositiveInteger(operation_idx)) return 0;

            if (operation_idx > 17) {
                cout << "Введен неверный код операции\n";
            }
            if (operation_idx == 17) return 0;

            if (operation_idx == 0) {
                string new_surname;
                if (!GetAndCheckString(new_surname)) return 0;
                engineer.SetSurname(new_surname);
            }
            if (operation_idx == 1) {
                string new_name;
                if (!GetAndCheckString(new_name)) return 0;
                engineer.SetName(new_name);
            }
            if (operation_idx == 2) {
                string new_patronymic;
                if (!GetAndCheckString(new_patronymic)) return 0;
                engineer.SetPatronymic(new_patronymic);
            }
            if (operation_idx == 3) {
                char c;
                cout << "Введите 0, если пол - мужской, иначе введите 1\n";
                cin >> c;
                if (c != '0' && c != '!') {
                    cout << "Введено неверное значение\n";
                    return 0;
                }
                engineer.SetIsMale(c == 0);
            }
            if (operation_idx == 4) {
                size_t new_age;
                if (!GetAndCheckPositiveInteger(new_age)) return 0;
                engineer.SetAge(new_age);
            }
            if (operation_idx == 5) {
                Date new_date;
                if (!GetDate(new_date)) return 0;
                engineer.SetDateOfBirth(new_date);
            }
            if (operation_idx == 6) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                engineer.SetResidenceAddress(new_address);
            }
            if (operation_idx == 7) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                engineer.SetRegistrationAddress(new_address);
            }
            if (operation_idx == 8) {
                engineer.ToQuitJob();
            }
            if (operation_idx == 9) {
                string new_company_name;
                if (!GetAndCheckString(new_company_name)) return 0;
                engineer.SetCompanyName(new_company_name);
            }
            if (operation_idx == 10) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                engineer.SetCompanyAddress(new_address);
            }
            if (operation_idx == 11) {
                Worker w;
                if (!GetWorker(w)) return 0;
                engineer.AddWorker(w);
            }
            if (operation_idx == 12) {
                string spec;
                cout << "Введите специальность рабочего, которого хотите удалить\n";
                cin >> spec;
                engineer.DismissWorker(spec);
            }
            if (operation_idx == 13) {
                engineer.DismissAllWorkers();
            }
            if (operation_idx == 14) {
                engineer.PrintWorkers();
            }
            if (operation_idx == 15) {
                engineer.PrintWorkersData();
            }
            if (operation_idx == 16) {
                engineer.SortWorkersByBirthDate();
            }
            cout << "Данные рабочего после выполненной операции\n";
            engineer.Print();
        }
        if (object_type == 4) {
            cout << "У Вас есть " << engineers_workers.size() << " инженеров-рабочих.\n";
            if (engineers_workers.size() == 0) {
                cout << "Запустите программу заново и создате инженера-рабочего\n";
                return 0;
            }
            size_t idx = 0;
            if (engineers_workers.size() > 1) {
                cout << "Введите значение - индекс, в диапазоне [0, " << workers.size()
                    << "), с каким именно инженером-рабочим Вы хотите поработать ? \n";
                if (!GetAndCheckPositiveInteger(idx)) return 0;
                if (idx >= engineers_workers.size()) {
                    cout << "Введено неверное значени индекса\n";
                    return 0;
                }
            }
            EngeineerWorker& ew = engineers_workers[idx];
            cout << "Данные инженера-рабочиего до выполненной операции\n";
            ew.EWPrint();
            cout << R"(
Выберете номер операции, которую хотите собершить с инженером-рабочим\n
0 - поменять фамилию
1 - поменять имя
2 - поменять отчество
3 - поменять пол
4 - поменять возраст
5 - поменять дату рождения
6 - поменять адрес проживания
7 - поменять адрес регистрации
8 - уволиться
9 - поменять название компании
10 - поменять адрес компании
11 - задать специализации
12 - добавить специализацию
13 - удалить специализацию
14 - сменить специализацию
15 - добавить рабочего
16 - уволить рабочего
17 - уволить всех рабочих
18 - вывести на экран специализации всех рабочих
19 - вывести на экран все данные рабочих
20 - отсортировать рабочих по дате рождения
21 - выйти
)";
            size_t operation_idx;
            if (!GetAndCheckPositiveInteger(operation_idx)) return 0;

            if (operation_idx > 21) {
                cout << "Введен неверный код операции\n";
            }
            if (operation_idx == 21) return 0;

            if (operation_idx == 0) {
                string new_surname;
                if (!GetAndCheckString(new_surname)) return 0;
                ew.Person::SetSurname(new_surname);
            }
            if (operation_idx == 1) {
                string new_name;
                if (!GetAndCheckString(new_name)) return 0;
                ew.Person::SetName(new_name);
            }
            if (operation_idx == 2) {
                string new_patronymic;
                if (!GetAndCheckString(new_patronymic)) return 0;
                ew.Person::SetPatronymic(new_patronymic);
            }
            if (operation_idx == 3) {
                char c;
                cout << "Введите 0, если пол - мужской, иначе введите 1\n";
                cin >> c;
                if (c != '0' && c != '!') {
                    cout << "Введено неверное значение\n";
                    return 0;
                }
                ew.Person::SetIsMale(c == 0);
            }
            if (operation_idx == 4) {
                size_t new_age;
                if (!GetAndCheckPositiveInteger(new_age)) return 0;
                ew.Person::SetAge(new_age);
            }
            if (operation_idx == 5) {
                Date new_date;
                if (!GetDate(new_date)) return 0;
                ew.Person::SetDateOfBirth(new_date);
            }
            if (operation_idx == 6) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                ew.Person::SetResidenceAddress(new_address);
            }
            if (operation_idx == 7) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                ew.Person::SetRegistrationAddress(new_address);
            }
            if (operation_idx == 8) {
                ew.ToQuitJob();
            }
            if (operation_idx == 9) {
                string new_company_name;
                if (!GetAndCheckString(new_company_name)) return 0;
                ew.SetCompanyName(new_company_name);
            }
            if (operation_idx == 10) {
                Address new_address;
                if (!GetAddress(new_address)) return 0;
                ew.SetCompanyAddress(new_address);
            }
            if (operation_idx == 11) {
                cout << "Сколько специализаций Вы планируете ввести?\n";
                size_t sc;
                if (!GetAndCheckPositiveInteger(sc)) {
                    return 0;
                }
                unordered_set<string> new_specs;
                for (size_t i = 0; i < sc; ++i) {
                    string spec;
                    cin >> spec; //не проверяю цифры так специализации рабочих могут быть странными
                    new_specs.insert(spec);
                }
                ew.SetSpecialization(new_specs);
            }
            if (operation_idx == 12) {
                string ns;
                cin >> ns;
                ew.AddSpecialization(ns);
            }
            if (operation_idx == 13) {
                string spec;
                cin >> spec;
                ew.DeleteSpecialization(spec);
            }
            if (operation_idx == 14) {
                string from, to;
                cout << "Введите старую и новую специализации\n";
                cin >> from >> to;
                ew.ChangeSpecialization(from, to);
            }
            if (operation_idx == 15) {
                Worker w;
                if (!GetWorker(w)) return 0;
                ew.AddWorker(w);
            }
            if (operation_idx == 16) {
                string spec;
                cout << "Введите специальность рабочего, которого хотите удалить\n";
                cin >> spec;
                ew.DismissWorker(spec);
            }
            if (operation_idx == 17) {
                ew.DismissAllWorkers();
            }
            if (operation_idx == 18) {
                ew.PrintWorkers();
            }
            if (operation_idx == 19) {
                ew.PrintWorkersData();
            }
            if (operation_idx == 20) {
                ew.SortWorkersByBirthDate();
            }
            cout << "Данные рабочего после выполненной операции\n";
            ew.EWPrint();
        }

    }

    return 0;
}

/*
5
a
a
a
m
2
2
2
2

a
a
2
2
2
2
2
s
s
2
2
2
2
2
a
a
2
2
2
2
2
sdsad
y
6
3


*/