#include <iostream>
#include <algorithm>
#include <cstring>

typedef long long ll;
typedef double lf;

// #define DEBUG 1
struct IO
{
    #define MAXSIZE (1 << 20)
    #define isdigit(x) (x >= '0' && x <= '9')
    char buf[MAXSIZE], *p1, *p2;
    char pbuf[MAXSIZE], *pp;
    #if DEBUG
    #else
    IO() : p1(buf), p2(buf), pp(pbuf) {}
    ~IO() {fwrite(pbuf, 1, pp - pbuf, stdout);}
    #endif
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? ' ' : *p1++)
    #define blank(x) (x == ' ' || x == '\n' || x == '\r' || x == '\t')

    template <typename T>
    void Read(T &x)
    {
        #if DEBUG
        std::cin >> x;
        #else
        bool sign = 0; char ch = gc(); x = 0;
        for (; !isdigit(ch); ch = gc())
            if (ch == '-') sign = 1;
        for (; isdigit(ch); ch = gc()) x = x * 10 + (ch ^ 48);
        if (sign) x = -x;
        #endif
    }
    void Read(char *s)
    {
        #if DEBUG
        std::cin >> s;
        #else
        char ch = gc();
        for (; blank(ch); ch = gc());
        for (; !blank(ch); ch = gc()) *s++ = ch;
        *s = 0;
        #endif
    }
    void Read(char &c) {for (c = gc(); blank(c); c = gc());}

    void Push(const char &c)
    {
        #if DEBUG
        putchar(c);
        #else
        if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
        *pp++ = c;
        #endif
    }
    template <typename T>
    void Write(T x)
    {
        if (x < 0) x = -x, Push('-');
        static T sta[35];
        int top = 0;
        do sta[top++] = x % 10, x /= 10; while (x);
        while (top) Push(sta[--top] ^ 48);
    }
    template <typename T>
    void Write(T x, char lst) {Write(x), Push(lst);}
} IO;
#define Read(x) IO.Read(x)
#define Write(x, y) IO.Write(x, y)
#define Put(x) IO.Push(x)

using namespace std;

const int MAXN = 2e5 + 10;

int n, m;
struct point
{
    int x, y;
}a[MAXN];
int m1, m2, b1[MAXN], b2[MAXN];
int X[2][MAXN], Y[2][MAXN];

struct qry
{
    int x, y, lp[2], rp[2], id;
    int d0[2], d1[2];
    int pcnt[2], scnt[2];
    int pre[2], suf[2];
    int mid[2][2];
}qt[MAXN];

int lg[MAXN];
struct RMQ
{
    int f[MAXN][19], g[MAXN][19];
    inline void Build(int *a)
    {
        for (int i = 1; i <= n; i++) f[i][0] = g[i][0] = a[i];
        for (int j = 1; j < lg[n]; j++)
            for (int i = 1; i + (1 << j) - 1 <= n; i++)
                f[i][j] = min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]), g[i][j] = max(g[i][j - 1], g[i + (1 << j - 1)][j - 1]);
    }
    inline int qmin(int l, int r)
    {
        if (l > r) return 2e9;
        int s = lg[r - l + 1] - 1;
        return min(f[l][s], f[r - (1 << s) + 1][s]);
    }
    inline int qmax(int l, int r)
    {
        if (l > r) return -2e9;
        int s = lg[r - l + 1] - 1;
        return max(g[l][s], g[r - (1 << s) + 1][s]);
    }
}rx, ry;

int idx[MAXN], ai[MAXN];

int bit1[MAXN], bit2[MAXN];
inline void Add(int x, int k) { for (; x <= m2; x += (x & -x)) bit1[x] = min(bit1[x], k), bit2[x] = max(bit2[x], k); }
inline pair <int, int> Ask(int x) { int res1 = 2e9, res2 = -2e9; for (; x; x -= (x & -x)) res1 = min(res1, bit1[x]), res2 = max(res2, bit2[x]); return {res1, res2}; }

struct node
{
    int t, id, f, _;
    bool operator < (const node &u) const { return t < u.t; }
}h[MAXN << 2];
int tot, hr[MAXN << 2];

struct subqry
{
    int x, y, id;
}st[MAXN << 3];
int top;

int bit[MAXN];
inline void Upd(int x, int k) { for (; x <= m2; x += (x & -x)) bit[x] += k; }
inline int Qry(int x) { int res = 0; for (; x; x -= (x & -x)) res += bit[x]; return res; }

