#include <iostream>
#include <vector>
#include <algorithm>

typedef int VERTEX;
typedef int TRIANGLE;
typedef int EDGE;

struct TriEdge
{
    VERTEX v1, v2;      // Vertexes of the edge
    TRIANGLE t1, t2;    // The triangles sharing the edge
    TriEdge(VERTEX _v1, VERTEX _v2, TRIANGLE _t1)
        : v1(_v1), v2(_v2), t1(_t1), t2(-1) {}
};

struct DOT
{
    int x, y;
    explicit DOT(int x_, int y_) noexcept
        : x(x_), y(y_)
    {
    }
};

static inline bool operator<(const DOT& d1, const DOT& d2)
{
    return (d1.x < d2.x) || (d1.x == d2.x && d1.y < d2.y);
}

static inline bool operator==(const DOT& d1, const DOT& d2)
{
    return d1.x == d2.x && d1.y == d2.y;
}

std::vector<VERTEX> triangles;
std::vector<TriEdge> edges;
std::vector<DOT> vertexes;

// ==========================================================================
static inline TRIANGLE getTriangleCount()
{
    return static_cast<TRIANGLE>(triangles.size() / 3);
}

static inline DOT getDotOfVertex(VERTEX v)
{
    return vertexes[v];
}

static inline EDGE getEdgeCount()
{
    return static_cast<EDGE>(edges.size());
}

// ==========================================================================
static inline VERTEX getVert1FromTriangle(TRIANGLE t)
{
    return triangles[(t * 3) + 0];
}
static inline VERTEX getVert2FromTriangle(TRIANGLE t)
{
    return triangles[(t * 3) + 1];
}
static inline VERTEX getVert3FromTriangle(TRIANGLE t)
{
    return triangles[(t * 3) + 2];
}

// ==========================================================================
static void buildEdges()
{
    edges.reserve(triangles.size() * 3);
    for (TRIANGLE t = 0, tE = getTriangleCount(); t < tE; ++t)
    {
        VERTEX v[3] = {
            getVert1FromTriangle(t),
            getVert2FromTriangle(t),
            getVert3FromTriangle(t)
        };

                                        // ARRANGE THE VERTEXES IN ASCENDING ORDER
        std::sort(std::begin(v), std::end(v));

                                        // CREATE THREE EDGES
        edges.emplace_back(v[0], v[1], t);
        edges.emplace_back(v[0], v[2], t);
        edges.emplace_back(v[1], v[2], t);
    }

    if (edges.empty())
        return;
                                        // REMOVE DUPLICATES AND MERGE SHARED EDGES
    std::sort(
        edges.begin(), 
        edges.end(), 
        [](const TriEdge& e1, const TriEdge& e2) 
        {
        return (e1.v1 < e2.v1) || (e1.v1 == e2.v1 && e1.v2 < e2.v2);
        }
    );

    for (size_t i = 0, iE = edges.size()-1; i < iE;)
    {
        TriEdge& e1 = edges[i];         // FOR EACH PAIR OF EDGES
        TriEdge& e2 = edges[i + 1];
        if (e1.v1 < 0)                  // SKIP DEAD EDGE
        {
            // Unreachable!
            ++i;
            continue;
        }

                                        // IF A DUPLICATE FOUND
        if (e1.v1 == e2.v1 && e1.v2 == e2.v2)
        {
            e1.t2 = e2.t1;              // SHARE THE EDGE BETWEEN TWO ADJACENT TRINGLES
            e2.v1 = -1;                 // MARK EDGE DEAD
            i += 2;                     // GET THE NEXT PAIR
        }
        else                            // OTHERWISE
        {
            ++i;                        // GET THE NEXT EDGE
        }
    }

                                        // REMOVE DEAD EDGES AND THE ONES HAVING ONLY ONE TRIANGLE
    auto it = std::remove_if(edges.begin(), edges.end(), 
        [](const TriEdge& e) 
    {
        return e.v1 < 0 || e.t2 < 0;
    });

    edges.erase(it, edges.end());
}

static inline bool upAndLeft(const DOT& d1, const DOT& d2)
{
    return (d1.y > d2.y) || (d1.y == d2.y && d1.x < d2.x);
}

static bool orderEdgesByY(const TriEdge& e1, const TriEdge& e2)
{
    DOT d1s = getDotOfVertex(e1.v1),
        d1e = getDotOfVertex(e1.v2),
        d2s = getDotOfVertex(e2.v1),
        d2e = getDotOfVertex(e2.v2);
    // ENSURE THE 1st VERTEX IS HIGHER
    if (d1e.y > d1s.y)
        std::swap(d1s, d1e);
    if (d2e.y > d2s.y)
        std::swap(d2s, d2e);

    return upAndLeft(d1s, d2s) || (d1s == d2s && upAndLeft(d1e, d2e));
}

