#include <bits/stdc++.h>
#define rep(i, l, r) for (int i = l; i <= r; ++i)
using namespace std;
typedef long long ll;
const int N = 205, Q = 2005;
int n, q;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
class point {
   public:
    int x, y;
    void read() {
        scanf("%d%d", &x, &y);
        x = x * 2 + 1, y = y * 2 + 1;
    }
} a[N];

class frac {
   public:
    ll x, y;
    void sp() {
        ll d = gcd(x, y);
        x /= d, y /= d;
        if (y < 0) {
            y = -y, x = -x;
        }
        assert(y > 0);
    }
    frac(ll _x, ll _y) {
        x = _x;
        y = _y;
        sp();
    }
    frac operator+(const frac &rhs) const {
        return frac(x * rhs.y + y * rhs.x, y * rhs.y);
    }
    frac operator-(const frac &rhs) const {
        return frac(x * rhs.y - y * rhs.x, y * rhs.y);
    }
    frac operator*(const frac &rhs) const { return frac(x * rhs.x, y * rhs.y); }
    frac operator/(const frac &rhs) const { return frac(x * rhs.y, y * rhs.x); }
    bool operator<(const frac &rhs) const { return (*this - rhs).x < 0; }
    bool operator==(const frac &rhs) const { return (*this - rhs).x == 0; }
    void print() { printf("%lld/%lld", x, y); }
};

class seg {
   public:
    frac l, r;
    seg(frac _l, frac _r) : l(_l), r(_r) {}
    bool operator<(const seg &rhs) const {
        return l == rhs.l ? r < rhs.r : l < rhs.l;
    }
    void print() {
        l.print();
        printf("~");
        r.print();
        printf(", ");
    }
};
vector<seg> segs[Q];
void put(point p1, point p2) {
    if (p1.x > p2.x) swap(p1, p2);
    rep(x, p1.x, p2.x - 1) {
        frac l = frac(p1.y, 1) + frac((x - p1.x) * (p2.y - p1.y), p2.x - p1.x);
        frac r =
            frac(p1.y, 1) + frac((x + 1 - p1.x) * (p2.y - p1.y), p2.x - p1.x);
        segs[x].push_back(seg(l, r));
    }
}

frac get(frac l, frac r) {
    if (l < frac(0, 1) && r < frac(0, 1)) return frac(0, 1);
    if (!(l < frac(0, 1)) && !(r < frac(0, 1))) return (l + r) / frac(2, 1);
    if (r < l) swap(l, r);
    return r * r / (r - l) / frac(2, 1);
}

frac calc(int x, int y) {  // higher than y
    if (segs[x].size() == 0) return frac(0, 1);
    assert(segs[x].size() == 2);
    return get(segs[x][1].l - frac(y, 1), segs[x][1].r - frac(y, 1)) -
           get(segs[x][0].l - frac(y, 1), segs[x][0].r - frac(y, 1));
}

frac solve(point b) {
    return (calc(b.x - 1, b.y - 1) - calc(b.x - 1, b.y + 1) +
            calc(b.x, b.y - 1) - calc(b.x, b.y + 1)) /
           frac(4, 1);
}
int main() {
    scanf("%d%d", &n, &q);
    rep(i, 0, n - 1) { a[i].read(); }
    a[n] = a[0];
    rep(i, 0, n - 1) { put(a[i], a[i + 1]); }
    rep(i, 0, 2001) {
        if (segs[i].size()) {
            sort(segs[i].begin(), segs[i].end());
            // printf("%d:\n", i);
            // for (auto s : segs[i]) {
            //     s.print();
            // }
        }
    }
    rep(i, 0, q - 1) {
        point b;
        b.read();
        solve(b).print();
        printf("\n");
    }
    return 0;
}