#include <bits/stdc++.h>
using namespace std;

struct Node {
	int x;
	Node *l = 0;
	Node *r = 0;
	Node *p = 0;
	bool rev = false;

	Node() = default;

	Node(int v) {
		x = v;
	}

	void push() {
		if(rev) {
			rev = false;
			swap(l, r);
			if(l) l->rev ^= true;
			if(r) r->rev ^= true;
		}
	}

	bool is_root() {
		return p == 0 || (p->l != this && this != p->r);
	}
};

struct LCT {
	vector<Node> a;

	LCT(int n) {
		a.resize(n+1);
		for(int i = 1; i <= n; ++i)
		a[i].x = i;
	}

	void rot(Node* c) {
		auto p = c->p;
		auto g = p->p;

		if(!p->is_root())
			(g->r == p ? g->r : g->l) = c;

		p->push();
		c->push();

		if(p->l == c) { // rtr
			p->l = c->r;
			c->r = p;
			if(p->l) p->l->p = p;
		} else { // rtl
			p->r = c->l;
			c->l = p;
			if(p->r) p->r->p = p;
		}

		p->p = c;
		c->p = g;
	}

	void splay(Node* c) {
		while(!c->is_root()) {
			auto p = c->p;
			auto g = p->p;
			if(!p->is_root())
				rot((g->r == p) == (p->r == c) ? p : c);
			rot(c);
		}
		c->push();
	}

	Node* access(int v) {
		Node* last = 0;
		Node* c = &a[v];
		for(Node* p = c; p; p = p->p) {
			splay(p);
			p->r = last;
			last = p;
		}
		splay(c);
		return last;
	}

	void make_root(int v) {
		access(v);
		auto* c = &a[v];
		if(c->l)
			c->l->rev ^= true, c->l = 0;
	}

	void link(int u, int v) {
		make_root(v);
		Node* c = &a[v];
		c->p = &a[u];
	}

	void cut(int u, int v) {
		make_root(u);
		access(v);
		if(a[v].l) {
			a[v].l->p = 0;
			a[v].l = 0;
		}
	}

	bool connected(int u, int v) {
		access(u);
		access(v);
		return a[u].p;
	}
};

pair<int,int> edges[100005];
long long pref[100005];
int ile[100005];
int main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);

	int a,b;
	cin>>a>>b;

	LCT lct(a+2);

	for(int x=1;x<=b;x++)
    {
        int c,d;
        cin>>c>>d;
        edges[x] = {c,d};
	}
	int pocz = 1;
	for(int x=1;x<=b;x++)
    {
        while(lct.connected(edges[x].first, edges[x].second) && pocz != x + 1)
        {
            //cout<<x<<" : "<<pocz<<'\n';
            ile[pocz] = x - pocz;
            lct.cut(edges[pocz].first, edges[pocz].second);
            pocz++;
        }
        if(pocz != x+1)
            lct.link(edges[x].first, edges[x].second);
    }
   // cout<<pocz<<'\n';
    for(int x=pocz;x<=b;x++)
        ile[x] = b - x + 1;
    for(int x=1;x<=b;x++)
        pref[x] = pref[x-1] + ile[x];
    int t;
    cin>>t;
    while(t--)
    {
        int c,d;
        cin>>c>>d;
        int pocz = c, kon = d, sr;
        if(ile[c] + c - 1 > d)
        {
            cout<<(long long)(d-c+1)*(d-c+2)/2<<'\n';
            continue;
        }
        while(kon - pocz > 1)
        {
            sr = (pocz + kon) / 2;
            if(ile[sr] + sr - 1 > d)
                kon = sr;
            else
                pocz = sr;
        }
        if(ile[kon] + kon - 1 <= d)
            pocz = kon;
        cout<<pref[pocz] - pref[c-1] + (long long)(d-(pocz+1)+1)*(d-(pocz+1)+2)/2<<'\n';
    }
	return 0;
}