#include <iostream>
#include <cstdio>
#include <vector>
#include <string.h>
#include <algorithm>
#include <time.h>
#define INF 2100000000
#define TLIMIT 4600
#define DEADLINE 4800
using namespace std;
typedef int lld;


/// STRUCTURES
struct FLOW
{
    lld sx, sy, ex, ey;
    lld dist, id;
};
FLOW Make_Flow(lld sx, lld sy, lld ex, lld ey, lld id)
{
    FLOW ret;
    ret.sx = sx; ret.sy = sy; ret.ex = ex; ret.ey = ey; ret.dist = max(sx, ex) - min(sx, ex) + max(sy, ey) - min(sy, ey); ret.id = id;
    return ret;
}

struct QWE
{
    lld x, y, prevind;
};
QWE Make_QWE(lld x, lld y, lld prevind)
{
    QWE ret;
    ret.x = x; ret.y = y; ret.prevind = prevind;
    return ret;
}

/// SORTING FUNCTIONS
bool SH_FLOW_ByDist_DESC(FLOW a, FLOW b)
{
    return (a.dist > b.dist);
}
bool SH_FLOW_ByDist_ASC(FLOW a, FLOW b)
{
    return (a.dist < b.dist);
}
bool SH_FLOW_ById(FLOW a, FLOW b)
{
    return (a.id < b.id);
}

///PROGRAM
lld coolx[4] = {1, -1, 0, 0}, cooly[4] = {0, 0, 1, -1};
lld n, asz;
FLOW available[252];
bool forbidden[102][102], TFO[102][102], curgrid[102][102];
bool isflow[102][102];

void Input()
{
    scanf("%d %d", &n, &asz);
    for (lld i=1; i<=asz; i++)
    {
        lld sx, sy, ex, ey;

        scanf("%d %d %d %d", &sx, &sy, &ex, &ey);
        sx++; sy++; ex++; ey++;

        isflow[sx][sy] = isflow[ex][ey] = true;

        available[i] = Make_Flow(sx, sy, ex, ey, i);
    }

    lld b;
    scanf("%d", &b);
    for (lld i=1; i<=b; i++)
    {
        lld x, y;

        scanf("%d %d", &x, &y);
        x++; y++;

        forbidden[x][y] = true;
        curgrid[x][y] = true;
    }
}

lld tlm = CLOCKS_PER_SEC * TLIMIT / 1000;
bool HaveTime()
{
    return (clock() < tlm);
}
lld ddln = CLOCKS_PER_SEC * DEADLINE / 1000;
bool TryHard()
{
    return (clock() < ddln);
}

bool Legit(lld x, lld y)
{
    return (x >= 1 && x <= n && y >= 1 && y <= n);
}

QWE q[10002];
lld qsz;
lld ranind[5];

bool FindPath_BFS(lld sx, lld sy, lld ex, lld ey, pair<lld, lld> target[], bool stepover = false)
{
    if (curgrid[sx][sy] || curgrid[ex][ey]) return false;
    //cout<<"Tursim ot "<<sx<<","<<sy<<" do "<<ex<<","<<ey<<"\n";
    QWE cur, hpr;
    lld indr = 1, indw;
    bool success=false;

    qsz = 0;
    memset(TFO, 0, sizeof(TFO));

    q[++qsz] = Make_QWE(sx, sy, 0);
    TFO[sx][sy] = true;

    while (indr <= qsz)
    {
        cur = q[indr];

        if (cur.x == ex && cur.y == ey)
        {
            success = true;
            break;
        }

        random_shuffle(ranind, ranind+4);
        for (lld i=0; i<4; i++)
        {
            lld sv = i;
            i = ranind[i];

            lld nx = cur.x+coolx[i], ny = cur.y+cooly[i];
            if (curgrid[nx][ny] || !Legit(nx, ny) || TFO[nx][ny] || (!stepover && (isflow[nx][ny] && (nx != ex || ny != ey))))
            {
                i = sv;
                continue;
            }

            TFO[nx][ny] = true;
            q[++qsz] = Make_QWE(nx, ny, indr);
            i = sv;
        }

        indr++;
    }

    if (!success) return false;

    indw=1;
    do
    {
        target[indw++] = make_pair(q[indr].x, q[indr].y);
        indr = q[indr].prevind;
    }
    while (indr > 0);

    //reverse(target+1, target+indw);

    target[0].first = indw-1;
    return true;
}
bool FindPath_BFS(FLOW fl, pair<lld, lld> target[], bool stepover = false)
{
    return FindPath_BFS(fl.sx, fl.sy, fl.ex, fl.ey, target, stepover);
}

