bool CheckPermutation(vector<int>&& arr2, vector <Pair>&& pairs, int L, int trhld) {
    vector<vector<int>> mat {
                { 0},
                { 0, 1},
                { 0, 2},
                { 0, 1, 2, 3},
                { 0, 4},
                { 0, 1, 4, 5},
                { 0, 2, 4, 6},
                { 0, 1, 2, 3, 4, 5, 6, 7}};
    vector <vector<int>> dims(trhld);
    vector <int> arr;
    for (int i = 0; i < L; i++) {
        arr.push_back(pairs[arr2[i]].x);
        arr.push_back(pairs[arr2[i]].y);
    }
    //cout << "tr " << trhld << endl;
    for (int i = 0; i < trhld; i++) {
        dims[i].push_back(i);
    }

    //PrintMat(dims);
    for (int i = 0; i < L*2; i+=2) {
        if (arr[i] != arr[i + 1]) {
            for (int j = 0; j < dims[arr[i]].size(); j++) {
                dims[arr[i + 1]].push_back(dims[arr[i]][j]);
                //PrintMat(dims);
            }
        }
    }
    for (int i = 0; i < trhld; i++) {
        sort(dims[i].begin(), dims[i].end());
        //dims[i].erase(unique(dims[i].begin(), dims[i].end()), dims[i].end());
        int z = 0;
        int count = 0;
        //vector<int>counts;
        for (int j = 0; j < trhld; j++) {
            count = std::count(dims[i].begin(), dims[i].end(), j);
            //counts.push_back(count);
            if (count % 2 == 0) {
                dims[i].erase(std::remove(dims[i].begin(), dims[i].end(), j), dims[i].end());
            }
        }
        dims[i].erase(unique(dims[i].begin(), dims[i].end()), dims[i].end());
    }
    //PrintMat(dims);
    if (dims == mat) {
        cout << "!\n";
        PrintMat(dims);
        //cout << "i want pizza\n";

        return true;
    }
    return false;
}



void PrintAdd(vector <int> arr, int L, int trhld, vector <Pair> pairs, int lim, int threadTrhld)
{
    unsigned long long max = pow(trhld, L);
    int lastElementNumber = L - 1;
    int c,counter, found = 0;
    unsigned long long i = 0;
    counter = 0;
    cout << max << " " << L << endl;
    while(1) {
        counter++;
        //for (int i = 0; i < max; i++) {
        arr[lastElementNumber]++;
        for (int j = lastElementNumber; j > 0; j--) {
            if (arr[j] == arr[j - 1]) {
                arr[j]++;
            }
            if (arr[j] >= trhld) {
                arr[j] = 0;
                arr[j - 1]++;
                //counter--;
            }
        }
        //CheckPermutation(arr, L, trhld);
        if (arr[0] == threadTrhld) {
            break;
        }

        const int n = trhld;
        bool foundDup = false;
        vector <int> count(n, 0);

        for (int i = 0; i < L; i++)
        {
            count[arr[i]]++;
            if (count[arr[i]] > 1) {
                foundDup = true;
            }
        }
        if (!foundDup) {
            if (counter %  10000 == 0) {
                PrintVector(arr, L);
                cout << endl;
            }
            if (CheckPermutation(move(arr), move(pairs), L, lim)) {
                //PrintArr(arr, L);
                PrintVector(arr, L);
                PrintPairs(pairs, arr, L);
                found++;
                cout << "found\n";
                c = getchar();
            }
        }
    }
    cout << "Total: " << found << endl;
}




int main()
{

    const int L = 7; // L = 8
    //cout << len << endl;
    int c;

    vector <vector< int>> permutationMat(6);
    int lim = 8; // thld = 4

    for (int i = 0; i < L; i++) {
        permutationMat[0].push_back(i);
    }

    vector <Pair> pairsVector;

    pairsVector = GetPairs(lim);
    int trhld = pairsVector.size();
    for (int i = 1; i < 6; i++) {
        permutationMat[i] = permutationMat[i-1];
        permutationMat[i][0] += trhld / 6;
    }
    PrintMat(permutationMat);
    //-------------------------------------------------
    unsigned num_cpus = std::thread::hardware_concurrency();
    std::cout << "Launching " << num_cpus << " threads\n";
    std::vector <std::thread> threads(num_cpus);
    c = getchar();

    for (unsigned i = 0; i < num_cpus; ++i) {
        threads[i] = thread(PrintAdd, ref(permutationMat[i]), L, trhld, ref(pairsVector),lim, permutationMat[i][0] + trhld / 6);
    }
    for (unsigned i = 0; i < num_cpus; ++i) {
        threads[i].join();
    }
    //FindPermutations(pairsVector, permutationV, L);
    //PrintAdd(permutation, L, trhld, pairsVector, lim);
    cout << "END!\n";
    c = getchar();
}