#include "stdio.h"
#include "malloc.h"
#include "stdlib.h"
#define INT_MAX 2147483647
#define MAX_LENGTH INT_MAX

typedef struct edge {
    int first;
    int second;
    int weight;
} edge;


void swap(void *a, void *b, size_t size) {
    char tmp;
    size_t i;
    for (i = 0; i < size; i++) {
        tmp = *((char*) b + i);
        *((char*) b + i) = *((char*) a + i);
        *((char*) a + i) = tmp;
    }
}



int find_set (int* p, int v) {
    if ( p[v] == v) {
        return v;
    }
    return p[v] = find_set(p, p[v]);
}



int partition (edge* a, int l, int r) {
    edge v = a[(l + r)/2];
    int i = l;
    int j = r;
    while (i <= j) {
        while (a[i].weight < v.weight) {
            i++;
        }
        while (a[j].weight > v.weight) {
            j--;
        }
        if (i >= j) {
            break;
        }
        swap (&a[i], &a[j], sizeof(edge));
        i++;
        j--;
    }
    return j;
}



void quick_sort (edge* a, int l, int r) {
    if (l < r) {
        int q = partition(&a[0], l, r);
        quick_sort(a, l, q);
        quick_sort(a, q + 1, r);
    }
}



void union_set (int* p, int* count, int v1, int v2) {
    v1 = p[v1];
    v2 = p[v2];
    if (v1 == v2) {
        return;
    }

    if (count[v1] < count[v2]) {
        swap(&v1, &v2, sizeof(int));
    }
    p[v2] = v1;
    if (count[v1] == count[v2]) {
        count[v1]++;
    }
}



int main() {

    int n, m;

   scanf("%d%d", &n, &m);



    if (n < 0 || n > 5000) {
        printf( "bad number of vertices");
        return 0;
    }

    if (m < 0 || m > n*(n-1)/2) {
        printf( "bad number of edges");
        return 0;
    }

    if (n == 0 || (m == 0 && n != 1)) {
        printf( "no spanning tree");
        return 0;
    }

    int* p = (int*)malloc(sizeof(int)*n);
    int* count = (int*)malloc(sizeof(int)*n);
    int* carcas = (int*)malloc(sizeof(int)*m);
    edge* edges = (edge*)malloc(sizeof(edge)*m);

    if (p == NULL || count == NULL || carcas == NULL || edges == NULL) {
        printf( "mem error");
        return 0;
    }

    for (int i = 0; i < m; i++) {
        if (scanf("%d %d %d\n", &edges[i].first, &edges[i].second, &edges[i].weight) == EOF) {
            printf("bad number of lines");
            return 0;
        }

        if (edges[i].first < 1 || edges[i].first > n || edges[i].second < 1 || edges[i].second > n) {
            printf( "bad vertex");
            return 0;
        }

        if (edges[i].weight < 0 || edges[i].weight > MAX_LENGTH) {
            printf( "bad length");
            return 0;
        }
        edges[i].first--;
        edges[i].second--;
    }

    if (n == 1) {
        return 0;
    }

    if (m < n - 1) {
        printf( "no spanning tree");
        return 0;
    }

    quick_sort(&edges[0], 0, m - 1);

    for (int i = 0; i < n; i++) {
        p[i] = i;
        count[i] = 0;
    }

int count_of_edges = 0;
    for (int i = 0; i < m; i++) {
        if (find_set(&p[0], edges[i].first) == find_set(&p[0], edges[i].second)) {
            continue;
        }
        union_set(&p[0], &count[0], edges[i].first, edges[i].second);
        carcas[count_of_edges] = i;
        count_of_edges++;
    }

    int root = p[0];
    for (int i = 0; i < n; i++) {

        if (root != find_set(&p[0], i)) {
            printf("no spanning tree");
            return 0;
        }
    }

    for (int i = 0; i < count_of_edges; i++) {
        printf( "%d %d\n", edges[carcas[i]].first + 1, edges[carcas[i]].second + 1);
    }
}