c++ wtf

#include "pch.h"
#include <iostream>
#include <math.h>
#include <Windows.h>
#include <chrono>
#include <stdio.h>
#include <thread>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
const int Companies = 100;
const int Factories = 2500;
const int Departments = 25;
const int NumofResources = 200;//0-99 import 100-199 export
int delay = 0;
class Department {
public:
    char name;
    int inputtype;
    int outputtype;
    float typeprodfactor;
    float typeconsfactor;
    int numberofworkers;
    float toexport;
    float imported;
    int size;
private:
    int maxworkers;
};
class Factory {
public:
    float money;
    float OwnedResources[NumofResources];
    vector<Department> OwnedDepartment;

};
class Company {
public:
    char name;
    vector<Factory> OwnedFactories;

};
vector<Company> Database;

//Fills database with random values, DB is expandable
void InitializeDB() {
    Database.reserve(Companies);
    for (int i = 0; i < Companies; ++i) {
        Database.push_back(Company());
        Database[i].OwnedFactories.reserve(Factories);
        for (int k = 0; k < Factories; ++k) {
            Database[i].OwnedFactories.push_back(Factory());
            Database[i].OwnedFactories[k].OwnedDepartment.reserve(Departments);
            for (int l = 0; l < Departments; ++l) {
                Database[i].OwnedFactories[k].OwnedDepartment.push_back(Department());
                Database[i].OwnedFactories[k].OwnedDepartment[l].inputtype = rand() % 100;
                Database[i].OwnedFactories[k].OwnedDepartment[l].outputtype = rand() % 100;
                Database[i].OwnedFactories[k].OwnedDepartment[l].typeprodfactor = (rand() % 10) + 1;
                Database[i].OwnedFactories[k].OwnedDepartment[l].typeconsfactor = (rand() % 10) + 1;
                Database[i].OwnedFactories[k].OwnedDepartment[l].numberofworkers = rand() % 5 + 1;
                Database[i].OwnedFactories[k].OwnedDepartment[l].toexport = rand() % 100;
                Database[i].OwnedFactories[k].OwnedDepartment[l].imported = 0;
                Database[i].OwnedFactories[k].OwnedDepartment[l].size = rand() % 100;
            }
        }
    }
}
void produce(int Com, int Fac, int Dep) {
    float conspertick = Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].numberofworkers*Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].typeconsfactor;
    if (Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].imported > conspertick) {
        float prodpertick = Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].numberofworkers*Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].typeprodfactor;
        Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].toexport = Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].toexport + prodpertick;
        Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].imported = Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].imported - conspertick;
    }
}
//feed it Deparment and it does one tick of production
void ProduceAll() {
    for (int i = 0; i < Companies; ++i) {
        for (int k = 0; k < Factories; ++k) {
            for (int l = 0; l < Departments; ++l) {
                produce(i, k, l);
            }
        }
    }
}
void transport(int Com, int Fac, int Dep) {
    //out
    if (Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].toexport > 0) {
        Database[Com].OwnedFactories[Fac].OwnedResources[Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].outputtype] = Database[Com].OwnedFactories[Fac].OwnedResources[Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].outputtype]+ Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].toexport;
        Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].toexport = 0;
    }
    //in
    float conspertick = Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].numberofworkers*Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].typeconsfactor;
    if (Database[Com].OwnedFactories[Fac].OwnedResources[Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].inputtype] > conspertick*delay) {
        Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].imported = conspertick * 7;
        Database[Com].OwnedFactories[Fac].OwnedResources[Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].inputtype] = Database[Com].OwnedFactories[Fac].OwnedResources[Database[Com].OwnedFactories[Fac].OwnedDepartment[Dep].inputtype] - conspertick * 7;

    }

}
void TransportAll() {
    for (int i = 0; i < Companies; ++i) {
        for (int k = 0; k < Factories; ++k) {
            for (int l = 0; l < Departments; ++l) {
                transport(i, k, l);
            }
        }
    }
}
int a;
int main()
{
    InitializeDB();
    auto start = std::chrono::system_clock::now();
    for (int i = 0;i<365;++i)
    {

        ProduceAll();
        //transport resources every #delay days
        if (delay==0){
            TransportAll();
            delay = 7;
        }
        delay = delay - 1;


        //int c = 0;
        //int v = 5;
        //int b = 3;
        //system("cls");
        //cout <<"toexport= "<< Database[c].OwnedFactories[v].OwnedDepartment[b].toexport<<endl;
        //cout <<"import= "<< Database[c].OwnedFactories[v].OwnedDepartment[b].imported << endl;
        //cout << "numberofworkers= " << Database[c].OwnedFactories[v].OwnedDepartment[b].numberofworkers << endl;
        //cout << "typeprodfactor= " << Database[c].OwnedFactories[v].OwnedDepartment[b].typeprodfactor << endl;
        //cout << "typeconsfactor= " << Database[c].OwnedFactories[v].OwnedDepartment[b].typeconsfactor <<endl ;
        //cout << "conspertick= " << Database[c].OwnedFactories[v].OwnedDepartment[b].typeconsfactor*Database[c].OwnedFactories[v].OwnedDepartment[b].numberofworkers << endl;
        //cout << "prodpertick= " << Database[c].OwnedFactories[v].OwnedDepartment[b].typeprodfactor*Database[c].OwnedFactories[v].OwnedDepartment[b].numberofworkers << endl;
        //Sleep(500);



    }
    auto end = std::chrono::system_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    cout << elapsed.count() << '\n';
    cin >> a;
}