lld indw;
bool towrite;

bool FindPath_DFS(lld x, lld y, lld ex, lld ey, pair<lld, lld> target[], bool stepover = false)
{
    if (curgrid[x][y] || curgrid[ex][ey]) return false;

    //cout<<"Na "<<x<<","<<y<<" sme, tursim "<<ex<<","<<ey<<"\n";

    if (x == ex && y == ey)
    {
       // //cout<<"Success!\n";
        towrite = true;
        indw = 1;
        target[indw++] = make_pair(ex, ey);
        target[0].first = indw-1;
        return true;
    }

    random_shuffle(ranind, ranind+4);

    TFO[x][y] = true;
    for (lld i=0; i<4; i++)
    {
        lld sv = i;
        i = ranind[i];

        lld nx = x+coolx[i], ny = y+cooly[i];
        if (!Legit(nx, ny) || curgrid[nx][ny] || TFO[nx][ny] || (!stepover && (isflow[nx][ny] && (nx != ex || ny != ey))))
        {
            i = sv;
            continue;
        }

        FindPath_DFS(nx, ny, ex, ey, target);
        //cout<<x<<","<<y<<" se vurnahme\n";
        if (towrite)
        {
            target[0].first = indw;
            target[indw++] = make_pair(x, y);
            return true;
        }

        i = sv;
    }

    //cout<<"Vrushtame se ot "<<x<<","<<y<<" na: ";
    return false;
}
bool FindPath_DFS(FLOW fl, pair<lld, lld> target[], bool stepover = false)
{
    return FindPath_DFS(fl.sx, fl.sy, fl.ex, fl.ey, target, stepover);
}

pair<lld, lld> path[10002];

lld curans=0;
pair<lld, lld> ans[252][10002], info[252][10002], playtime[10002], temp[10002], best[10002];

lld Evaluate(pair<lld, lld> info[252][10002])
{
    lld fcnt=0, area=0;

    for (lld i=1; i<=asz; i++)
    {
        if (info[available[i].id][0].first == 0)
        {
            continue;
        }

        fcnt++;
        area += info[available[i].id][0].first;
    }

    return fcnt*area;
}
void ShiftWith(lld from, lld with, pair<lld, lld> target[])
{
    lld len = target[0].first;
    for (lld i=len; i>=from; i--)
    {
        target[i+with] = target[i];
    }

    target[0].first += with;
}
void PutAfter(lld after, pair<lld, lld> toput[], pair<lld, lld> target[])
{
    ShiftWith(after+1, toput[0].first, target);
    for (lld i=1; i<=toput[0].first; i++)
    {
        target[after+i] = toput[i];
    }
}

void Copy(pair<lld, lld> source[], pair<lld, lld> target[])
{
    for (lld i=0; i<=source[0].first; i++)
    {
        target[i] = source[i];
    }
}

lld Expand(pair<lld, lld> source[])
{
    lld myindw=1;
    lld expansion=0;

    if (source[0].first == 0) return 0;
    Copy(source, playtime);

    for (lld j=1; j<playtime[0].first; j++)
    {
        source[myindw++] = playtime[j];

        best[0].first = 0;

        curgrid[playtime[j].first][playtime[j].second] = false;
        curgrid[playtime[j+1].first][playtime[j+1].second] = false;

        memset(TFO, 0, sizeof(TFO));
        indw = 1; towrite = false;

        bool success = FindPath_DFS(playtime[j].first, playtime[j].second, playtime[j+1].first, playtime[j+1].second, best);

        curgrid[playtime[j].first][playtime[j].second] = true;
        curgrid[playtime[j+1].first][playtime[j+1].second] = true;

        if (!success) continue;

        reverse(best+1, best+best[0].first+1);
        expansion += best[0].first-2;
        for (lld ii=2; ii<best[0].first; ii++)
        {
            source[myindw++] = best[ii];
            curgrid[best[ii].first][best[ii].second] = true;
        }
    }

    source[0].first = myindw;
    source[myindw++] = playtime[playtime[0].first];
    return expansion;
}

