#include<cstdio>
#include<vector>
#include<algorithm>

using namespace std;

///struct used to store edges
struct Edge{
    int from,to,weight;

    ///we need this operator for sorting. Compares only weight since this is the only thing we need (in most cases, if nothing else is said)
    bool operator < (const Edge &target)const{
        return this->weight < target.weight;
    }
}edges[100000];

int m,n;
int dsuParent[10000];
vector<pair<int,int> >mst[10000];

void init(){
    scanf("%d %d",&n,&m);

    ///we store the edges in an array since we need to sort them (only) and nothing else
    for(int i=0;i<m;i++){
        scanf("%d %d %d",&edges[i].from,&edges[i].to,&edges[i].weight);
    }

    ///initialization for the dsu. In the beginning there are no edges, every node is the root of the tree it is in.
    for(int i=0;i<n;i++){
        dsuParent[i]=i;
    }
}

///returns the root of the in which the node is
int getRoot(int node){
    if(node==dsuParent[node])return node;///if it is its own parent, then there is no parent and this is the root.

    int root = getRoot(dsuParent[node]);///else we get the root

    ///we say the root is this node's direct parent since we only need the root and dont care what is on the way
    ///so it is faster if we just rearange the tree. This way we have less edges on the way to the root.
    dsuParent[node]=root;

    return root;

    ///return dsuParent[node]=getRoot(dsuParent[node]);///this replaces the 3 lines above. Its easier to write but harder to read
}

///unites two trees in the dsu. IMPORTANT! we work under the assumption that the arguments are the ROOTS of the trees.
///usually it is more logical that the arguments are two random nodes and we find the roots ourselves, however in our algorithm we have already found the roots so its faster
void mstUnite(int root1, int root2){
    dsuParent[root1]=root2;///since we don't use the depth anymore we don't care which node is the root.
}

void Kruskal(){
    sort(edges,edges+m);///sort the edges

    for(int i=0;i<m;i++){///for every edge
        ///get the roots of the two ends of the edge
        int root1 = getRoot(edges[i].from);
        int root2 = getRoot(edges[i].to);

        if(root1 == root2)continue;///if they are the same, there is a path between the two nodes, the edge will add a cycle, so we do nothing.

        ///else we add the edge in the graph
        mst[edges[i].from].push_back({edges[i].to,edges[i].weight});
        mst[edges[i].to].push_back({edges[i].from,edges[i].weight});

        ///and also add it in the dsu
        mstUnite(root1,root2);
    }
}

///print function to see what we have built
void print(){
    for(int i=0;i<n;i++){
        printf("neighbors of %d: ",i);
        for(int j=0;j<mst[i].size();j++){
            printf("%d ",mst[i][j].first);
        }
        printf("\n");
    }
}

int main(){
    init();
    Kruskal();
    print();
}