#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;


typedef struct Snode* sn;
struct Snode 
{ 
	sn p, c[2]; // parent, children
	bool rev = false; // subtree flipped or not
	int val, sz; // value in node, # nodes in splay subtree (as cnt in treap)
	int sub, vsub = 0; // vsub stores sum of virtual children
	
	Snode(int _val): val(_val)
	{
		p = c[0] = c[1] = 0;
		upd(); 
	}
	
	friend int getSz(sn x)
	{
		return x ? x->sz : 0; 
	}
	friend int getSub(sn x) 
	{ 
		return x ? x->sub : 0; 
	}
	
	void push() 
	{ 
		if (!rev) 
			return;
		swap(c[0], c[1]);
		rev = false;
		FOR (i, 0, 2)
			if (c[i]) 
				c[i]->rev ^= 1;
	}
	void upd()
	{ 
		FOR (i, 0, 2) 
			if (c[i])
				c[i]->push();
		sz = 1 + getSz(c[0]) + getSz(c[1]);
		sub = 1 + getSub(c[0]) + getSub(c[1]) + vsub;
	}
	//////// SPLAY TREE OPERATIONS
	int dir() 
	{
		if (!p) return -2;
		FOR (i, 0, 2) 
			if (p->c[i] == this) 
				return i;
		return -1; // p is path-parent pointer
	} // -> not in current splay tree
	// test if root of current splay tree
	bool isRoot() 
	{ 
		return dir() < 0; 
	} 
	friend void setLink(sn x, sn y, int d) 
	{
		if (y) 
			y->p = x;
		if (d >= 0) 
			x->c[d] = y;
	}
	// assume p and p->p are propagated
	void rot() 
	{ 
		assert(!isRoot()); 
		int x = dir(); 
		sn pa = p;
		setLink(pa->p, this, pa->dir());
		setLink(pa, c[x ^ 1], x); 
		setLink(this, pa, x ^ 1);
		pa->upd();
	}
	void splay()
	{
		while (!isRoot() && !p->isRoot()) 
		{
			p->p->push();
			p->push();
			push();
			dir() == p->dir() ? p->rot() : rot();
			rot();
		}
		if (!isRoot()) 
			p->push(), push(), rot();
		push();
		upd();
	}
	
	//////// BASE OPERATIONS
	// bring this to top of tree, propagate
	void access() 
	{ 
		for (sn v = this, pre = 0; v; v = v->p) 
		{
			v->splay(); // now switch virtual children
			if (pre) 
				v->vsub -= pre->sub;
			if (v->c[1])
				v->vsub += v->c[1]->sub;
			v->c[1] = pre;
			v->upd();
			pre = v;
		}
		splay(); 
		assert(!c[1]); // right subtree is empty
	}
	void makeRoot() 
	{ 
		access();
		rev ^= 1;
		access();
		assert(!c[0] && !c[1]); 
	}
	//////// QUERIES
	friend sn lca(sn x, sn y) 
	{
		if (x == y) 
			return x;
		x->access(); 
		y->access(); 
		if (!x->p) 
			return 0;
		x->splay();
		return x->p ? x->p : x; // y was below x in latter case
	} // access at y did not affect x -> not connected
	
	friend bool connected(sn x, sn y) 
	{ 
		return lca(x,y);
	} 
	// # nodes above
	int distRoot()
	{ 
		access(); 
		return getSz(c[0]); 
	} 
	sn getRoot() 
	{ // get root of LCT component
		access(); 
		sn a = this; 
		while (a->c[0]) 
		{
			a = a->c[0]; 
			a->push();
		}
		a->access(); 
		return a;
	}	
	//////// MODIFICATIONS
	void set(int v) 
	{ 
		access();
		val = v; 
		upd(); 
	} 
	friend void link(sn x, sn y) 
	{ 
		assert(!connected(x, y));
		y->makeRoot();
		x->access(); 
		setLink(y, x, 0);
		y->upd();
	}
	// cut y from its parent
	friend void cut(sn y) 
	{ 
		y->access(); 
		assert(y->c[0]);
		y->c[0]->p = 0; 
		y->c[0] = 0; 
		y->upd(); 
	}
	// if x, y adj in tree
	friend void cut(sn x, sn y) 
	{ 
		x->makeRoot(); 
		y->access(); 
		assert(y->c[0] == x && !x->c[0] && !x->c[1]); 
		cut(y); 
	}
};

const int N = 100'447;
sn LCT[N];
VI a;

LL f(int l, int r)
{
	LL sum = 0;
	FOR (i, l, r)
		sum += min(r, a[i]) - i;
	return sum;
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	
	int n, m;
	cin >> n >> m;
	FOR (i, 0, n) LCT[i] = new Snode(i);
	queue<PII> q;
	a = VI(m, m);
	int idx = 0;
	FOR (i, 0, m)
	{
		int u, v;
		cin >> u >> v;
		u--, v--;
		q.push({u, v});
		while (connected(LCT[u], LCT[v]))
		{
			auto [u1, v1] = q.front();
			q.pop();
			a[idx++] = i;
			cut(LCT[u1], LCT[v1]);
		}
		link(LCT[u], LCT[v]);
	}
	int qq;
	cin >> qq;
	FOR (i, 0, qq)
	{
		int l, r;
		cin >> l >> r;
		l--;
		cout << f(l, r) << '\n';
	}
	
	
	return 0;
}