#include <cstdio>
#include <vector>
#include <cstring>
#include <cstdlib>
#include <algorithm>

using namespace std;

#define MaxN 100100

struct Edge {
    int vec, flux;
    Edge(int v) {
        vec = v;
        flux = 0;
    }
};

int N, M, doneEdges = 0;
vector<Edge> edges[MaxN];
int cd[MaxN], t[MaxN];
bool viz[MaxN], haveTouched[MaxN];
int startNode = 0;
bool stillCycling;

bool CompFlux(const Edge &a, const Edge &b) {
    return a.flux < b.flux;
}

void IncremFlow(int x, int y, int flux) {
    haveTouched[x] = true; //good touch, not bad touch
    for (size_t i = 0; i < edges[x].size(); i++) {
        if (edges[x][i].vec == y) {
            doneEdges += (edges[x][i].flux == 0 && flux > 0);
            edges[x][i].flux += flux;
            return;
        }
    }
}

void MarkEdge(int x, int y) {
    IncremFlow(x, y, 1);
    IncremFlow(y, x, -1);
}

bool HaveEdges(int x) {
    for (size_t i = 0; i < edges[x].size(); i++) {
        if (edges[x][i].flux == 0) {
            return true;
        }
    }
    return false;
}

void ReversePath(int nod) {
    MarkEdge(nod, startNode);
    while (nod != startNode) {
        //fprintf(stderr, "%d ", nod + 1);
        MarkEdge(t[nod], nod);
        nod = t[nod];
    }
    //fprintf(stderr, "%d\n", startNode + 1);
}

void df(int nod) {
    sort(edges[nod].begin(), edges[nod].end(), CompFlux);
    for (int i = 0; i < (int)edges[nod].size() && stillCycling; i++) {
        const int vec = edges[nod][i].vec;
        if (edges[nod][i].flux >= 0 && t[vec] == -1 && vec != t[nod]) {

            if (vec == startNode) {
                stillCycling = false;
                ReversePath(nod);
                return;
            }

            t[vec] = nod;
            df(vec);
        }
    }
}

void FindCycle() {
    int st = 0, fn = 0;

    memset(viz, 0, N);
    memset(t, -1, sizeof(int) * N);

    while (!HaveEdges(startNode) && startNode < N) {
        startNode++;
    }

    stillCycling = true;

    for (size_t i = 0; i < edges[startNode].size(); i++) {
        if (edges[startNode][i].flux == 0) {
            const int v = edges[startNode][i].vec;
            t[v] = startNode;
            viz[v] = true;
            df(v);
        }
    }
}

int main() {
    freopen("nowhere-zero.in", "rb", stdin);
    freopen("nowhere-zero.out", "wb", stdout);
    scanf("%d %d\n", &N, &M);

    for (int i = 0; i < N; i++) {
        double x, y;
        scanf("%lf %lf", &x, &y);
    }

    fprintf(stderr, "%d %d\n", N, M);

    for (int i = 0; i < M; i++) {
        int x, y;
        scanf("%d %d", &x, &y);
        x--; y--;
        edges[x].push_back(y);
        edges[y].push_back(x);
    }

    fprintf(stderr, "%d %d\n", N, M);

    while (doneEdges < M) {
        FindCycle();
    }

    for (int i = 0; i < N; i++) {
        for (size_t j = 0; j < edges[i].size(); j++) {
            if (edges[i][j].flux > 0) {
                printf("%d %d %d\n", i + 1, edges[i][j].vec + 1, edges[i][j].flux);
            }
        }
    }

    return 0;
}