#include <bits/stdc++.h>

#define fi first
#define se second
#define p_b push_back
#define pll pair<ll,ll>
#define pii pair<int,int>
#define m_p make_pair
#define all(x) x.begin(),x.end()
#define sset ordered_set
#define sqr(x) (x)*(x)
#define pw(x) (1ll << x)
#define sz(x) (int)x.size()
#define fout(x) {cout << x << "\n"; return; }

using namespace std;
typedef long long ll;
typedef long double ld;
const int MAXN = 1123456;
const int M = pw(16);
const ll inf = 1e18;
const long long mod = 1e9 + 7;
const long long N = 3e5;

template <typename T> void vout(T s){cout << s << endl;exit(0);}

// NOTE CODE WAS ON PC
int n, x, y;
struct node{
    node *l, *r, *p, *pp;
    int sz, key;
    bool ob;
    node(){
        l = NULL;
        r = NULL;
        p = NULL;
        pp = NULL;
        sz = 0;
        key = 0;
        ob = 0;
    }
    node(int _x){
        l = NULL;
        r = NULL;
        p = NULL;
        pp = NULL;
        sz = 1;
        ob = 0;
        key = _x;
    }
};

typedef node * tnode;
tnode root, t[N];


void keep(tnode v){
    if (!v)return;
    if (v->l)v->l->p = v;
    if (v->r)v->r->p = v;
}

inline int get_sz(tnode v){
    if (v)return v->sz;else return 0;
}

inline void upd(tnode v){
    if (v){
        if (v->ob){
            v->ob = 0;
            if (v->l)v->l->ob ^= 1;
            if (v->r)v->r->ob ^= 1;
            swap(v->l, v->r);
        }
        v->sz = 1 + get_sz(v->l) + get_sz(v->r);
    }
}

inline void rot(tnode v, tnode p){
    tnode pr = p->p;
    if (pr){
        if (pr->l == p)pr->l = v;else pr->r = v;
    }
    if (p->l == v){
        p->l = v->r;
        v->r = p;
    }else {
        p->r = v->l;
        v->l = p;
    }
    v->p = pr;
    keep(p);
    keep(v);

    upd(p);
    upd(v);
    upd(p);
}

tnode splay(tnode v){
    upd(v);
    tnode p = v->p;
    if (!p)return v;
    tnode pr = p->p;
    if (!pr){
        rot(v, p);
        return v;
    }
    if ((pr->l == p) == (p->l == v)){
        rot(p, pr);
        rot(v, p);
    }else {
        rot(v, p);
        rot(v, pr);
    }
    return splay(v);
}
void clea(tnode v){
    if (!v)return;
    clea(v->p);
    upd(v);
}

tnode up(tnode v){
    clea(v);
    return splay(v);
}

tnode fin(tnode v, int key){
    if (!v)return NULL;
    upd(v);
    if (key  == get_sz(v->l) + 1)return up(v);
    if (key <= get_sz(v->l))return fin(v->l, key);
                    else return fin(v->r, key - 1 - get_sz(v->l));
}

tnode left(tnode v){
    return fin(up(v), 1);
}

inline tnode merg(tnode l, tnode r){
    if (!l)return r;
    if (!r)return l;
    r = left(r);
    r->pp = NULL;
    r->l = l;
    l->p = r;
    upd(r);
    return r;
}


void cut_right(tnode v){
    v = up(v);
    if (!v->r)return;
    tnode r = v->r;
    r->p = NULL;
    v->r = NULL;

    tnode e = left(r);
    e->pp = v;
    upd(e);
    upd(v);
}

void expose(tnode v){
    cut_right(v);
    v = left(v);
    while (v->pp){
        //cout <<v->key<<"AA"<<endl;
        cut_right(v->pp);
        v = merg(v->pp, v);
        //print();cout <<endl<<endl;
        v = left(v);
    }
    //cout <<v->key<<"AA"<<endl;
}

tnode get_root(tnode v){
    expose(v);
    while(v->p){
        v = v->p;
    }
    return up(v);
}

void make_root(tnode v){
    expose(v);
    up(v);
    v->ob ^= 1;
}

void link(tnode x, tnode y){
    make_root(x);
    x->pp = y;
}

void cut(tnode a, tnode b){
    make_root(a);
    expose(a);
    b->pp = NULL;
}

bool conn(tnode a, tnode b){
    make_root(a);
    expose(b);
    return get_root(a) == get_root(b);
}

int lca(tnode a, tnode b){
    //print();cout <<endl<<endl;
    expose(b);
    //print();cout <<endl<<endl;
    if (left(a) == left(b))return a->key;
    expose(a);
    if (left(a) == left(b))return b->key;
    return left(b)->pp->key;
}

int depth(tnode a, tnode b){
    tnode c = t[lca(a, b)];
    int x, y, z;
    x = get_root(a)->sz;
    y = get_root(b)->sz;
    z = get_root(c)->sz;
    return x + y - 2 * z;
}

inline void add(int x){
    tnode v = new node(x);
    t[x] = v;
}

/*inline int get(int l, int r){
    tnode v1, v2, v3;
    split(root, r, v2, v3);
    split(v2, l - 1, v1, v2);
    int s = v2->m;
    root = merg(v1, v2);
    root = merg(root, v3);
    return s;
}*/

char q;

vector <pll> qr[N];

ll fenw[2][N + 5];

void up(int xe, int x, ll val){
    for(int i = x; i <= N; i += i & -i){
        fenw[xe][i] += val;
    }
}

ll f(int xe, int x){
    ll res = 0;
    for(int i = x; i > 0; i -= i & -i){
        res += fenw[xe][i];
    }
    return res;
}

ll get(int xe, int l, int r){
    return f(xe, r) - f(xe, l - 1);
}

ll f_p(ll x){
    return (x * (x + 1)) / 2;
}

ll get_p(ll l, ll r){
    return f_p(r) - f_p(l - 1);
}

int main(){

    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int n, m;

    cin >> n >> m;

    vector <pii> e(m);

    for(int i = 0; i < m; i++){
        cin >> e[i].fi >> e[i].se;
    }

    vector <int> ri(m + 10);


    for(int i = 1; i <= n; i++){
        add(i);
    }

    int r = 1;
    
    link(t[e[0].fi], t[e[0].se]);
    ri[1] = 1;

    for(int i = 2; i <= m; i++){
        while(conn(t[e[i - 1].fi], t[e[i - 1].se])){
            cut(t[e[r - 1].fi], t[e[r - 1].se]);
            r++;
        }
        link(t[e[i - 1].fi], t[e[i - 1].se]);
        ri[i] = r;
    }

    int q;
    cin >> q;

    vector <ll> ans(q);

    for(int i = 0; i < q; i++){
        int l, r;
        cin >> l >> r;
        qr[r].p_b({l, i});
    }

    for(int i = 1; i <= m; i++){
        up(0, ri[i], 1);
        up(1, ri[i], ri[i]);
        for(auto j : qr[i]){
            ll answer = get_p(j.fi, i) + (i - j.fi + 1);
            answer -= get(1, j.fi, i);
            answer -= j.fi * (i - j.fi + 1 - get(0, j.fi, i));
            ans[j.se] = answer;
        }
    }

    for(auto i : ans){
        cout << i << "\n";
    }
    /*
    while(q--){
        int l, r;
        cin >> l >> r;
        int ans = 0;
        for(int i = l; i <= r; i++){
            ans += i - max(ri[i], l) + 1;
        }
        cout << ans << "\n";
    }
    */
    return 0;
}