#include <bits/stdc++.h>
#include "simurgh.h"

using pii = std::pair<int, int>;
#define mkp(a, b) std::make_pair(a, b)

const int N = 5e2 + 10, M = N * N;

std::vector<int> Gold_Roads, Spanning_Tree;
int tot = 1, fir[N], nex[M], got[M], idx[M], Map[N][N], n;

inline void AddEdge(int u, int v, int I) {
    nex[++tot] = fir[u], fir[u] = tot, got[tot] = v, idx[tot] = I;
    nex[++tot] = fir[v], fir[v] = tot, got[tot] = u, idx[tot] = I;
}

int par[N], vis[M], dep[N], Vis[M], par_edge[N], TYPE[M], w[N], f[N], U[M], V[M], d[N];

inline void dfs(int u) {
    vis[u] = true;

    for (int i = fir[u]; i; i = nex[i])
        if (!vis[got[i]])
            Spanning_Tree.push_back(idx[i]), dfs(got[i]);
}

inline int find(int u) {
    return f[u] == u ? u : f[u] = find(f[u]);
}

inline int count(std::vector<int> E) {
    if (E.size() == n - 1)
        return count_common_roads(E);

    // assert(E.size() < n);
    int s = 0, sum = 0;

    for (int i = 0; i < n; ++i)
        f[i] = i;

    for (int i = 0; i < E.size(); ++i) {
        int u = U[E[i]], v = V[E[i]];
        // assert(find(u) != find(v));
        f[find(u)] = find(v);
    }

    // printf("E.size() = %d\n", E.size());
    // for (int i = 0; i < n; ++i) if (find(i) == i) ++sum;
    // printf("%d\n", sum);
    for (auto i : Spanning_Tree) {
        int u = find(U[i]), v = find(V[i]);

        if (u != v)
            f[u] = v, s += TYPE[i], E.push_back(i);
    }

    // assert(E.size() < n);
    return count_common_roads(E) - s;
}

inline std::vector<int> ring(std::vector<int> bas, int ban) {
    std::vector<int> res;

    for (auto dat : bas)
        if (dat != ban)
            res.push_back(dat);

    return res;
}

inline void solve(int u, int v, int edg_num) {
    int flg = 0, edg = 0, cont = 1;
    std::vector<int> query;
    memset(Vis, 0, sizeof(Vis));

    for (int U = u; U != v; U = par[U]) {
        Vis[par_edge[U]] = true;

        if (TYPE[par_edge[U]] == -1)
            cont = false;

        if (TYPE[par_edge[U]] != -1)
            flg = true, edg = par_edge[U];
    }

    if (cont) {
        return;
    }

    if (flg) {
        std::vector<int> bas = Spanning_Tree;
        bas.push_back(edg_num);
        int sum = count(ring(bas, edg));

        for (int U = u; U != v; U = par[U]) {
            int e = par_edge[U];

            if (TYPE[e] == -1) {
                std::vector<int> query = ring(bas, e);
                int s = count(query);
                TYPE[e] = TYPE[edg] + s - sum;

                if (TYPE[e] == -1) {
                    // puts("");
                }

                // assert(TYPE[e] != -1);
            }
        }
    } else {
        std::vector<int> bas = Spanning_Tree;
        int Min = count(bas), flg = true;

        for (int U = u; U != v; U = par[U]) {
            int e = par_edge[U];
            std::vector<int> query = ring(bas, e);
            query.push_back(edg_num);
            w[U] = count(query), flg &= w[U] == Min, Min = std::min(Min, w[U]);
        }

        for (int U = u; U != v; U = par[U])
            TYPE[par_edge[U]] = flg ? 0 : 1 - w[U] + Min;
    }

    // for (int i = 0; i < 6; ++i) printf("%d ", TYPE[i]); puts("");
    // std::cout << lxndanfdiadsfnslkjGrader::q << std::endl;
}

inline void dfs(int u, int fa) {
    par[u] = fa, vis[u] = true;

    if (fa != -1)
        dep[u] = dep[fa] + 1;

    for (int i = fir[u]; i; i = nex[i])
        if (got[i] != fa) {
            if (!vis[got[i]])
                par_edge[got[i]] = idx[i], dfs(got[i], u);
            else if (dep[u] > dep[got[i]])
                solve(u, got[i], idx[i]);
        }
}

inline int solve(int u, std::vector<int> vec) {
    if (vec.size() == 1)
        return vec[0];

    int mid = vec.size() / 2;
    std::vector<int> E;

    for (int i = 0; i < mid; ++i)
        E.push_back(Map[u][vec[i]]);

    if (count(E)) {
        std::vector<int> v;

        for (int i = 0; i < mid; ++i)
            v.push_back(vec[i]);

        return solve(u, v);
    } else {
        std::vector<int> v;

        for (int i = mid; i < vec.size(); ++i)
            v.push_back(vec[i]);

        return solve(u, v);
    }
}

inline int solve(int u) {
    std::vector<int> vec;

    for (int i = fir[u]; i; i = nex[i])
        if (TYPE[idx[i]] == -1)
            vec.push_back(got[i]);

    return solve(u, vec);
}

std::vector<int> find_roads(int N, std::vector<int> U, std::vector<int> V) {
    // freopen("3173.out", "w", stdout);
    int m = U.size();
    n = N;

    for (int i = 0; i < m; ++i) {
        int u = U[i], v = V[i];
        AddEdge(u, v, i);
        Map[u][v] = Map[v][u] = i;
        ::U[i] = u, ::V[i] = v;
    }

    memset(TYPE, -1, sizeof(TYPE));
    dfs(0), memset(vis, 0, sizeof(vis)), dfs(0, -1);

    // std::cerr << lxndanfdiadsfnslkjGrader::q << std::endl;
    for (auto i : Spanning_Tree)
        if (TYPE[i] == -1)
            TYPE[i] = 1;

    // for (int i = 0; i < m; ++i) printf("%d ", TYPE[i]); puts("");
    // for (int i = 0; i < n; ++i) printf("%d ", par[i]); puts("");
    // std::cout << "Spanning_Tree.size() = " << Spanning_Tree.size() << std::endl;
    // for (int i: Spanning_Tree) printf("%d %d %d\n", U[i], V[i], TYPE[i]);
    // for (int i: Spanning_Tree) if (lxndanfdiadsfnslkjGrader::Gold[i] != TYPE[i])
    // std::cerr << U[i] << ' ' << V[i] << ' ' << i << std::endl;
    // return Spanning_Tree;
    for (int u = 0; u < n; ++u) {
        std::vector<int> E;

        for (int i = fir[u]; i; i = nex[i])
            E.push_back(idx[i]);

        d[u] = count(E);
    }

    for (auto i : Spanning_Tree)
        if (TYPE[i] == 1) {
            Gold_Roads.push_back(i), --d[U[i]], --d[V[i]];
        }

    for (int i = 0; i < n - 1; ++i) {
        for (int u = 0; u < n; ++u)
            if (d[u]) {
                int v = solve(u);
                Gold_Roads.push_back(Map[u][v]), --d[u], --d[v];
                TYPE[Map[u][v]] = 1;
                break;
            }
    }

    // fclose(stdout);
    return Gold_Roads;
}