#include<cstdio>

#include<cstring>

#include<string>

#include<cmath>

#include<vector>

#include<queue>

#include<algorithm>

using namespace std;

const int maxn=+;

const int INF=0x7FFFFFFF;

struct Edge

{

    int from,to,cap,flow;

};

vector<Edge>edges;

vector<int>G[maxn];

vector<int>CG[maxn];

bool vis[maxn];

int d[maxn];

int cur[maxn];

int n,m,s,t;

Edge P[maxn];

//求出层次网络

bool BFS()

{

    memset(vis,,sizeof(vis));

    queue<int>Q;

    Q.push(s);

    d[s]=;

    vis[s]=;

    while(!Q.empty())

    {

        int x=Q.front();

        Q.pop();

        for(int i=; i<G[x].size(); i++)

        {

            Edge& e=edges[G[x][i]];

            if(!vis[e.to]&&e.cap>e.flow)

            {

                vis[e.to]=;

                d[e.to]=d[x]+;

                Q.push(e.to);

            }

        }

    }

    return vis[t];

}

//加边

void AddEdge(int from,int to,int cap)

{

    Edge r;

    r.from=from;

    r.to=to;

    r.cap=cap;

    r.flow=;

    edges.push_back(r);

    Edge d;

    d.from=to;

    d.to=from;

    d.cap=;

    d.flow=;

    edges.push_back(d);

    m=edges.size();

    G[from].push_back(m-);

    G[to].push_back(m-);

}

//每个阶段来一次DFS增广

int DFS(int x,int a)

{

    if(x==t||a==) return a;

    int flow=,f;

    for(int i=cur[x]; i<G[x].size(); i++)

    {

        Edge& e=edges[G[x][i]];

        if(d[x]+==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>)

        {

            e.flow+=f;

            edges[G[x][i]^].flow-=f;

            flow+=f;

            a-=f;

            if(a==) break;

        }

    }

    return flow;

}

//多个阶段，多次建立层次网络。

int Maxflow(int ss,int tt)

{

    int flow=;

    while(BFS())

    {

        memset(cur,,sizeof(cur));

        flow+=DFS(ss,INF);

    }

    return flow;

}

int N,M,Cost;

int U[maxn],V[maxn];

int FF[maxn];

void dfs(int x)

{

    FF[x]=;

    for(int i=; i<CG[x].size(); i++)

        if(!FF[CG[x][i]])

            dfs(CG[x][i]);

}

int main()

{

    while(~scanf("%d%d",&N,&M))

    {

        if(!N&&!M) break;

        edges.clear();

        for(int i=; i<maxn; i++) G[i].clear();

        for(int i=; i<maxn; i++) CG[i].clear();

        memset(FF,,sizeof FF);

        s=;

        t=;

        for(int i=; i<=M; i++)

        {

            scanf("%d%d%d",&U[i],&V[i],&Cost);

            AddEdge(U[i],V[i],Cost);

            AddEdge(V[i],U[i],Cost);

        }

        Maxflow(s,t);

        int Tot=;

        for(int i=; i<edges.size(); i=i+)

        {

            P[Tot].from=edges[i].from;

            P[Tot].to=edges[i].to;

            P[Tot].cap=edges[i].cap;

            P[Tot].flow=edges[i].flow;

            Tot++;

        }

        for(int i=; i<Tot; i++)

        {

            if(P[i].cap-P[i].flow>)

                CG[P[i].from].push_back(P[i].to);

            if(P[i].flow>)

                CG[P[i].to].push_back(P[i].from);

        }

        dfs(s);

        for(int i=; i<=M; i++)

            if((FF[U[i]]==&&FF[V[i]]==)||(FF[V[i]]==&&FF[U[i]]==))

                printf("%d %d\n",U[i],V[i]);

        printf("\n");

    }

    return ;

}