#include <vector>
#include <cmath>
#include <iostream>



class FloodIsolation {
public:
    FloodIsolation() :
            numberOfCells(20000),
            data(numberOfCells)
    {
    }
    ~FloodIsolation(){
    }

    void isUpdateNeeded() {
        for (int i = 0; i < numberOfCells; ++i) {
           data[i].h = data[i].h + 1;
           data[i].floodedCells = !data[i].floodedCells;
           data[i].floodedCellsTimeInterval = !data[i].floodedCellsTimeInterval;
           data[i].qInflow = data[i].qInflow + 1;
           data[i].qStartTime = data[i].qStartTime + 1;
           data[i].qEndTime = data[i].qEndTime + 1;
           data[i].lowerFloorCells = data[i].lowerFloorCells + 1;
           data[i].cellLocationX = data[i].cellLocationX + 1;
           data[i].cellLocationY = data[i].cellLocationY + 1;
           data[i].cellLocationZ = data[i].cellLocationZ + 1;
           data[i].levelOfCell = data[i].levelOfCell + 1;
           data[i].valueOfCellIds = data[i].valueOfCellIds + 1;
           data[i].h0 = data[i].h0 + 1;
           data[i].vU = data[i].vU + 1;
           data[i].vV = data[i].vV + 1;
           data[i].vUh = data[i].vUh + 1;
           data[i].vVh = data[i].vVh + 1;
           data[i].vUh0 = data[i].vUh0 + 1;
           data[i].vVh0 = data[i].vVh0 + 1;
           data[i].ghh = data[i].ghh + 1;
           data[i].sfx = data[i].sfx + 1;
           data[i].sfy = data[i].sfy + 1;
           data[i].qIn = data[i].qIn + 1;


            for(int j = 0; j < nEdges; ++j) {
                data[i].flagInterface[j] = !data[i].flagInterface[j];
                data[i].typeInterface[j] = data[i].typeInterface[j] + 1;
                data[i].neighborIds[j] = data[i].neighborIds[j] + 1;
            }
        }

    }

private:

    const int numberOfCells;
    static const int nEdges = 6;
struct data_t {
    double valueOfCellIds = 0;
    double h = 0;

    double h0 = 0;
    double vU = 0;
    double vV = 0;
    double vUh = 0;
    double vVh = 0;
    double vUh0 = 0;
    double vVh0 = 0;
    double ghh = 0;
    double sfx = 0;
    double sfy = 0;
    double qInflow = 0;
    double qStartTime = 0;
    double qEndTime = 0;
    double qIn = 0;
    double nx = 0;
    double ny = 0;
    double floorLevels = 0;
    double cellLocationX = 0;
    double cellLocationY = 0;
    double cellLocationZ = 0;
    int lowerFloorCells = 0;
    int levelOfCell = 0;
    int typeInterface[nEdges] = {};
    int neighborIds[nEdges] = {};
    bool flagInterface[nEdges] = {};
    bool floorCompleteleyFilled = 0;
    bool floodedCells = 0;
    bool floodedCellsTimeInterval = 0;
};
	std::vector<data_t> data;

};

int main() {
	std::ios_base::sync_with_stdio(false);
    FloodIsolation isolation;
    clock_t start = clock();
    for (int i = 0; i < 400; ++i) {
        if(i % 100 == 0) {
            std::cout << i << "\n";
        }
        isolation.isUpdateNeeded();
    }
    clock_t stop = clock();
    std::cout << "Time: " << difftime(stop, start) / 1000 << "\n";
}