#include <bits/stdc++.h>
using namespace std;
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
template <class T>
using V = vector<T>;
namespace tuple_utils {
template <size_t...>
struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is>
struct gen_seq<0, Is...> : seq<Is...> {};
template <class Tuple, size_t... Is>
void read(istream &stream, Tuple &t, seq<Is...>) {
  static_cast<void>((int[]){0, (void(stream >> get<Is>(t)), 0)...});
}
template <class Tuple, size_t... Is>
void print(ostream &stream, Tuple const &t, seq<Is...>) {
  static_cast<void>(
      (int[]){0, (void(stream << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...});
}
template <size_t I, class F, class A, class... Elems>
struct ForEach {
  void operator()(A &arg, tuple<Elems...> const &t) const {
    F()(arg, get<I>(t));
    ForEach<I - 1, F, A, Elems...>()(arg, t);
  };
  void operator()(A &arg, tuple<Elems...> &t) const {
    F()(arg, get<I>(t));
    ForEach<I - 1, F, A, Elems...>()(arg, t);
  };
};
template <class F, class A, class... Elems>
struct ForEach<0, F, A, Elems...> {
  void operator()(A &arg, tuple<Elems...> const &t) const {
    F()(arg, get<0>(t));
  };
  void operator()(A &arg, tuple<Elems...> &t) const { F()(arg, get<0>(t)); };
};
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> const &t) {
  ForEach<tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg, t);
};
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> &t) {
  ForEach<tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg, t);
};
struct hash_for_element {
  template <class V>
  void operator()(size_t &size, const V &v) const {
    size ^= hash<V>()(v);
  }
};
}  // namespace tuple_utils
template <class F, class S>
istream &operator>>(istream &stream, pair<F, S> &pair) {
  stream >> pair.first;
  stream >> pair.second;
  return stream;
}
template <class... Args>
istream &operator>>(istream &stream, tuple<Args...> &tuple) {
  tuple_utils::read(stream, tuple, tuple_utils::gen_seq<sizeof...(Args)>());
  return stream;
}
template <class T>
T read() {
  T t;
  cin >> t;
  return t;
}
template <class F, class S>
pair<F, S> read() {
  pair<F, S> p;
  cin >> p;
  return p;
}
template <class T1, class T2, class T3, class... Args>
tuple<T1, T2, T3, Args...> read() {
  tuple<T1, T2, T3, Args...> t;
  cin >> t;
  return t;
}
template <class T>
V<T> read(const int length) {
  V<T> ts(length);
  for (auto &t : ts) {
    cin >> t;
  }
  return ts;
}
template <class F, class S>
V<pair<F, S>> read(const int length) {
  V<pair<F, S>> ps(length);
  for (auto &p : ps) {
    cin >> p;
  }
  return ps;
}
template <class T1, class T2, class T3, class... Args>
V<tuple<T1, T2, T3, Args...>> read(const int length) {
  V<tuple<T1, T2, T3, Args...>> ts(length);
  for (auto &t : ts) {
    cin >> t;
  }
  return ts;
}
namespace debug {
template <class F, class S>
ostream &operator<<(ostream &stream, const pair<F, S> &pair) {
  stream << "{" << pair.first << ", " << pair.second << "}";
  return stream;
}
template <class... Args>
ostream &operator<<(ostream &stream, const tuple<Args...> &tuple) {
  stream << "{";
  tuple_utils::print(stream, tuple, tuple_utils::gen_seq<sizeof...(Args)>());
  stream << "}";
  return stream;
}
template <class Iterator>
struct Container {
  Container(const Iterator &begin, const Iterator &end)
      : begin(begin), end(end) {}
  const Iterator &begin;
  const Iterator &end;
};
template <class Iterator>
Container<Iterator> container(const Iterator &begin, const Iterator &end) {
  return Container<Iterator>(begin, end);
}
template <class Iterator>
ostream &operator<<(ostream &stream, const Container<Iterator> &container) {
  stream << "[";
  size_t cnt = 0;
  for (auto it = container.begin; it != container.end; ++it) {
    stream << *it;
    stream << "," << ((cnt % 10 == 9) ? "\n " : "\t");
    cnt += 1;
  }
  stream << "\b\b]";
  return stream;
}
template <class T, class Alloc>
ostream &operator<<(ostream &stream, const vector<T, Alloc> &vector) {
  return stream << container(vector.begin(), vector.end());
}
}  // namespace debug
namespace std {
template <class F, class S>
struct hash<pair<F, S>> {
  size_t operator()(const pair<F, S> &p) const {
    return hash<F>()(p.first) ^ hash<S>()(p.second);
  }
};
template <class... Args>
struct hash<tuple<Args...>> {
  size_t operator()(const tuple<Args...> &t) const {
    size_t retval = 0;
    tuple_utils::for_each<tuple_utils::hash_for_element, size_t, Args...>(
        retval, t);
    return retval;
  }
};
}  // namespace std
int body(int &argc, char **argv);
int main(int argc, char **argv) {
  cin.tie(0);
  ios_base::sync_with_stdio(false);
  return body(argc, argv);
}
int body(int &argc, char **argv) {
  auto X = read<i64>();
  auto K = read<i32>();
  auto rs = read<i64>(K);
  auto Q = read<i32>();
  auto qs = read<i64, i64>(Q);
  for (auto &q : (qs)) {
    auto t = q.first;
    auto a = q.second;
    auto b = X - a;
    auto i = 0;
    while (i < K && rs[i] < t) {
      auto diff = (i == 0) ? rs[i] : rs[i] - rs[i - 1];
      if (i % 2 == 0) {
        diff = min(diff, a);
        a -= diff;
        b += diff;
      } else {
        diff = min(diff, b);
        a += diff;
        b -= diff;
      }
      i += 1;
    }
    auto r = (i == 0) ? 0 : rs[i - 1];
    if (i % 2 == 0) {
      a -= min(a, t - r);
    } else {
      a += min(t - r, b);
    }
    cout << a << endl;
  }
  return 0;
}