inline void Solve1(int l, int r, int ql, int qr)
{
    if (l > r || ql > qr) return;
    if (l == r)
    {
        for (int i = ql; i <= qr; i++) hr[i] += (a[l].x >= qt[h[i].id].x) && (a[l].y <= qt[h[i].id].y);
        return;
    }
    int mid = l + r >> 1, qmid = ql - 1;
    while (qmid < qr && h[qmid + 1].t <= mid) qmid++;
    top = 0;
    for (int i = l; i <= mid; i++) st[++top] = subqry{a[i].x, a[i].y, 0};
    for (int i = qmid + 1; i <= qr; i++) st[++top] = subqry{qt[h[i].id].x, qt[h[i].id].y, i};
    sort(st + 1, st + top + 1, [&](const subqry &u, const subqry &v) { return u.x == v.x ? (u.y == v.y ? u.id < v.id : u.y < v.y) : u.x > v.x; });
    for (int i = 1; i <= top; i++)
        if (st[i].id == 0) Upd(st[i].y, 1);
        else hr[st[i].id] += Qry(st[i].y);
    for (int i = 1; i <= top; i++)
        if (st[i].id == 0) Upd(st[i].y, -1);
    Solve1(l, mid, ql, qmid), Solve1(mid + 1, r, qmid + 1, qr);
}
inline void Solve2(int l, int r, int ql, int qr)
{
    if (l > r || ql > qr) return;
    if (l == r)
    {
        for (int i = ql; i <= qr; i++) hr[i] += (a[l].x <= qt[h[i].id].x) && (a[l].y >= qt[h[i].id].y);
        return;
    }
    int mid = l + r >> 1, qmid = ql - 1;
    while (qmid < qr && h[qmid + 1].t <= mid) qmid++;
    top = 0;
    for (int i = l; i <= mid; i++) st[++top] = subqry{a[i].x, a[i].y, 0};
    for (int i = qmid + 1; i <= qr; i++) st[++top] = subqry{qt[h[i].id].x, qt[h[i].id].y, i};
    sort(st + 1, st + top + 1, [&](const subqry &u, const subqry &v) { return u.x == v.x ? (u.y == v.y ? u.id < v.id : u.y > v.y) : u.x < v.x; });
    for (int i = 1; i <= top; i++)
        if (st[i].id == 0) Upd(m2 - st[i].y + 1, 1);
        else hr[st[i].id] += Qry(m2 - st[i].y + 1);
    for (int i = 1; i <= top; i++)
        if (st[i].id == 0) Upd(m2 - st[i].y + 1, -1);
    Solve2(l, mid, ql, qmid), Solve2(mid + 1, r, qmid + 1, qr);
}

int s, t, pre[9], suf[9];
int cx(int x) { return (x > s ? 2 : (x == s ? 1 : 0)); }
int cy(int y) { return (y > t ? 2 : (y == t ? 1 : 0)); }
int tr(int i) { return cx(a[i].x) * 3 + cy(a[i].y); }