void TestSorting()
{
    for (lld i=0; i<102; i++)
    {
        for (lld j=0; j<102; j++)
        {
            curgrid[i][j] = forbidden[i][j];
        }
    }

    lld chance, expansion=0;
    lld res = 0;

    chance = max (2, n/10);
    for (lld i=1; i<=asz; i++)
    {
        bool gowithdfs = false;


        if (gowithdfs)
        {
            memset(TFO, 0, sizeof(TFO));
            indw = 1; towrite = false;
            if (!FindPath_DFS(available[i], info[available[i].id]))
            {
                info[available[i].id][0].first = 0;
                continue;
            }
        }
        else
        {
            if (!FindPath_BFS(available[i], info[available[i].id]))
            {
                info[available[i].id][0].first = 0;
                continue;
            }
        }

        res++;
        lld cura = available[i].id;
        for (lld j=1; j<=info[cura][0].first; j++)
        {
            curgrid[ info[cura][j].first ][ info[cura][j].second ] = true;
        }
    }


    if (res > curans)
    {
        curans = res;
        //cout<<"Found "<<res<<"\n";
        for (lld i=1; i<=asz; i++)
        {
            ans[i][0] = info[i][0];

            if (info[i][0].first == 0)
            {
                continue;
            }

            for (lld j=1; j<=info[i][0].first; j++)
            {
                ans[i][j] = info[i][j];
            }
        }
    }
    /*else if (res == curans)
    {
        for (lld i=1; i<=asz; i++)
        {
            lld cura = available[i].id;
            Expand(info[cura]);
        }

        if (Evaluate(ans) < Evaluate(info))
        {
            curans = res;
            //cout<<"Found "<<res<<"\n";
            for (lld i=1; i<=asz; i++)
            {
                ans[i][0] = info[i][0];

                if (info[i][0].first == 0)
                {
                    continue;
                }

                for (lld j=1; j<=info[i][0].first; j++)
                {
                    ans[i][j] = info[i][j];
                }
            }
        }
    }*/

}

int main ()
{
    srand(22335577);

    //freopen("input.txt", "r", stdin);
    freopen("flow.in", "r", stdin);
    freopen("flow.out", "w", stdout);

    for (lld i=0; i<5; i++)
    {
        ranind[i] = i;
    }

    Input();

    sort(available+1, available+n+1, SH_FLOW_ByDist_DESC);
    TestSorting();

    do
    {
        random_shuffle(available+1, available+asz+1);
        TestSorting();
       // return 0;
    }
    while (HaveTime());

    for (lld i=0; i<102; i++)
    {
        for (lld j=0; j<102; j++)
        {
            curgrid[i][j] = forbidden[i][j];
        }
    }

    for (lld i=1; i<=asz; i++)
    {
        if (ans[i][0].first == 0)
        {
            continue;
        }

        for (lld j=1; j<=ans[i][0].first; j++)
        {
            curgrid[ ans[i][j].first ] [ ans[i][j].second ] = true;
        }
    }

    lld win;
    do
    {
        win = 0;
        for (lld i=1; i<=asz; i++)
        {
            win += Expand(ans[i]);
        }
    }
    while (TryHard() && win > 0);
    //cout<<Evaluate(ans)<<" <- the result\n";

    for (lld i=1; i<=asz; i++)
    {
        if (ans[i][0].first == 0)
        {
            printf("0\n");
            continue;
        }

        printf("%d ", ans[i][0].first);
        for (lld j=1; j<=ans[i][0].first; j++)
        {
            printf(" %d %d", ans[i][j].first-1, ans[i][j].second-1);
        }
        printf("\n");
    }