12 12
5 1
5 11
1 11
8 11
8 9
5 12
6 9
7 11
9 3
9 10
4 12
10 2
78
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
1 10
1 11
1 12
2 2
2 3
2 4
2 5
2 6
2 7
2 8
2 9
2 10
2 11
2 12
3 3
3 4
3 5
3 6
3 7
3 8
3 9
3 10
3 11
3 12
4 4
4 5
4 6
4 7
4 8
4 9
4 10
4 11
4 12
5 5
5 6
5 7
5 8
5 9
5 10
5 11
5 12
6 6
6 7
6 8
6 9
6 10
6 11
6 12
7 7
7 8
7 9
7 10
7 11
7 12
8 8
8 9
8 10
8 11
8 12
9 9
9 10
9 11
9 12
10 10
10 11
10 12
11 11
11 12
12 12

1
3
6
10
15
21
28
36
45
55
65
76
1
3
6
10
15
21
28
36
45
55
66
1
3
6
10
15
21
28
36
45
55
1
3
6
10
15
21
28
36
45
1
3
6
10
15
21
28
36
1
3
6
10
15
21
28
1
3
6
10
15
21
1
3
6
10
15
1
3
6
10
1
3
6
1
3
1

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3 * (1e5) + 5;
int n, m, Q;
int u, v;
vector<int> graph[MAXN];
int cyclesCount = 0;
int node2Cycle[MAXN];
vector<int> cycle[MAXN];
int parent[MAXN];
set<pair<int, int> > used;
bool usedNodes[MAXN];
int maxLeft[MAXN];
long long dp[MAXN];
long long prefix[MAXN];
void DFS(int x) {
  usedNodes[x] = true;
  for (int i = 0; i < graph[x].size(); i++) {
    u = x;
    v = graph[x][i];
    if (used.count(make_pair(min(u, v), max(u, v))) == false) {
      used.insert(make_pair(min(u, v), max(u, v)));
      if (usedNodes[v] == false) {
        parent[v] = u;
        DFS(v);
      } else {
        while (u != v) {
          node2Cycle[u] = cyclesCount;
          cycle[cyclesCount].push_back(u);
          u = parent[u];
        }
        node2Cycle[v] = cyclesCount;
        cycle[cyclesCount].push_back(v);
        cyclesCount++;
      }
    }
  }
}
long long sum(long long x) {
  if (x % 2 != 0) {
    return sum(x - 1) + x;
  }
  return (x + 1) * (x / 2);
}
long long getSum(int l, int r) { return sum(r) - sum(l - 1); }
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  long long L, R;
  long long l, r, mid;
  long long answer = 0;
  cin >> n >> m;
  for (int i = 0; i < m; i++) {
    cin >> u >> v;
    graph[u].push_back(v);
    graph[v].push_back(u);
  }
  for (int i = 1; i <= n; i++) {
    DFS(i);
  }
  for (int i = 0; i < cyclesCount; i++) {
    sort(cycle[i].begin(), cycle[i].end());
  }
  dp[1] = 1;
  for (int i = 2; i <= n; i++) dp[i] = dp[i - 1] + i;
  L = 1;
  R = 1;
  maxLeft[1] = 1;
  for (R = 2; R <= n; R++) {
    if (cyclesCount != 0) {
      while (cycle[node2Cycle[R]][0] >= L &&
             cycle[node2Cycle[R]][cycle[node2Cycle[R]].size() - 1] <= R) {
        L++;
      }
    }
    maxLeft[R] = L;
  }
  prefix[1] = 1;
  for (int i = 2; i <= n; i++) prefix[i] = prefix[i - 1] + i - maxLeft[i] + 1;
  cin >> Q;
  for (int q = 0; q < Q; q++) {
    cin >> L >> R;
    answer = 0;
    l = L;
    r = R;
    while (l + 1 < r) {
      mid = (l + r) / 2;
      if (maxLeft[mid] <= L)
        l = mid;
      else
        r = mid - 1;
    }
    if (maxLeft[r] <= L) {
      answer = getSum(L, r) - L * (r - L + 1) + (r - L + 1);
      answer += prefix[R] - prefix[r];
    } else if (maxLeft[l] <= L) {
      answer = getSum(L, l) - L * (l - L + 1) + (l - L + 1);
      answer += prefix[R] - prefix[l];
    }
    cout << answer << '\n';
  }
}
