#include <bits/stdc++.h>
using namespace std;
#include "grader.h"
int cnt = 0;
bool g = false;
map<pair<int, int>, long long> m;
template<class F>
vector<int> smawk(int h, int w, F f){
  auto dfs = [&](auto self, vector<int> &row, vector<int> &col) -> vector<int>{
    int n = row.size();
    if(n == 0) return {};
    vector<int> ncol;
    ncol.reserve(n);
    for(int i:col){
      long long mi = 3e9, ma = -3e9;
      for(int j = 0; j < min(200, row[ncol.size()-1]); j++){
        for(int k = 0; k < min(200, w-i-1); k++){
          auto p = f(row[ncol.size()-1]-j, i+k, 1);
          if(p < 0) continue;
          if(m.count({p/10000, p%10000})) ma = max(ma, m[{p/10000, p%10000}]);
        }
      }
      for(int j = 0; j < min(200, h-row[ncol.size()-1]-1); j++){
        for(int k = 0; k < min(200, ncol.back()); k++){
          auto p = f(row[ncol.size()-1]+j, ncol.back()-k, 1);
          if(p < 0) continue;
          if(m.count({p/10000, p%10000})) mi = min(mi, m[{p/10000, p%10000}]);
        }
      }
      while(!ncol.empty() && mi > ma && f(row[ncol.size()-1], ncol.back()) > f(row[ncol.size()-1], i)){
        ncol.pop_back();
      }
      if(ncol.size() < n) ncol.push_back(i);
    }
    vector<int> row_odd;
    row_odd.reserve(n/2+1);
    for(int i = 1; i < n; i+=2) row_odd.push_back(row[i]);
    vector<int> ans = self(self, row_odd, ncol);
    vector<int> res(n);
    for(int i = 0; i < row_odd.size(); i++) res[i*2+1] = ans[i];
    int j = 0;
    for(int i = 0; i < n; i+=2){
      int last = (i == n-1 ? ncol.back() : res[i+1]);
      res[i] = ncol[j];
      while(ncol[j] < last){
        ++j;
        if(f(row[i], res[i]) > f(row[i], ncol[j])) res[i] = ncol[j];
      }
    }
    return res;
  };
  vector<int> row(h), col(w);
  iota(row.begin(), row.end(), 0);
  iota(col.begin(), col.end(), 0);
  return dfs(dfs, row, col);
}
void Rescue(int R, int C, int RS, int CS, int X){
  int l1 = 0, r1 = RS;
  while(r1-l1 > 1){
    int mid = (l1+r1)/2;
    int x = mid, y = CS;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    if(h < X) l1 = mid;
    else r1 = mid;
  }
  /*
  int l3 = r1, r3 = RS;
  while(r3-l3 > 1){
    int mid = (l3+r3)/2;
    int x = mid, y = 1;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    if(h < X) l3 = mid;
    else r3 = mid;
  }
  int l4 = r1, r4 = RS;
  while(r4-l4 > 1){
    int mid = (l4+r4)/2;
    int x = mid, y = C;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    if(h < X) l4 = mid;
    else r4 = mid;
  }
  */
  int l2 = RS, r2 = R+1;
  while(r2-l2 > 1){
    int mid = (l2+r2)/2;
    int x = mid, y = CS;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    if(h < X) r2 = mid;
    else l2 = mid;
  }
  int l7 = 0, r7 = CS;
  while(r7-l7 > 1){
    int mid = (l7+r7)/2;
    int x = RS, y = mid;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    if(h < X) l7 = mid;
    else r7 = mid;
  }
  int l8 = CS, r8 = C+1;
  while(r8-l8 > 1){
    int mid = (l8+r8)/2;
    int x = RS, y = mid;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    if(h < X) r8 = mid;
    else l8 = mid;
  }
  auto f1 = [&](int x, int y, bool t = false){
    x = r1+x;
    y = CS-y;
    if(t) return x*10000+y;
    if(g) return 0;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    return abs(h-X);
  };
  auto s1 = smawk(RS-r1+1, CS-r7+1, f1);
  for(int i = 0; i < s1.size(); i++){
    cerr << s1[i] << " ";
    f1(i, s1[i]);
  }
  cerr << endl;
  auto f2 = [&](int x, int y, bool t = false){
    x = r1+x;
    y = CS+y;
    if(t) return x*10000+y;
    if(g) return 0;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    return abs(h-X);
  };
  auto s2 = smawk(RS-r1+1, l8-CS+1, f2);
  for(int i = 0; i < s2.size(); i++){
    cerr << s2[i] << " ";
    f2(i, s2[i]);
  }
  cerr << endl;
  auto f3 = [&](int x, int y, bool t = false){
    x = l2-x;
    y = CS-y;
    if(t) return x*10000+y;
    if(g) return 0;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    return abs(h-X);
  };
  auto s3 = smawk(l2-RS+1, CS-r7+1, f3);
  for(int i = 0; i < s3.size(); i++){
    cerr << s3[i] << " ";
    f3(i, s3[i]);
  }
  cerr << endl;
  auto f4 = [&](int x, int y, bool t = false){
    x = l2-x;
    y = CS+y;
    if(t) return x*10000+y;
    if(g) return 0;
    int h = m.count({x, y}) ? m[{x, y}] : Measure(x, y);
    if(!m.count({x, y})){
      if(h == X){
        Pinpoint(x, y);
        g = true;
      }
      m[{x, y}] = h;
    }
    return abs(h-X);
  };
  auto s4 = smawk(l2-RS+1, l8-CS+1, f4);
  for(int i = 0; i < s4.size(); i++){
    cerr << s4[i] << " ";
    f4(i, s4[i]);
  }
  cerr << endl;
}