using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace contest
{
//прим
    public class Edge
    {
        public int From { get; }
        public int To { get; }
        public int Weight { get; }

        public Edge(int from, int to, int weight)
        {
            if (from > to)
            {
                var temp = from;
                from = to;
                to = temp;
            }

            From = from;
            To = to;
            Weight = weight;
        }
    }

    public class EdgeComparer : IComparer<Edge>
    {
        public int Compare(Edge x, Edge y)
        {
            if (x.Weight.CompareTo(y.Weight) != 0) return x.Weight.CompareTo(y.Weight);

            return x.From.CompareTo(y.From) == 0 ? x.To.CompareTo(y.To) : x.From.CompareTo(y.From);
        }
    }

    public class Graph
    {
        private SortedSet<Edge> edges;
        private int VertexCount { get; }

        public Graph(int vertexCount)
        {
            edges = new SortedSet<Edge>(new EdgeComparer());
            VertexCount = vertexCount;
        }

        public void AddEdge(Edge e)
        {
            edges.Add(e);
        }

        private static void Fill<T>(ICollection<T> list, int count, T value)
        {
            for (var i = 0; i < count; i++)
            {
                list.Add(value);
            }
        }

        public IEnumerable<Edge> GetMinimalSpanningTree()
        {
            var result = new List<Edge>();
            var vertexes = new HashSet<int>();
            var temp= new Edge[edges.Count];
            edges.CopyTo(temp);
            var allEdges = new SortedSet<Edge>(temp, new EdgeComparer());

            var edge = allEdges.First();
            allEdges.Remove(edge);
            vertexes.Add(edge.From);
            vertexes.Add(edge.To);
            result.Add(edge);

            while (vertexes.Count < VertexCount)
            {
                foreach (var currentEdge in allEdges.Where(currentEdge => vertexes.Contains(currentEdge.From) && !vertexes.Contains(currentEdge.To) ||
                                                                          vertexes.Contains(currentEdge.To) && !vertexes.Contains(currentEdge.From)))
                {
                    result.Add(currentEdge);
                    allEdges.Remove(currentEdge);
                    vertexes.Add(currentEdge.From);
                    vertexes.Add(currentEdge.To);
                    break;
                }
            }

            return result;
        }
    }


    internal static class Program
    {
        private static void Main()
        {
            var sr = new StreamReader("input.txt");
            var sw = new StreamWriter("output.txt");
            var line = sr.ReadLine()
                ?.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse)
                .ToArray();

            var n = line[0];
            var m = line[1];
            var graph = new Graph(n);

            for (var i = 0; i < m; i++)
            {
                line = sr.ReadLine()
                    ?.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse)
                    .ToArray();

                var edge = new Edge(line[0], line[1], line[2]);

                graph.AddEdge(edge);
            }

            foreach (var edge in graph.GetMinimalSpanningTree())
            {
                sw.WriteLine($"{edge.From} {edge.To}");
            }

            sr.Close();
            sw.Close();
        }
    }
}