#include <bits/stdc++.h>
using namespace std;
template <class T>
struct LazySegmentTree {
  struct Node {
    Node *lch, *rch;
    T value;
    T *lazyAdd, *lazySet;
    int size;
    void setMark(T val) {
      if (lazyAdd != 0) delete lazyAdd;
      lazyAdd = 0;
      if (lazySet != 0) delete lazySet;
      lazySet = new T(val);
    }
    void addMark(T val) {
      if (lazyAdd != 0)
        *lazyAdd = lazyAdd->add(val);
      else
        lazyAdd = new T(val);
    }
    void propagate() {
      if (lazySet) {
        T toSet = *lazySet;
        value = toSet.multiply(size);
        if (lch != 0 && rch != 0) {
          lch->setMark(toSet);
          rch->setMark(toSet);
        }
        delete lazySet;
        lazySet = 0;
      }
      if (lazyAdd) {
        T toAdd = *lazyAdd;
        value = value.add(toAdd.multiply(size));
        if (lch != 0 && rch != 0) {
          lch->addMark(toAdd);
          rch->addMark(toAdd);
        }
        delete lazyAdd;
        lazyAdd = 0;
      }
    }
    T getValue() {
      propagate();
      return value;
    }
    void update() { value = lch->getValue().combine(rch->getValue()); }
  };
  vector<Node> nodes;
  int n;
  LazySegmentTree(int nsize, vector<T> init = vector<T>()) {
    n = 1;
    while (n < nsize) n *= 2;
    nodes.resize(2 * n - 1, {0, 0, T(), 0, 0, 1});
    for (int i = 0; i < n; i++) {
      if (i < (int)init.size()) nodes[n - 1 + i].value = init[i];
    }
    for (int i = n - 2; i >= 0; i--) {
      nodes[i].value = nodes[2 * i + 1].value.combine(nodes[2 * i + 2].value);
      nodes[i].lch = &nodes[2 * i + 1];
      nodes[i].rch = &nodes[2 * i + 2];
      nodes[i].size = nodes[i].lch->size + nodes[i].rch->size;
    }
  }
  void add(int l, int r, T toAdd, Node* cur = 0, int lb = 0, int rb = -1) {
    if (cur == 0) {
      cur = &nodes[0];
      rb = n;
    }
    cur->propagate();
    if (l <= lb && rb <= r) {
      cur->addMark(toAdd);
      return;
    }
    int mid = (lb + rb) / 2;
    if (l < mid) add(l, r, toAdd, cur->lch, lb, mid);
    if (mid < r) add(l, r, toAdd, cur->rch, mid, rb);
    cur->update();
  }
  void set(int l, int r, T toSet, Node* cur = 0, int lb = 0, int rb = -1) {
    if (cur == 0) {
      cur = &nodes[0];
      rb = n;
    }
    cur->propagate();
    if (l <= lb && rb <= r) {
      cur->setMark(toSet);
      return;
    }
    int mid = (lb + rb) / 2;
    if (l < mid) set(l, r, toSet, cur->lch, lb, mid);
    if (mid < r) set(l, r, toSet, cur->rch, mid, rb);
    cur->update();
  }
  T get(int l, int r, Node* cur = 0, int lb = 0, int rb = -1) {
    if (cur == 0) {
      cur = &nodes[0];
      rb = n;
    }
    cur->propagate();
    if (l <= lb && rb <= r) return cur->getValue();
    vector<T> ret;
    int mid = (lb + rb) / 2;
    if (l < mid) ret.push_back(get(l, r, cur->lch, lb, mid));
    if (mid < r) ret.push_back(get(l, r, cur->rch, mid, rb));
    if (ret.size() == 2) return ret[0].combine(ret[1]);
    return ret[0];
  }
};
using namespace std;
struct Value {
  int val;
  Value(int nval = 0) { val = nval; }
  Value add(Value r) { return {max(val, r.val)}; }
  Value combine(Value r) { return {min(val, r.val)}; }
  Value multiply(int cnt) { return *this; }
};
struct Stree : LazySegmentTree<Value> {
  Stree(int nsize, vector<Value> init = vector<Value>())
      : LazySegmentTree<Value>(nsize, init) {}
  int getInd(int l, int limit, Node* cur = 0, int lb = 0, int rb = -1) {
    if (cur == 0) {
      cur = &nodes[0];
      rb = n;
    }
    cur->propagate();
    if (cur->value.val >= limit) return rb;
    if (cur->size == 1) return lb;
    int mid = (lb + rb) / 2;
    if (mid <= l) return getInd(l, limit, cur->rch, mid, rb);
    int ret = getInd(l, limit, cur->lch, lb, mid);
    if (ret == mid) return getInd(l, limit, cur->rch, mid, rb);
    return ret;
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n, m;
  cin >> n >> m;
  vector<vector<int> > rope(n + 1);
  for (int i = 0; i < m; i++) {
    int l, r;
    cin >> l >> r;
    if (l < r) rope[r].push_back(l);
  }
  struct Query {
    int x, y;
    int result;
  };
  int q;
  cin >> q;
  vector<Query> queries(q);
  vector<vector<Query*> > queriesOnHeight(n + 1);
  for (int i = 0; i < q; i++) {
    cin >> queries[i].x >> queries[i].y;
    queriesOnHeight[queries[i].y].push_back(&queries[i]);
  }
  Stree st(n + 1);
  for (int h = 0; h <= n; h++) {
    for (auto c : rope[h]) st.add(c, h, c);
    for (auto cp : queriesOnHeight[h]) {
      if (cp->x < h)
        cp->result = st.getInd(cp->x, cp->x);
      else
        cp->result = h;
    }
  }
  for (auto c : queries) cout << c.result << '\n';
  return 0;
}
