#include <bits/stdc++.h>
  using namespace std;

  const long long maxn = 2e5 + 5;
  long long fa[maxn], rk[maxn];

  void init() {
      for(long long i = 1; i <= maxn; i ++) {
          fa[i] = i, rk[i] = 1;
      }
  }

  long long find(long long x) {
      return fa[x] == x ? x : fa[x] = find(fa[x]);
  }

  void merge(long long x, long long y) {
      long long fx = find(x), fy = find(y);
      if(fx == fy) return;
      if(rk[fx] < rk[fy]) std::swap(fx, fy);
      fa[fx] = fy;
      if(rk[fx] == rk[fy]) rk[fx] ++;
  }

  // e.g. Luogu P1551
  using ll = long long;
  int main() {
      ios::sync_with_stdio(false);
      cin.tie(0); cout.tie(0);
      ll n, m, p; cin >> n >> m >> p;
      init();
      while(m --) {
          ll x, y; cin >> x >> y;
          merge(x, y);
      }
      while(p --) {
          ll x, y; cin >> x >> y;
          if(find(x) == find(y)) cout << "Yes\n";
          else cout << "No\n";
      }
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  class DSU {
  private:
  	std::vector<long long> fa, rk;
  public:
  	explicit DSU(size_t size_) : fa(size_), rk(size_, 1) {
  		iota(fa.begin(), fa.end(), 0);
  	}

  	long long find(long long x) {
  		return fa[x] == x ? x : fa[x] = find(fa[x]);
  	}

  	void unite(long long x, long long y) {
  		long long fx = find(x), fy = find(y);
  		if(fx == fy) return;
  		if(rk[fx] < rk[fy]) std::swap(fx, fy);
  		fa[fx] = fy;
  		if(rk[fx] == rk[fy]) rk[fx] ++;
  	}
  };

  // e.g. Luogu P1551
  using ll = long long;
  int main() {
  	ios::sync_with_stdio(false);
  	cin.tie(0); cout.tie(0);
      ll n, m, p; cin >> n >> m >> p;
      DSU dsu(n + 1);
      while(m --) {
          ll x, y; cin >> x >> y;
          dsu.unite(x, y);
      }
      while(p --) {
          ll x, y; cin >> x >> y;
          if(dsu.find(x) == dsu.find(y)) cout << "Yes\n";
          else cout << "No\n";
      }
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      vector<vector<int>> v(n, vector<int>(n, 0));
      for(int i = 0; i < n; i ++) {
          for(int j = 0; j <= i; j ++) {
              cin >> v[i][j];
              if(i != 0) {
                  if (j == 0) v[i][j] += v[i - 1][j];
  		// 在三角形左边缘，无分叉，直接加上
                  else v[i][j] += max(v[i - 1][j - 1], v[i - 1][j]);
  		// 在三角形非左边缘，存在分叉或无分叉，取最大值加上。
  		// 右边缘无分叉也这样是因为这里取了最大值，
  		// 而三角形内元素总是在[0,100]区间内，可以不采取处理
              }
          }
      }
      int mx = 0;
      for(int &x : v[n - 1]) mx = max(mx, x);
      // 找出最大路径和
      cout << mx << endl;
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      vector<int> v(n, 0);
      vector<int> w(n, 0);
      // 数组v保留历史路径，数组w更新最大路径
      for(int i = 0; i < n; i ++) {
          for(int j = 0; j <= i; j ++) {
              cin >> w[j];
              if(j == 0) w[j] += v[j];
              else w[j] += max(v[j], v[j - 1]);
  	    // 此处与二维数组思路相似，但替换为数组v与数组w之间
          }
          v = w;
  	// 更新历史路径
      }
      int mx = 0;
      for(int &x : v) mx = max(mx, x);
      // 找出历史路径最大和
      cout << mx << endl;
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      vector<vector<int>> v(n, vector<int>(n, 0));
      for(int i = 0; i < n; i ++) {
          for(int j = 0; j <= i; j ++) {
              cin >> v[i][j];
          }
      }
      // 先读出数字三角形元素
      for(int i = n - 2; i >= 0; i --) {
          for(int j = 0; j <= i; j ++) {
              v[i][j] += max(v[i + 1][j], v[i + 1][j + 1]);
  	    // 除了最后一行，每行选取左边分叉与右边分叉中
  	    // 最小的那个分叉并加入元素
          }
      }
      cout << v[0][0] << endl;
      // 此时最大路径集中在顶部，直接输出即可
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      vector<int> v(n);
      // 保留历史
      int mx = 0;
      for(int i = 0; i < n; i ++) {
          cin >> v[i];
          if(i == 0) {mx = v[0]; continue;}
  	// 考虑全是负数的情况
          v[i] = max(v[i], v[i] + v[i - 1]);
  	// 连续子数组
          mx = max(v[i], mx);
  	// 更新最大值
      }
      cout << mx << endl;
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      int mx = 0, sum = 0;
      // 仅保留累加历史以及最大值
      for(int i = 0; i < n; i ++) {
          int tmp; cin >> tmp;
          if(i == 0) {mx = sum = tmp; continue;}
  	// 同时更新，原因同上
          sum = max(tmp, tmp + sum);
          mx = max(sum, mx);
      }
      cout << mx << endl;
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n, m; cin >> n >> m;
      vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
      // dp[i][j]表示当来到第i轮时，第j个人已经拿到球dp[i][j]次
      dp[0][1] = 1;
      // 初始化，开始时由第1号拿着球
      for(int i = 1; i <= m ; i ++) {
          for(int j = 1; j <= n; j ++) {
              dp[i][j] = dp[i - 1][j + 1 == n + 1 ? 1 : j + 1] +
                  dp[i - 1][j - 1 == 0 ? n : j - 1];
  	    // 状态转移：当前轮数这个人拿到球的传球方法
  	    // 等于右边传过来的方法加上左边传过来的方法，
  	    // 其中j + 1 == n + 1 ? 1 : j + 1表示向右传递，
  	    // j - 1 == 0 ? n : j - 1表示向左传递。
          }
      }
      cout << dp[m][1] << endl;
      // 最后一轮中第1号的传球方法数作为答案
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n, m; cin >> n >> m;
      vector<int> prevdp(n + 1, 0);
      vector<int> nowdp(n + 1, 0);
      // 解释同上，但使用两个一维数组替代二维数组
      // prevdp保留历史方法，nowdp计算当前方法
      prevdp[1] = 1;
      for(int i = 1; i <= m ; i ++) {
          for(int j = 1; j <= n; j ++) {
              nowdp[j] = prevdp[j == n ? 1 : j + 1] +
                  prevdp[j - 1 == 0 ? n : j - 1];
          }
          prevdp = nowdp;
      }
      cout << prevdp[1] << endl;
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int t, m; cin >> t >> m;
      vector<int> dp(t + 1, 0);
      // 索引：采药时间；值：采药最大值
      for(int i = 0; i < m; i ++) {
          int w, v; cin >> w >> v;
          for(int j = t; j >= w; j --) {
              dp[j] = max(dp[j], dp[j - w] + v);
  	    // 如果能采到更大价值则换为采集更大价值的
  	    // 不能则保留原先选择
          }
      }
      cout << dp[t] << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n, m; cin >> n >> m;
      vector<int> dp(n + 1);
      for(int i = 0; i < m; i ++) {
          int v, p; cin >> v >> p;
          for(int j = n; j >= v; j --) {
              dp[j] = max(dp[j], dp[j - v] + (v * p));
          }
      }
      cout << dp[n] << '\n';
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;
  using ll = long long;
  #define MAXSIZE ((ll)(1e7+10))

  ll dp[MAXSIZE] = {0};
  // 定义一个长度刚好覆盖要求的数组
  // 并用long long类型替换所有场景，
  // 因为当前要求已经超过int的承受范围

  int main() {
      ll t, m; cin >> t >> m;
      for(ll i = 0; i < m; i ++) {
          ll a, b; cin >> a >> b;
          for(ll j = a; j <= t; j ++) {
              dp[j] = max(dp[j], dp[j - a] + b);
  	    // 此处正序遍历，能采摘一个品种的药多次
          }
      }
      cout << dp[t] << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      vector<int> v(n);
      for(int &i : v) cin >> i;
      vector<int> dpl(n), dpr(n);
      for(int i = 0; i < n; i ++) {
          dpl[i] = 1;
  	// 自身也算是一个上升/下降子序列
          for(int j = 0; j < i; j ++) {
              if(v[i] > v[j]) dpl[i] = max(dpl[i], dpl[j] + 1);
  	    // 如果自身大于另一个数，判断先前比较的上升子序列长度
  	    // 与加入当前数后的整个上升子序列长度，更新更大者
          }
      }
      // 求最长上升子序列
      for(int i = n - 1; i >= 0; i --) {
          dpr[i] = 1;
          for(int j = n - 1; j > i; j --) {
              if(v[i] > v[j]) dpr[i] = max(dpr[i], dpr[j] + 1);
          }
      }
      // 求最长下降子序列
      int mn = n;
      for(int i = 0; i < n; i ++) {
          mn = min(mn, n - (dpl[i] + dpr[i] - 1));
      }
      // 找出最少可出列人数
      cout << mn << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      vector<int> v(n);
      for(int &i : v) cin >> i;
      vector<vector<int>> dp(n, vector<int>(n, INT_MAX));
      // 初始化dp数组，元素均为最大值，方便后续处理
      vector<int> sum(n, v[0]);
      dp[0][0] = 0;
      for(int i = 1; i < n; i ++) 
          sum[i] = sum[i - 1] + v[i], dp[i][i] = 0;
      // 初始化前缀和，对角线处dp设为0
      // 因为自身的代价为0
      for(int l = 2; l <= n; l ++) {
          for(int i = 0; i <= n - l; i ++) {
              int j = i + l - 1;
  	    // 先按长度遍历，后按序号遍历
              for(int k = i; k < j; k ++) {
                  dp[i][j] = min(dp[i][j],
                                 dp[i][k] + dp[k + 1][j] + (sum[j] - sum[i - 1]));
  		// 切分两部分进行比较，保存更小的
              }
          }
      }
      cout << dp[0][n - 1] << "\n";
      // 输出0到n-1的最小代价
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      char root = '*';
      unordered_map<char, pair<char, char>> mp;
      // 建立新二叉树
      for(int i = 0; i < n; i ++) {
          string tmp; cin >> tmp;
          if(root == '*') root = tmp[0];
  	// 设置根节点
          for(char &c : tmp) {
              if(c != '*' && !mp.contains(c))
                  mp[c] = make_pair('*', '*');
  	    // 遍历每一个合法节点并初始化
          }
          mp[tmp[0]].first = tmp[1], mp[tmp[0]].second = tmp[2];
  	// 连接父子节点
      }
      auto dfs = [&](auto &&self, char &c) -> string {
          if(c == '*') return "";
  	// 空节点跳出
          string s = "";
          s.push_back(c);
          return s + self(self, mp[c].first) + self(self, mp[c].second);
  	// 合并返回子节点、左分支结果、右分支结果
      };
      cout << dfs(dfs, root) << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  char l[128] = {0}, r[128] = {0};

  int main() {
      int n; cin >> n;
      char root = '*';
      for(int i = 0; i < n; i ++) {
          string tmp; cin >> tmp;
          if(root == '*') root = tmp[0];
          l[tmp[0]] = tmp[1], r[tmp[0]] = tmp[2];
      }
      auto dfs = [&](auto &&self, char &c) -> string {
          if(c == '*') return "";
          string s = "";
          s.push_back(c);
          return s + self(self, l[c]) + self(self, r[c]);
      };
      cout << dfs(dfs, root) << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      string mstr, fstr; cin >> mstr >> fstr;
      auto dfs = [&](auto &&self, string a, string b) -> string {
          if(a == "" || b == "") return "";
          int n = a.length();
          if (n == 1) return a;
          int mid = a.find(b[0]);
          string s = ""; s.push_back(a[mid]);
          return self(self, a.substr(0, mid), b.substr(1, mid))
              + self(self, a.substr(mid + 1, n - (mid + 1)),
                     b.substr(mid + 1, n - (mid + 1))) + s;
      };
      int n = mstr.length();
      cout << dfs(dfs, mstr, fstr) << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;
  
  int main() {
      string mstr, bstr; cin >> mstr >> bstr;
      auto dfs = [&](auto &&self, string a, string b) -> string {
          if(a == "" || b == "") return "";
          int n = a.length();
          if (n == 1) return a;
          int pre = a.find(b[n - 1]);
          string s = ""; s.push_back(a[pre]);
          return s + self(self, a.substr(0, pre), b.substr(0, pre))
              + self(self, a.substr(pre + 1, n - (pre + 1)),
                     b.substr(pre, n - (pre + 1)));
      };
      int n = mstr.length();
      cout << dfs(dfs, mstr, bstr) << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n; cin >> n;
      vector<bool> v(n, false);
      // 当前路径是否已访问过该元素
      vector<int> w;
      // DFS路径
      auto dfs = [&](auto&& self) {
          if(w.size() == n) {
              for(int &i : w) {
                  cout << "    " << i;
              }
              cout << "\n";
              return;
          }
  	// 遍历完所有元素，输出路径
          for(int i = 0; i < n; i ++) {
              if(v[i]) continue;
  	    // 已访问，跳过
              w.push_back(i + 1); v[i] = true;
  	    // 未访问，尾加数组并标记已访问
              self(self);
  	    // 加深度，继续访问
              w.pop_back(); v[i] = false;
  	    // 还原数组并取消标记，用于下一循环
          }
      };
      dfs(dfs);
      // 进入DFS
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      vector<vector<int>> dirs{
          {-1, 0}, {1, 0}, {0, 1}, {0, -1}
      };
      // 路径方向
      int n, m, t; cin >> n >> m >> t;
      int sx, sy, fx, fy; cin >> sx >> sy >> fx >> fy;
      vector<vector<bool>> visit(m + 1, vector<bool>(n + 1, false));
      // 经过路径
      for(int i = 0; i < t; i ++) {
          int x, y; cin >> x >> y;
          visit[y][x] = true;
      }
      // 为障碍物标注已经过，防止穿过
      int cnt = 0;
      auto dfs = [&](auto&& self, int x, int y) {
          if(x == fx && y == fy) {
              ++ cnt;
              return;
          }
  	// 到达终点，路径加1
          for(vector<int> &dir : dirs) {
              int cx = dir[1] + x, cy = dir[0] + y;
  	    // 计算移动后坐标
              if(1 <= cx && cx <= n && 1 <= cy && cy <= m) {
                  if(visit[cy][cx]) continue;
  		// 判断是否在范围内且是否经过
                  visit[cy][cx] = true;
                  self(self, cx, cy);
                  visit[cy][cx] = false;
  		// 标记并访问
              }
          }
      };
      visit[sy][sx] = true;
      // 防止重复经过起点
      dfs(dfs, sx, sy);
      cout << cnt << "\n";
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  vector<vector<int>> graph;
  // 邻接表存储图的边相关信息

  int main() {
      int n, m; cin >> n >> m;
      vector<vector<int>> v(m, vector<int>(2));
      for(vector<int> &w : v) cin >> w[0] >> w[1];
      sort(v.begin(), v.end());
      graph.resize(n + 1, vector<int>{});
      for(vector<int> &w : v) {
          graph[w[0]].push_back(w[1]);
      }
      // 读取边并排序插入邻接表
      vector<bool> visit(n + 1, false);
      auto dfs = [&](auto&& self, int t) -> void {
          cout << t << " ";
          for(int &elem : graph[t]) {
              if(visit[elem]) continue;
              visit[elem] = true;
              self(self, elem);
  	    // 访问后不标记回false：防止重复经过某节点
          }
          return;
      };
      visit[1] = true; dfs(dfs, 1);
      cout << "\n";
      // DFS前序
      for(int i = 1; i <= n; i ++) visit[i] = false;
      // 重置已访问
      queue<int> q;
      visit[1] = true; q.push(1);
      // 放入根节点，用于向下层序遍历
      while(q.size()) {
          int nw = q.front(); q.pop();
  	// 取出当前需遍历的父元素
          cout << nw << " ";
          for(int &elem : graph[nw]) {
              if(visit[elem]) continue;
              visit[elem] = true;
              q.push(elem);
  	    // 未访问的直接子元素放入队列，等待遍历
          }
      }
      cout << "\n";
      // BFS：利用队列进行层序遍历
      return 0;
  }

  // 题意误解性可能有点大，比较好理解的应该是如下：
  // 输入分别为 棋盘的高 棋盘的宽 马所在的纵坐标 马所在的横坐标

  #include <bits/stdc++.h>
  using namespace std;

  #define vci vector<int>
  vector<vci> mp;
  queue<vci> q;

  vector<vci> steps{
      {1, 2}, {1, -2},
      {-1, 2}, {-1, -2},
      {2, 1}, {2, -1},
      {-2, 1}, {-2, -1}
  };

  int main() {
      int h, w, y, x; cin >> h >> w >> y >> x;
  	// 读取输入
  	--y, --x;
  	// 换成x:0-m, y:0-n
  	mp.resize(h, vci(w, -1));
  	// 初始化大小与内容
  	mp[y][x] = 0;
  	q.push(vci{y, x});
  	// 设置马的起点
  	while (!q.empty()) {
  		vci p = q.front(); q.pop();
  		y = p[0], x = p[1];
  		// 取出队列元素
  		for(vci &v : steps) {
  			int cy = y + v[0], cx = x + v[1];
  			// 计算跳一步后的新位置
  			if(0 <= cy && cy < h && 0 <= cx && cx < w && mp[cy][cx] == -1) {
  				// 如果在矩阵内且未经过，则放入队列并标记
  				// 由于BFS的层序性质，在矩阵内的已标记元素总是最小
  				mp[cy][cx] = mp[y][x] + 1;
  				q.push(vci{cy, cx});
  			}
  		}
  	}
  	for(vci &v : mp) {
  		for(int &i : v) {
  			cout << i << " ";
  		}
  		cout << "\n";
  	}
  	// 输出矩阵并做换行处理
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  #define vci vector<int>
  vector<vci> dirs{
      {-1, 0}, {1, 0},
      {0, -1}, {0, 1}
  };
  // 定义方向

  int main() {
      int n, m; cin >> n >> m;
      vector<string> mp(n);
      for(string &s : mp) cin >> s;
      // 读入数据
      vector<vector<bool>> visit(n, vector<bool>(m, false));
      // 标记是否为细胞的一部分
      queue<vci> q;
      int cnt = 0;
      for(int y = 0; y < n; y ++) {
          for(int x = 0; x < m; x ++) {
              if(visit[y][x] || mp[y][x] == '0') continue;
  	    // 已标记或非细胞则跳过
              visit[y][x] = true;
              q.push(vci{y, x});
              while(q.size()) {
                  vci v = q.front(); q.pop();
                  for(vci &dir : dirs) {
                      int cy = v[0] + dir[0], cx = v[1] + dir[1];
                      if(0 <= cx && cx < m && 0 <= cy && cy < n && 
  		       !visit[cy][cx] && mp[cy][cx] != '0') {
  		      // 对于每个方向，如果未被标记且作为细胞一部分
  		      // 则做标记并插入队列
                          visit[cy][cx] = true;
                          q.push(vci{cy, cx});
                      }
                  }
              }
              cnt ++;
  	    // 遍历完细胞后直接加一即可，因为
  	    // 不会再次遍历到已被标记完的细胞
          }
      }
      cout << cnt << "\n";
      return 0;
  }

  // 此处可注意到，把连接边界的0标记为2比把闭合圈内的0标记为2更简便
  
  #include <bits/stdc++.h>
  using namespace std;

  #define vci vector<int>
  vector<vci> dirs{
      {-1, 0}, {1, 0},
      {0, -1}, {0, 1}
  };

  int main() {
      int n; cin >> n;
      vector<vci> mp(n, vci(n, 0));
      for(vci &s : mp) for(int &i : s) cin >> i;
      queue<vci> q;
      auto bfs = [&](int y, int x) {
          mp[y][x] = 2; q.push(vci{y, x});
          while(q.size()) {
              vci v = q.front(); q.pop();
              for(vci &dir : dirs) {
                  int cy = v[0] + dir[0], cx = v[1] + dir[1];
                  if(0 <= cy && cy < n && 0 <= cx && cx < n && !mp[cy][cx]) {
                      mp[cy][cx] = 2; q.push(vci{cy, cx});
                  }
              }
          }
  	// 为连接边界的0标记为2，方便后续操作
      };
      // 写好需要用的BFS Lambda
      for(int i = 0; i < n; i ++) {
          if(!mp[0][i]) bfs(0, i);
          if(!mp[n - 1][i]) bfs(n - 1, i);
      }
      for(int i = 0; i < n; i ++) {
          if(!mp[i][0]) bfs(i, 0);
          if(!mp[i][n - 1]) bfs(i, n - 1);
      }
      // 对在边界上的每一个0做一次BFS
      for(vci &v : mp) {
          for(int &i : v) {
              cout << 2 - i << " ";
  	    // 全部做2-i操作，1保持不变，
  	    // 原来在边界的“2”改为0，不在边界的“0”改为2
          }
          cout << "\n";
      }
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int main() {
      int n, a, b; cin >> n >> a >> b;
      vector<int> k(n + 1);
      vector<bool> visit(n + 1, false);
      for(int i = 1; i <= n; i ++) cin >> k[i];
      // 读入输入
      queue<pair<int, int>> q;
      q.push(make_pair(a, 0));
      // 放入起始层数并设置按下次数为0
      while(q.size()) {
          pair<int, int> p = q.front(); q.pop();
          int y1 = p.first, y2 = p.second;
          if(visit[y1]) continue;
          visit[y1] = true;
  	// 这里需要提防一手，判断一下是否曾经有经过这的同按下数，
  	// 举个例子：有多个楼层都是在同一次按下按钮后到达，
  	// 此时没有判断visit的同一层BFS会持续塞入同样的元素，
  	// 累积下会造成MLE，因此此处需要额外判断
          if(y1 == b) {
              cout << y2 << "\n";
              return 0;
          }
  	// 如果楼层到达则输出并跳出
          int x = y1 + k[y1];
          if(1 <= x && x <= n) {
              q.push(make_pair(x, y2 + 1));
          }
  	// 向上时未超出范围就放入队列
          x = y1 - k[y1];
          if(1 <= x && x <= n) {
              q.push(make_pair(x, y2 + 1));
          }
  	// 向下时未超出范围就放入队列
      }
      cout << "-1\n";
      // 所有可能沿经楼层都已经访问完，
      // 仍旧无法到达则输出-1
      return 0;
  }

  // 我发现这种涉及坐标的题目真的很迷，
  // x和y的含义是颠倒的，行和列也是难以区分的，
  // 不擅长读题的很容易绕进去就WA了

  #include <bits/stdc++.h>
  using namespace std;

  vector<int> dirs{0, 1, 0, -1, 0};

  int main() {
      int n, m, a, b;
      cin >> n >> m >> a >> b;
      vector<vector<int>> dp(n + 1, vector<int>(m + 1, INT_MAX));
      // n为行数，m为列数，由此建立dp数组
      queue<vector<int>> q;
      for(int i = 0; i < a; i ++) {
          int x, y; cin >> y >> x;
  	// 根据输入输出样例以及输入输出格式，
  	// 判断按纵坐标-横坐标格式读入，即y-x形式
  	// 后续逻辑正常处理
          q.push({y, x});
          dp[y][x] = 0;
          while(q.size()) {
              vector<int> w = q.front(); q.pop();
              y = w[0], x = w[1];
              for(int i = 0; i < 4; i ++) {
                  int cy = y + dirs[i], cx = x + dirs[i + 1];
                  if(1 <= cy && cy <= n && 1 <= cx && cx <= m
                    && dp[cy][cx] > dp[y][x] + 1) {
                      dp[cy][cx] = dp[y][x] + 1;
                      q.push({cy, cx});
                  }
              }
  	    // 四个方向都做判断处理，
  	    // 如果在范围内并比原先的值更小
  	    // 则替换上去并放入队列，因为
  	    // 后续路径可能存在更小的值
          }
      }
      for(int i = 0; i < b; i ++) {
          int x, y; cin >> y >> x;
          cout << dp[y][x] << "\n";
      }
      // 按坐标读dp数组输出，原理相似
      return 0;
  }

  #include <bits/stdc++.h>
  using namespace std;

  int dirs[5] = {0, 1, 0, -1, 0};

  int main() {
      int n, m; cin >> n >> m;
      vector<vector<int>> v(n, vector<int>(m, 0));
      vector<vector<int>> mx(n, vector<int>(m, 0));
      // v存储输入，mx存储历史经过的最大hp
      queue<vector<int>> q;
      for(int i = 0; i < n; i ++) {
          for(int j = 0; j < m; j ++) {
              cin >> v[i][j];
              if(v[i][j] == 2) {
                  q.push(vector<int>{i, j, 6, 0});
  		mx[j][i] = 6;
  		// 遍历到起点则初始化，并设置当前最大hp
              }
          }
      }
      while(q.size()) {
          vector<int> w = q.front(); q.pop();
          int y = w[0], x = w[1], hp = w[2], step = w[3];
          if(v[y][x] == 3) {
              cout << step << "\n";
              return 0;
          }
          // 到达家则输出步数（BFS上可认定为最短时间）
          if(v[y][x] == 4) hp = 6;
          // 到达鼠标处回满hp（在hp判断后补满，
          // 防止死去后通过鼠标“复活”）
          for(int i = 0; i < 4; i ++) {
              int cy = y + dirs[i], cx = x + dirs[i + 1], newhp = hp - 1;
              if(0 <= cy && cy < n && 0 <= cx && cx < m) {
                  if(v[cy][cx] == 0) continue;
                  // 新位置为障碍物，跳过
                  if(newhp <= mx[cy][cx]) continue;
  		mx[y][x] = hp;
                  // 新hp小于过往的最大hp，可能存在重复
                  // 或已经死去则跳过，否则更新最大hp
                  q.push(vector<int>{cy, cx, newhp, step + 1});
  		// 更新当前路径hp，方便后续路径对hp的判断
  		// （不是太懂里面的原理，反正是方便判断）
              }
          }
      }
      cout << "-1\n";
      return 0;
  }