#include<bits/stdc++.h>

#define LL long long

#define fi first

#define se second

#define mk make_pair

#define PLL pair<LL, LL>

#define PLI pair<LL, int>

#define PII pair<int, int>

#define SZ(x) ((int)x.size())

#define ull unsigned long long

using namespace std;

const int N = 3e5 + ;

const int inf = 0x3f3f3f3f;

const LL INF = 0x3f3f3f3f3f3f3f3f;

const int mod = 1e9 + ;

const double eps = 1e-;

const double PI = acos(-);

int n, m, q, to[N], f[N][], mx[N][], mn[N][], depth[N];

bool vis[N];

LL ans[N];

vector<int> G[N];

vector<PII> qus[N];

#define lson l, mid, rt << 1

#define rson mid + 1, r, rt << 1 | 1

LL a[N << ], lazy[N << ];

inline void pull(int rt) {

    a[rt] = a[rt << ] + a[rt <<  | ];

}

inline void push(int rt, int l, int mid, int r) {

    if(lazy[rt]) {

        a[rt << ] += lazy[rt] * (mid - l + );

        a[rt <<  | ] += lazy[rt] * (r - mid);

        lazy[rt << ] += lazy[rt];

        lazy[rt <<  | ] += lazy[rt];

        lazy[rt] = ;

    }

}

void update(int L, int R, LL val, int l, int r, int rt) {

    if(l >= L && r <= R) {

        a[rt] += val * (r - l + );

        lazy[rt] += val;

        return;

    }

    int mid = l + r >> ;

    push(rt, l, mid, r);

    if(L <= mid) update(L, R, val, lson);

    if(R > mid)  update(L, R, val, rson);

    pull(rt);

}

LL query(int L, int R, int l, int r, int rt) {

    if(l >= L && r <= R) return a[rt];

    int mid = l + r >> ;

    push(rt, l, mid, r);

    if(R <= mid) return query(L, R, lson);

    else if(L > mid) return query(L, R, rson);

    else return query(L, R, lson) + query(L, R, rson);

}

void dfs(int u, int fa) {

    vis[u] = true;

    depth[u] = depth[fa] + ;

    f[u][] = fa;

    mx[u][] = u, mn[u][] = u;

    for(int i = ; i < ; i++) {

        f[u][i] = f[f[u][i - ]][i - ];

        mx[u][i] = max(mx[u][i - ], mx[f[u][i - ]][i - ]);

        mn[u][i] = min(mn[u][i - ], mn[f[u][i - ]][i - ]);

    }

    for(auto& v : G[u]) {

        if(v == fa || vis[v]) continue;

        dfs(v, u);

    }

}

void getVal(int u, int v) {

    int MX = v, MN = v;

    for(int i = ; i >= ; i--) {

        if(depth[u] - depth[v] >= ( << i)) {

            MX = max(MX, mx[u][i]);

            MN = min(MN, mn[u][i]);

            u = f[u][i];

        }

    }

    to[MN] = MX - ;

}

void getTo(int u, int fa) {

    vis[u] = true;

    for(auto& v : G[u]) {

        if(v == fa) continue;

        else if(!vis[v]) getTo(v, u);

        else if(vis[v]) {

            if(depth[u] > depth[v]) getVal(u, v);

        }

    }

}

int main() {

    scanf("%d%d", &n, &m);

    for(int i = ; i <= n; i++) to[i] = n;

    for(int i = ; i <= m; i++) {

        int u, v; scanf("%d%d", &u, &v);

        G[u].push_back(v);

        G[v].push_back(u);

    }

    for(int i = ; i <= n; i++)

        if(!vis[i]) dfs(i, );

    memset(vis, , sizeof(vis));

    for(int i = ; i <= n; i++)

        if(!vis[i]) getTo(i, );

    for(int i = n - ; i >= ; i--)

        to[i] = min(to[i], to[i + ]);

    scanf("%d", &q);

    for(int i = ; i <= q; i++) {

        int L, R; scanf("%d%d", &L, &R);

        qus[L].push_back(mk(R, i));

    }

    for(int i = n; i >= ; i--) {

        update(i, to[i], , , n, );

        for(auto& Q : qus[i]) ans[Q.se] = query(i, Q.fi, , n, );

    }

    for(int i = ; i <= q; i++) printf("%lld\n", ans[i]);

    return ;

}

/*

*/