return true;

    }

    // There are two possible edge exchanges

    // switchType indicates which one is desired

    // Returns false if the switch is not possible

        StoredEdge &se1 = edges[e1index];

        StoredEdge &se2 = edges[e2index];

        const Edge &e1 = se1.e;

        const Edge &e2 = se2.e;

        // The new edges configuration is one of these two

        }

        // First check if the move is possible

        if (hasEdge({e1.u, e2.u}) || hasEdge({e1.v, e2.v}))

            return false; // conflicting edges

        // Clear old edges

        badj[e1.u][e1.v] = false;

        badj[e1.v][e1.u] = false;

        badj[e2.u][e2.v] = false;

        badj[e2.v][e2.u] = false;

        std::swap(se1.v2uindex, se2.u2vindex);

        // e1 and e2 now contain the NEW edges!!

        badj[e1.u][e1.v] = true;

        badj[e1.v][e1.u] = true;

        badj[e2.u][e2.v] = true;

        badj[e2.v][e2.u] = true;

        return true;

    }

        for (auto& v : adj) {

            for (unsigned int i = 0; i < v.size(); ++i) {

                for (unsigned int j = i + 1; j < v.size(); ++j) {

                    if (hasEdge({v[i], v[j]})) {

                        ++triangles;

                    }

            }

        }

        assert(triangles % 3 == 0);

        return triangles / 3;

    }

    // Should return zero

    int consistencyCheck() const {

        // Check if info in 'edges' is present

        // in adj and badj

        for (auto &se : edges) {

            if (se.e.u >= adj.size() || se.e.v >= adj.size())

  private:

    // Graph is saved in three formats for speed

    // They should be kept consistent at all times

    std::vector<std::vector<unsigned int>> adj;

    std::vector<std::vector<bool>> badj; // symmetric binary matrix

    std::vector<StoredEdge> edges;

};

        // random_device uses hardware entropy if available

        // std::random_device rd;

        // mt.seed(rd());

    }

    ~SwitchChain() {}

        if (gstart.edgeCount() == 0)

            return false;

        g = gstart;

        edgeDistribution.param(

            std::uniform_int_distribution<>::param_type(0, g.edgeCount() - 1));

        return true;

    }

        int e1index, e2index;

        int timeout = 0;

        // Keep regenerating while conflicting edges

        do {

            e1index = edgeDistribution(mt);

            e2index = edgeDistribution(mt);

        // Consider one of the three possible permutations

        // 1) e1.u - e1.v and e2.u - e2.v (original)

        // 2) e1.u - e2.u and e1.v - e2.v

        // 3) e1.u - e2.v and e1.v - e2.u

        bool switchType = permutationDistribution(mt);

    }

    Graph g;

    std::mt19937 mt;

    std::uniform_int_distribution<> edgeDistribution;

    //std::uniform_int_distribution<> permutationDistribution;

#include <iostream>

#include <numeric>

#include <random>

#include <vector>

int main(int argc, char* argv[]) {

    float tauValues[] = {2.1f, 2.2f, 2.3f, 2.4f, 2.5f, 2.6f, 2.7f, 2.8f, 2.9f};

    if (argc >= 2)

        outfile.open(argv[1]);

        outfile.open("graphdata_etmt.m");

    if (!outfile.is_open()) {

        std::cout << "ERROR: Could not open output file.\n";

        return 1;

    }

    outfile << '{';

    bool outputComma = false;

        for (float tau : tauValues) {

            // For a single n,tau take samples over several instances of

            // the degree distribution.

                DegreeSequence ds;

                generatePowerlawGraph(numVertices, tau, g, ds, rng);

                // Multiple runs from the same degree sequence

                for (int i = 0; i < 5; ++i) {

                SwitchChain chain;

                    std::cerr << "Could not initialize Markov chain.\n";

                    return 1;

                }

                int movesTotal = 0;

                int movesSuccess = 0;

                int triangles[measurements];

                for (int i = 0; i < mixingTime; ++i) {

                }

                for (int i = 0; i < measurements; ++i) {

                    for (int j = 0; j < measureSkip; ++j) {

                        ++movesTotal;

                            ++movesSuccess;

                        }

                    }

                }

                // Take the average over the last 20%

                auto trianglesTotal = 0uL;

                auto count = 0u;

                for (int i = measurements - (measurements / 5); i < measurements; ++i) {

                    trianglesTotal += triangles[i];

                }

                if (outputComma)

                    outfile << ',' << '\n';

                outputComma = true;

                outfile << '{' << '{' << numVertices << ',' << tau << '}';

                outfile << ',' << ETMT;

                outfile << '}' << std::flush;

                }

            }

        }

    }

    outfile << '}';

    return 0;

                    float(movesDone) / float(measurements * measureSkip);

                for (auto& f : avgAspectrum)

                    f /= float(measurements);

                for (auto& f : avgLspectrum)

                    f /= float(measurements);

                if (outputComma)

                    outfile << ',' << '\n';

                outputComma = true;

                outfile << '{' << '{' << numVertices << ',' << tau << '}';