static bool isEdgeLeftToRight(const TriEdge& e)
{
    DOT d1 = getDotOfVertex(e.v1),
        d2 = getDotOfVertex(e.v2);
    return d1 < d2;
}

static inline bool equalEdge(VERTEX v1, VERTEX v2, VERTEX vt1, VERTEX vt2)
{
    if (vt1 > vt2)
        std::swap(vt1, vt2);
    return v1 == vt1 && v2 == vt2;
}

static VERTEX getTheOppositeVertex(TRIANGLE t, VERTEX v1, VERTEX v2)
{
    VERTEX v[3] = 
    {
        getVert1FromTriangle(t),
        getVert2FromTriangle(t),
        getVert3FromTriangle(t)
    };

    if (equalEdge(v1, v2, v[0], v[1]))
        return v[2];
    if (equalEdge(v1, v2, v[0], v[2]))
        return v[1];
    if (equalEdge(v1, v2, v[1], v[2]))
        return v[0];

    // Unreachable
    return v[0]; // return something
}

//! \brief Get doubled area of triangle ABC
//! CCW direction is considered positive
template<typename D> inline double square2(const D& A, const D& B, const D& C)
{
    /* A cross product of two vectors AB x AC */
    return  double(A.y - B.y) * double(C.x - A.x)
        - double(A.x - B.x) * double(C.y - A.y);
}

//! Whether the dot <d> is on the right side of the segment <se>
static bool isOnTheRight(const DOT& d, const DOT& s, const DOT& e)
{
    bool retval = square2(s, e, d) < 0.0;
    return retval;
}

static TRIANGLE getRightTriangle(const TriEdge& e)
{
    VERTEX opp_vert = getTheOppositeVertex(e.t1, e.v1, e.v2);

    DOT opp_dot = getDotOfVertex(opp_vert);
    DOT d1 = getDotOfVertex(e.v1),
        d2 = getDotOfVertex(e.v2);

    if (isOnTheRight(opp_dot, d1, d2))
        return e.t1;
    else
        return e.t2;
}

static TRIANGLE getLeftTriangle(const TriEdge& e)
{
    TRIANGLE t = getRightTriangle(e);
    return (t == e.t1)  ? e.t2 
                        : e.t1;
}

static bool loadData()
{
    /* 
     * The first line contains two integers:
     * Number of vertexes N (3 <= N <= 10M) and
     * number of triangles M (1 <= M <= 10M)
     * The following N lines contain vertexes' coordinates (a pairs of integers)
     * The following M lines contain triples of vertexes (starting from 1)
    */

    int N = 0, M = 0;
    std::cin >> N >> M;
    if (N < 3 || 10000000 < N)
    {
        std::cerr << "The number of vertexes is invalid. Got " 
            << N << ", expected [3, 10M]\n";
        return false;
    }
    if (M < 1 || 10000000 < M)
    {
        std::cerr << "The number of triangles is invalid. Got "
            << M << ", expected [1, 10M]\n";
        return false;
    }

    vertexes.reserve(N);

    for (int i = 0; i < N; ++i)
    {
        if (!std::cin)
        {
            std::cerr << "Inconsistent data. Failed to read vertexes\n";
            return false;
        }

        int x = 0, y = 0;
        std::cin >> x >> y;
        vertexes.emplace_back(x, y);
    }

    triangles.reserve(M * 3);
    for (int i = 0; i < M; ++i)
    {
        if (!std::cin)
        {
            std::cerr << "Inconsistent data. Failed to read triangles\n";
            return false;
        }

        int v1 = -1, v2 = -1, v3 = -1;
        std::cin >> v1 >> v2 >> v3;
        triangles.push_back(v1 - 1);
        triangles.push_back(v2 - 1);
        triangles.push_back(v3 - 1);
    }

    return true;
}

int main(int argc, char *argv[])
{
    // READ INPUT DATA
    if (!loadData())
        return 1;

    // BUILD EDGES
    buildEdges();

    // ORDER EDGES BY Y
    std::sort(edges.begin(), edges.end(), orderEdgesByY);

    std::vector<bool> visited_tri(getTriangleCount(), false);
    const char* pszDelimiter = "";
    // FOR EACH EDGE
    for (const TriEdge& e : edges)
    {
        // CHOOSE THE UPPER TRIANGLE
        TRIANGLE tt[2] = { getRightTriangle(e),
                           getLeftTriangle(e) };
        if (isEdgeLeftToRight(e))
            std::swap(tt[0], tt[1]);

        // OUTPUT
        for(TRIANGLE t : tt)
        {
            if (!visited_tri[t])
            {
                std::cout << pszDelimiter << t + 1;
                pszDelimiter = " ";
                visited_tri[t] = true;  /* Do not print the triangle twice */
            }
        }
    }

    return 0;
}