int main()
{
    // freopen("A.in", "r", stdin);
    // freopen("A.out", "w", stdout);
    #if DEBUG
    #else
    ios::sync_with_stdio(0), cin.tie(0);
    #endif
    Read(n), Read(m);
    for (int i = 1; i <= n; i++) Read(a[i].x), Read(a[i].y), b1[++m1] = a[i].x, b2[++m2] = a[i].y;
    sort(b1 + 1, b1 + m1 + 1), m1 = unique(b1 + 1, b1 + m1 + 1) - b1 - 1;
    sort(b2 + 1, b2 + m2 + 1), m2 = unique(b2 + 1, b2 + m2 + 1) - b2 - 1;
    b1[m1 + 1] = b2[m2 + 1] = -1;
    for (int i = 1; i <= n; i++)
        a[i].x = lower_bound(b1 + 1, b1 + m1 + 1, a[i].x) - b1, 
        a[i].y = lower_bound(b2 + 1, b2 + m2 + 1, a[i].y) - b2;
    for (int i = 1, j = 1; i <= m; i++)
    {
        Read(qt[i].x), Read(qt[i].y), qt[i].id = j++;
        int xx = lower_bound(b1 + 1, b1 + m1 + 1, qt[i].x) - b1;
        int yy = lower_bound(b2 + 1, b2 + m2 + 1, qt[i].y) - b2;
        if (qt[i].x != b1[xx] || qt[i].y != b2[yy]) { i--, m--; continue; }
        qt[i].x = xx, qt[i].y = yy;
    }
    for (int i = 1; i <= n; i++) X[1][a[i].x] = i, Y[1][a[i].y] = i;
    for (int i = n; i >= 1; i--) X[0][a[i].x] = i, Y[0][a[i].y] = i;
    for (int i = 1; i <= m; i++)
    {
        qt[i].lp[0] = X[0][qt[i].x], qt[i].rp[0] = Y[1][qt[i].y];
        qt[i].lp[1] = Y[0][qt[i].y], qt[i].rp[1] = X[1][qt[i].x];
        if (!qt[i].lp[0]) qt[i].lp[0] = n + 1;
        if (!qt[i].lp[1]) qt[i].lp[1] = n + 1;
    }

    // for (int i = 1; i <= n; i++) cout << a[i].x << ' ' << a[i].y << '\n';
    // cout << '\n';
    // for (int i = 1; i <= m; i++) cout << qt[i].x << ' ' << qt[i].y << '\n';
    // cout << '\n';

    // for (int i = 1; i <= m; i++)
    //     cout << qt[i].lp[0] << ' ' << qt[i].rp[0] << ' ' << qt[i].lp[1] << ' ' << qt[i].rp[1] << '\n'; cout << "\n";

    for (int i = 1; i <= n; i++) b1[i] = a[i].x, b2[i] = a[i].y, lg[i] = lg[i >> 1] + 1;
    rx.Build(b1), ry.Build(b2);
    
    for (int i = 1; i <= m; i++)
        for (int _ = 0; _ < 2; _++)
        {
            int xx = a[i].x, yy = a[i].y;
            int l = 2, r = qt[i].lp[_] - 1, mid, cpos = r;
            while (l <= r)
            {
                mid = l + r >> 1;
                if ((xx > a[1].x ? rx.qmax(1, mid) < xx : (xx < a[1].x ? rx.qmin(1, mid) > xx : rx.qmin(1, mid) == rx.qmax(1, mid))) &&
                    (yy > a[1].y ? ry.qmax(1, mid) < yy : (yy < a[1].y ? ry.qmin(1, mid) > yy : ry.qmin(1, mid) == ry.qmax(1, mid))))
                    l = mid + 1;
                else r = mid - 1;
            }
            qt[i].d0[_] = l;
            if (cpos == 0) qt[i].pcnt[_] = 0;
            else if ((rx.qmax(1, cpos) < xx || rx.qmin(1, cpos) > xx || rx.qmax(1, cpos) == rx.qmin(1, cpos)) &&
                (ry.qmax(1, cpos) < yy || ry.qmin(1, cpos) > yy || ry.qmax(1, cpos) == ry.qmin(1, cpos)))
                    qt[i].pcnt[_] = 1;
            else qt[i].pcnt[_] = 2;
        }
    for (int i = 1; i <= m; i++)
        for (int _ = 0; _ < 2; _++)
        {
            int xx = a[i].x, yy = a[i].y;
            int l = qt[i].rp[_] + 1, r = n - 1, mid, cpos = l;
            while (l <= r)
            {
                mid = l + r >> 1;
                if ((xx > a[n].x ? rx.qmax(mid, n) < xx : (xx < a[n].x ? rx.qmin(mid, n) > xx : rx.qmin(mid, n) == rx.qmax(mid, n))) && 
                    (yy > a[n].y ? ry.qmax(mid, n) < yy : (yy < a[n].y ? ry.qmin(mid, n) > yy : ry.qmin(mid, n) == ry.qmax(mid, n))))
                    r = mid - 1;
                else l = mid + 1;
            }
            qt[i].d1[_] = r;
            if (cpos == n + 1) qt[i].scnt[_] = 0;
            else if ((rx.qmax(cpos, n) < xx || rx.qmin(cpos, n) > xx || rx.qmax(cpos, n) == rx.qmin(cpos, n)) &&
                (ry.qmax(cpos, n) < yy || ry.qmin(cpos, n) > yy || ry.qmax(cpos, n) == ry.qmin(cpos, n)))
                    qt[i].scnt[_] = 1;
            else qt[i].scnt[_] = 2;
        }

    // for (int i = 1; i <= m; i++)
    //     cout << qt[i].d0[0] << ' ' << qt[i].d1[0] << ' ' << qt[i].d0[1] << ' ' << qt[i].d1[1] << '\n'; cout << '\n';
    // for (int i = 1; i <= m; i++)
    //     cout << qt[i].pcnt[0] << ' ' << qt[i].pcnt[1] << ' ' << qt[i].scnt[0] << ' ' << qt[i].scnt[1] << "\n";

    for (int i = 0; i <= m2; i++) bit1[i] = 2e9, bit2[i] = -2e9;
    for (int i = 1; i <= m; i++) idx[i] = i;
    for (int i = 1; i <= n; i++) ai[i] = i;
    sort(idx + 1, idx + m + 1, [&](int x, int y) { return qt[x].x < qt[y].x; });
    sort(ai + 1, ai + n + 1, [&](int x, int y) { return a[x].x < a[y].x; });
    for (int i = 1, j = 1; i <= m; i++)
    {
        while (j <= n && a[ai[j]].x < qt[idx[i]].x) Add(m2 - a[ai[j]].y + 1, ai[j]), j++;
        auto cur = Ask(m2 - qt[idx[i]].y);
        qt[idx[i]].pre[0] = cur.first, qt[idx[i]].suf[0] = cur.second;
    }
    for (int i = 0; i <= m2; i++) bit1[i] = 2e9, bit2[i] = -2e9;
    for (int i = m, j = n; i >= 1; i--)
    {
        while (j >= 1 && a[ai[j]].x > qt[idx[i]].x) Add(a[ai[j]].y, ai[j]), j--;
        auto cur = Ask(qt[idx[i]].y - 1);
        qt[idx[i]].pre[1] = cur.first, qt[idx[i]].suf[1] = cur.second;
    }

    for (int i = 1; i <= m; i++)
        for (int _ = 0; _ < 2; _++)
            if (qt[i].lp[_] + 1 < qt[i].rp[_])
                h[++tot] = node{qt[i].lp[_], i, -1, _}, h[++tot] = node{qt[i].rp[_] - 1, i, 1, _};
    sort(h + 1, h + tot + 1);
    Solve1(1, n, 1, tot);
    // for (int i = 1; i <= tot; i++)
    // {
    //     cout << h[i].t << ' ' << h[i].id << ' ' << h[i]._ << ' ' << h[i].f << ' ' << hr[i] << '\n';
    // }
    for (int i = 1; i <= tot; i++) qt[h[i].id].mid[h[i]._][0] += h[i].f * hr[i], hr[i] = 0;
    Solve2(1, n, 1, tot);
    for (int i = 1; i <= tot; i++) qt[h[i].id].mid[h[i]._][1] += h[i].f * hr[i], hr[i] = 0;

    // for (int i = 1; i <= m; i++, cout << '\n')
    //     for (int _ = 0; _ < 2; _++)
    //         cout << qt[i].mid[_][0] << ' ' << qt[i].mid[_][1] << ' '; cout << "\n";

    // for (int i = 1; i <= m; i++) cout << qt[i].pre[0] << ' ' << qt[i].pre[1] << ' ' << qt[i].suf[0] << ' ' << qt[i].suf[1] << "\n";

    for (int k = 1; k <= m; k++)
    {
        s = qt[k].x, t = qt[k].y;
        bool flag = 0;
        int lp = qt[k].lp[0], rp = qt[k].rp[0];
        if (lp <= rp)
        {
            memset(pre, 0, sizeof(pre)), memset(suf, 0, sizeof(suf));
            int d0 = qt[k].d0[0], d1 = qt[k].d1[0], c0 = qt[k].pcnt[0], c1 = qt[k].scnt[0];
            bool a0[3] = {0}, a1[3] = {0};

            if (qt[k].pre[0] < lp) pre[2] = qt[k].pre[0];
            if (qt[k].pre[1] < lp) pre[6] = qt[k].pre[1];
            if (qt[k].suf[0] > rp) suf[2] = qt[k].suf[0];
            if (qt[k].suf[1] > rp) suf[6] = qt[k].suf[1];

            if (lp == rp) { flag |= (c0 != 1 || (tr(1) != 2 && tr(1) != 6)) && (c1 != 1 || (tr(n) != 2 && tr(n) != 6)); goto NXT; }

            if (cy(a[lp].y) == 1)
            {
                if (c0 != 1 || (tr(1) != 2 && tr(1) != 6)) { flag = 1; goto NXT; }
                a0[3 - tr(1) / 2] = 1;
            }
            else
            {
                a0[cy(a[lp].y)] = c0 != 1 || !pre[cy(a[lp].y) * 2 + 2];
                a0[2 - cy(a[lp].y)] = pre[cy(a[lp].y) * 2 + 2] && (pre[cy(a[lp].y) * 2 + 2] != d0 || tr(1) != 6 - 2 * cy(a[lp].y));
            }
            if (cx(a[rp].x) == 1)
            {
                if (c1 != 1 || (tr(n) != 2 && tr(n) != 6)) { flag = 1; goto NXT; }
                a1[tr(n) / 2 - 1] = 1;
            }
            else
            {
                a1[cx(a[rp].x)] = c1 != 1 || !suf[6 - 2 * cx(a[rp].x)];
                a1[2 - cx(a[rp].x)] = suf[6 - 2 * cx(a[rp].x)] && (suf[6 - 2 * cx(a[rp].x)] != d1 || tr(n) != cx(a[rp].x) * 2 + 2);
            }

            // cout << a0[0] << ' ' << a0[2] << ' ' << a1[0] << ' ' << a1[2] << '\n';
            if ((a0[0] && a1[0]) || (a0[2] && a1[2])) { flag = 1; goto NXT; }
            bool f1 = 1, f2 = 1;
            if (a0[0]) f1 = 0; if (a0[2]) f2 = 0;
            if (a1[0]) f2 = 0; if (a1[2]) f1 = 0;
            // cout << f1 << " " << f2 << "\n";
            if (lp + 1 < rp && qt[k].mid[0][0]) f1 = 0;
            if (lp + 1 < rp && qt[k].mid[0][1]) f2 = 0;
            // cout << f1 << ' ' << f2 << "\n";
            flag |= !(f1 || f2);
        }
        NXT:
        lp = qt[k].lp[1], rp = qt[k].rp[1];
        if (lp <= rp)
        {
            memset(pre, 0, sizeof(pre)), memset(suf, 0, sizeof(suf));
            int d0 = qt[k].d0[1], d1 = qt[k].d1[1], c0 = qt[k].pcnt[1], c1 = qt[k].scnt[1];
            bool a0[3] = {0}, a1[3] = {0};

            if (qt[k].pre[0] < lp) pre[2] = qt[k].pre[0];
            if (qt[k].pre[1] < lp) pre[6] = qt[k].pre[1];
            if (qt[k].suf[0] > rp) suf[2] = qt[k].suf[0];
            if (qt[k].suf[1] > rp) suf[6] = qt[k].suf[1];

            if (lp == rp) { flag |= (c0 != 1 || (tr(1) != 2 && tr(1) != 6)) && (c1 != 1 || (tr(n) != 2 && tr(n) != 6)); goto END; }

            if (cx(a[lp].x) == 1)
            {
                if (c0 != 1 || (tr(1) != 2 && tr(1) != 6)) { flag = 1; goto END; }
                a0[tr(1) / 2 - 1] = 1;
            }
            else
            {
                a0[cx(a[lp].x)] = c0 != 1 || !pre[6 - 2 * cx(a[lp].x)];
                a0[2 - cx(a[lp].x)] = pre[6 - 2 * cx(a[lp].x)] && (pre[6 - 2 * cx(a[lp].x)] != d0 || tr(1) != cx(a[lp].x) * 2 + 2);
            }
            if (cy(a[rp].y) == 1)
            {
                if (c1 != 1 || (tr(n) != 2 && tr(n) != 6)) { flag = 1; goto END; }
                a1[3 - tr(n) / 2] = 1;
            }
            else
            {
                a1[cy(a[rp].y)] = c1 != 1 || !suf[cy(a[rp].y) * 2 + 2];
                a1[2 - cy(a[rp].y)] = suf[cy(a[rp].y) * 2 + 2] && (suf[cy(a[rp].y) * 2 + 2] != d1 || tr(n) != 6 - 2 * cx(a[rp].y));
            }

            // cout << a0[0] << ' ' << a0[2] << ' ' << a1[0] << ' ' << a1[2] << '\n';
            if ((a0[0] && a1[0]) || (a0[2] && a1[2])) { flag = 1; goto END; }
            bool f1 = 1, f2 = 1;
            if (a0[0]) f2 = 0; if (a0[2]) f1 = 0;
            if (a1[0]) f1 = 0; if (a1[2]) f2 = 0;
            if (lp + 1 < rp && qt[k].mid[1][0]) f1 = 0;
            if (lp + 1 < rp && qt[k].mid[1][1]) f2 = 0;
            flag |= !(f1 || f2);
        }
        END:
        if (flag) cout << qt[k].id << ' ';
    }
    return 0;
}