Problem:
B Hokkaido_University2
問題文
ほむちゃんは春から北海道大学に入学しました。
今日は初めての授業。しかし大変、寝坊をしてしまいました。
ほむちゃんは初めての授業に間に合うことができるのでしょうか。
札幌は碁盤目状の町並みで知られています。
より正確には、札幌はxy平面で表されます。
ほむちゃんは各時刻 $t=0,1,2,\ldots$ で次のいずれかの行動をします。
ほむちゃんは時刻 $t$ に $(x,y)$ にいるとします。
$x$ が偶数または $t$ が偶数のとき時刻 $t+1$ に $(x+1,y)$ に移動する。
$x$ が奇数または $t$ が偶数のとき時刻 $t+1$ に $(x-1,y)$ に移動する。
$y$ が偶数または $t$ が奇数のとき時刻 $t+1$ に $(x,y+1)$ に移動する。
$y$ が奇数または $t$ が奇数のとき時刻 $t+1$ に $(x,y-1)$ に移動する。
時刻 $t+1$ まで $(x,y)$ にとどまる。
ほむちゃんは時刻 $0$ に $(s_x,s_y)$ にいます。
北海道大学の校門は $(g_x,g_y)$ にあります。
全ての行動の選び方にたいする、ほむちゃんが $(g_x,g_y)$ にたどり着く時刻の最小値を求めてください。
入力
入力は以下の形式で標準入力から与えられる。
$s_x$ $s_y$ $g_x$ $g_y$
制約
$0 \leq s_x,s_y,g_x,g_y \leq 10^{18}$
入力は全て整数である。
出力
答えを 1 行に出力せよ。
入力例1
3 5 4 9
出力例1
5
以下のように動くのが最適です。
時刻 $0$ に $(3,5)$ から $(4,5)$ に移動する。
時刻 $1$ に $(4,5)$ から $(4,6)$ に移動する。
時刻 $2$ に $(4,6)$ から $(4,7)$ に移動する。
時刻 $3$ に $(4,7)$ から $(4,8)$ に移動する。
時刻 $4$ に $(4,8)$ から $(4,9)$ に移動する。
時刻 $5$ に $(4,9)$ に到着する。
他の動き方では時刻 $5$ に $(4,9)$ にいることはできません。
入力例2
0 0 1000 0
出力例2
1001

Submitted solutions:

code_snippet: #line 2 "/home/yuruhiya/programming/library/template/template.cpp"
#include <bits/stdc++.h>
#line 4 "/home/yuruhiya/programming/library/template/constants.cpp"
#include <string_view>
#line 7 "/home/yuruhiya/programming/library/template/constants.cpp"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rfor(i, m, n) for (int i = (m); i >= (n); --i)
#define unless(c) if (!(c))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define range_it(a, l, r) (a).begin() + (l), (a).begin() + (r)

using namespace std;
using ll = long long;
using LD = long double;
using VB = vector<bool>;
using VVB = vector<VB>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VS = vector<string>;
using VD = vector<LD>;
using PII = pair<int, int>;
using VP = vector<PII>;
using PLL = pair<ll, ll>;
using VPL = vector<PLL>;
template <class T> using PQ = priority_queue<T>;
template <class T> using PQS = priority_queue<T, vector<T>, greater<T>>;
constexpr int inf = 1000000000;
constexpr long long inf_ll = 1000000000000000000ll, MOD = 1000000007;
constexpr long double PI = 3.14159265358979323846, EPS = 1e-12;
#line 7 "/home/yuruhiya/programming/library/template/Input.cpp"
using namespace std;

#ifdef _WIN32
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#define fwrite_unlocked fwrite
#define fflush_unlocked fflush
#endif
class Scanner {
	static int gc() {
		return getchar_unlocked();
	}
	static char next_char() {
		char c;
		read(c);
		return c;
	}
	template <class T> static void read(T& v) {
		cin >> v;
	}
	static void read(char& v) {
		while (isspace(v = gc()))
			;
	}
	static void read(bool& v) {
		v = next_char() != '0';
	}
	static void read(string& v) {
		v.clear();
		for (char c = next_char(); !isspace(c); c = gc()) v += c;
	}
	static void read(int& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(long long& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(double& v) {
		v = 0;
		double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	static void read(long double& v) {
		v = 0;
		long double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	template <class T, class U> static void read(pair<T, U>& v) {
		read(v.first);
		read(v.second);
	}
	template <class T> static void read(vector<T>& v) {
		for (auto& e : v) read(e);
	}
	template <size_t N = 0, class T> static void read_tuple_impl(T& v) {
		if constexpr (N < tuple_size_v<T>) {
			read(get<N>(v));
			read_tuple_impl<N + 1>(v);
		}
	}
	template <class... T> static void read(tuple<T...>& v) {
		read_tuple_impl(v);
	}
	struct ReadVectorHelper {
		size_t n;
		ReadVectorHelper(size_t _n) : n(_n) {}
		template <class T> operator vector<T>() {
			vector<T> v(n);
			read(v);
			return v;
		}
	};
	struct Read2DVectorHelper {
		size_t n, m;
		Read2DVectorHelper(const pair<size_t, size_t>& nm) : n(nm.first), m(nm.second) {}
		template <class T> operator vector<vector<T>>() {
			vector<vector<T>> v(n, vector<T>(m));
			read(v);
			return v;
		}
	};

public:
	string read_line() const {
		string v;
		for (char c = gc(); c != '\n' && c != '\0'; c = gc()) v += c;
		return v;
	}
	template <class T> T read() const {
		T v;
		read(v);
		return v;
	}
	template <class T> vector<T> read_vector(size_t n) const {
		vector<T> a(n);
		read(a);
		return a;
	}
	template <class T> operator T() const {
		return read<T>();
	}
	int operator--(int) const {
		return read<int>() - 1;
	}
	ReadVectorHelper operator[](size_t n) const {
		return ReadVectorHelper(n);
	}
	Read2DVectorHelper operator[](const pair<size_t, size_t>& nm) const {
		return Read2DVectorHelper(nm);
	}
	void operator()() const {}
	template <class H, class... T> void operator()(H&& h, T&&... t) const {
		read(h);
		operator()(forward<T>(t)...);
	}

private:
	template <template <class...> class, class...> struct Multiple;
	template <template <class...> class V, class Head, class... Tail>
	struct Multiple<V, Head, Tail...> {
		template <class... Args> using vec = V<vector<Head>, Args...>;
		using type = typename Multiple<vec, Tail...>::type;
	};
	template <template <class...> class V> struct Multiple<V> { using type = V<>; };
	template <class... T> using multiple_t = typename Multiple<tuple, T...>::type;
	template <size_t N = 0, class T> void multiple_impl(T& t) const {
		if constexpr (N < tuple_size_v<T>) {
			auto& vec = get<N>(t);
			using V = typename remove_reference_t<decltype(vec)>::value_type;
			vec.push_back(read<V>());
			multiple_impl<N + 1>(t);
		}
	}

public:
	template <class... T> auto multiple(size_t h) const {
		multiple_t<T...> result;
		while (h--) multiple_impl(result);
		return result;
	}
} in;
#define inputs(T, ...) \
	T __VA_ARGS__;     \
	in(__VA_ARGS__)
#define ini(...) inputs(int, __VA_ARGS__)
#define inl(...) inputs(long long, __VA_ARGS__)
#define ins(...) inputs(string, __VA_ARGS__)
#line 7 "/home/yuruhiya/programming/library/template/Output.cpp"
#include <charconv>
#line 10 "/home/yuruhiya/programming/library/template/Output.cpp"
using namespace std;

struct BoolStr {
	const char *t, *f;
	BoolStr(const char* _t, const char* _f) : t(_t), f(_f) {}
} Yes("Yes", "No"), yes("yes", "no"), YES("YES", "NO"), Int("1", "0");
struct DivStr {
	const char *d, *l;
	DivStr(const char* _d, const char* _l) : d(_d), l(_l) {}
} spc(" ", "\n"), no_spc("", "\n"), end_line("\n", "\n"), comma(",", "\n"),
    no_endl(" ", "");
class Printer {
	BoolStr B{Yes};
	DivStr D{spc};

public:
	void print(int v) const {
		char buf[12]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void print(long long v) const {
		char buf[21]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void print(bool v) const {
		print(v ? B.t : B.f);
	}
	void print(vector<bool>::reference v) const {
		print(v ? B.t : B.f);
	}
	void print(char v) const {
		putchar_unlocked(v);
	}
	void print(const char* v) const {
		fwrite_unlocked(v, 1, strlen(v), stdout);
	}
	void print(double v) const {
		printf("%.20f", v);
	}
	void print(long double v) const {
		printf("%.20Lf", v);
	}
	template <class T> void print(const T& v) const {
		cout << v;
	}
	template <class T, class U> void print(const pair<T, U>& v) const {
		print(v.first);
		print(D.d);
		print(v.second);
	}
	template <class InputIterater>
	void print_range(const InputIterater& begin, const InputIterater& end) const {
		for (InputIterater i = begin; i != end; ++i) {
			if (i != begin) print(D.d);
			print(*i);
		}
	}
	template <class T> void print(const vector<T>& v) const {
		print_range(v.begin(), v.end());
	}
	template <class T, size_t N> void print(const array<T, N>& v) const {
		print_range(v.begin(), v.end());
	}
	template <class T> void print(const vector<vector<T>>& v) const {
		for (size_t i = 0; i < v.size(); ++i) {
			if (i) print(D.l);
			print(v[i]);
		}
	}

	Printer() = default;
	Printer(const BoolStr& _boolstr, const DivStr& _divstr) : B(_boolstr), D(_divstr) {}
	Printer& operator()() {
		print(D.l);
		return *this;
	}
	template <class H> Printer& operator()(H&& h) {
		print(h);
		print(D.l);
		return *this;
	}
	template <class H, class... T> Printer& operator()(H&& h, T&&... t) {
		print(h);
		print(D.d);
		return operator()(forward<T>(t)...);
	}
	template <class InputIterator>
	Printer& range(const InputIterator& begin, const InputIterator& end) {
		print_range(begin, end);
		print(D.l);
		return *this;
	}
	template <class T> Printer& range(const T& a) {
		range(a.begin(), a.end());
		return *this;
	}
	template <class... T> void exit(T&&... t) {
		operator()(forward<T>(t)...);
		std::exit(EXIT_SUCCESS);
	}
	Printer& flush() {
		fflush_unlocked(stdout);
		return *this;
	}
	Printer& set(const BoolStr& b) {
		B = b;
		return *this;
	}
	Printer& set(const DivStr& d) {
		D = d;
		return *this;
	}
	Printer& set(const char* t, const char* f) {
		B = BoolStr(t, f);
		return *this;
	}
} out;
#line 3 "/home/yuruhiya/programming/library/template/Step.cpp"
using namespace std;

template <class T> struct Step {
	using value_type = T;

	class iterator {
		value_type a, b, c;

	public:
		constexpr iterator() : a(value_type()), b(value_type()), c(value_type()) {}
		constexpr iterator(value_type _b, value_type _c, value_type _s)
		    : a(_b), b(_c), c(_s) {}
		constexpr iterator& operator++() {
			--b;
			a += c;
			return *this;
		}
		constexpr iterator operator++(int) {
			iterator tmp = *this;
			--b;
			a += c;
			return tmp;
		}
		constexpr const value_type& operator*() const {
			return a;
		}
		constexpr const value_type* operator->() const {
			return &a;
		}
		constexpr bool operator==(const iterator& i) const {
			return b == i.b;
		}
		constexpr bool operator!=(const iterator& i) const {
			return !(b == i.b);
		}
		constexpr value_type start() const {
			return a;
		}
		constexpr value_type size() const {
			return b;
		}
		constexpr value_type step() const {
			return c;
		}
	};
	constexpr Step(value_type b, value_type c, value_type s) : be(b, c, s) {}
	constexpr iterator begin() const {
		return be;
	}
	constexpr iterator end() const {
		return en;
	}
	constexpr value_type start() const {
		return be.start();
	}
	constexpr value_type size() const {
		return be.size();
	}
	constexpr value_type step() const {
		return be.step();
	}
	constexpr value_type sum() const {
		return start() * size() + step() * (size() * (size() - 1) / 2);
	}
	operator vector<value_type>() const {
		return to_a();
	}
	auto to_a() const {
		vector<value_type> result;
		result.reserve(size());
		for (auto i : *this) {
			result.push_back(i);
		}
		return result;
	}

private:
	iterator be, en;
};
template <class T> constexpr auto step(T a) {
	return Step<T>(0, a, 1);
}
template <class T> constexpr auto step(T a, T b) {
	return Step<T>(a, b - a, 1);
}
template <class T> constexpr auto step(T a, T b, T c) {
	return Step<T>(a, a < b ? (b - a - 1) / c + 1 : 0, c);
}
#line 8 "/home/yuruhiya/programming/library/template/Ruby.cpp"
using namespace std;

template <class F> struct Callable {
	F func;
	Callable(const F& f) : func(f) {}
};
template <class T, class F> auto operator|(const T& v, const Callable<F>& c) {
	return c.func(v);
}

struct Sort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const Sort_impl& c) {
		sort(begin(v), end(v));
		return v;
	}
} Sort;
struct SortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) < f(j); });
			return v;
		});
	}
} SortBy;
struct RSort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(rbegin(v), rend(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const RSort_impl& c) {
		sort(rbegin(v), rend(v));
		return v;
	}
} RSort;
struct RSortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) > f(j); });
			return v;
		});
	}
} RSortBy;
struct Reverse_impl {
	template <class T> friend auto operator|(T v, const Reverse_impl& c) {
		reverse(begin(v), end(v));
		return v;
	}
} Reverse;
struct Unique_impl {
	template <class T> friend auto operator|(T v, const Unique_impl& c) {
		v.erase(unique(begin(v), end(v), end(v)));
		return v;
	}
} Unique;
struct Uniq_impl {
	template <class T> friend auto operator|(T v, const Uniq_impl& c) {
		sort(begin(v), end(v));
		v.erase(unique(begin(v), end(v)), end(v));
		return v;
	}
} Uniq;
struct Rotate_impl {
	auto operator()(int&& left) {
		return Callable([&](auto v) {
			int s = static_cast<int>(size(v));
			assert(-s <= left && left <= s);
			if (0 <= left) {
				rotate(begin(v), begin(v) + left, end(v));
			} else {
				rotate(begin(v), end(v) + left, end(v));
			}
			return v;
		});
	}
} Rotate;
struct Max_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *max_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Max_impl& c) {
		return *max_element(begin(v), end(v));
	}
} Max;
struct Min_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *min_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Min_impl& c) {
		return *min_element(begin(v), end(v));
	}
} Min;
struct MaxPos_impl {
	template <class T> friend auto operator|(T v, const MaxPos_impl& c) {
		return max_element(begin(v), end(v)) - begin(v);
	}
} MaxPos;
struct MinPos_impl {
	template <class T> friend auto operator|(T v, const MinPos_impl& c) {
		return min_element(begin(v), end(v)) - begin(v);
	}
} MinPos;
struct MaxBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_it = begin(v);
			auto max_val = f(*max_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_it = it;
					max_val = val;
				}
			}
			return *max_it;
		});
	}
} MaxBy;
struct MinBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_it = begin(v);
			auto min_val = f(*min_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_it = it;
					min_val = val;
				}
			}
			return *min_it;
		});
	}
} MinBy;
struct MaxOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_val = val;
				}
			}
			return max_val;
		});
	}
} MaxOf;
struct MinOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_val = val;
				}
			}
			return min_val;
		});
	}
} MinOf;
struct Count_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return count(begin(v), end(v), val); });
	}
} Count;
struct CountIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return count_if(begin(v), end(v), f); });
	}
} CountIf;
struct Index_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(begin(v), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
	template <class V> auto operator()(const V& val, size_t i) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(next(begin(v), i), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} Index;
struct IndexIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} IndexIf;
struct FindIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<typename decltype(v)::value_type> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(*result) : nullopt;
		});
	}
} FindIf;
struct Sum_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			return accumulate(next(begin(v)), end(v), f(*begin(v)),
			                  [&](const auto& a, const auto& b) { return a + f(b); });
		});
	}
	template <class T> friend auto operator|(T v, const Sum_impl& c) {
		return accumulate(begin(v), end(v), typename T::value_type{});
	}
} Sum;
struct Includes {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return find(begin(v), end(v), val) != end(v); });
	}
} Includes;
struct IncludesIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return find_if(begin(v), end(v), f) != end(v); });
	}
} IncludesIf;
struct RemoveIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) {
			v.erase(remove_if(begin(v), end(v), f), end(v));
			return v;
		});
	}
} RemoveIf;
struct Each_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				f(i);
			}
		});
	}
} Each;
struct EachConsPair_impl {
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, EachConsPair_impl& c) {
		vector<pair<value_type, value_type>> result;
		if (size(v) >= 2) {
			result.reserve(size(v) - 1);
			for (size_t i = 0; i < size(v) - 1; ++i) {
				result.emplace_back(v[i], v[i + 1]);
			}
		}
		return result;
	}
} EachConsPair;
struct Select_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using value_type = typename decltype(v)::value_type;
			vector<value_type> result;
			for (const auto& i : v) {
				if (f(i)) result.push_back(i);
			}
			return result;
		});
	}
} Select;
struct Map_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using result_type = invoke_result_t<F, typename decltype(v)::value_type>;
			vector<result_type> result;
			result.reserve(size(v));
			for (const auto& i : v) {
				result.push_back(f(i));
			}
			return result;
		});
	}
} Map;
struct Indexed_impl {
	template <class T> friend auto operator|(const T& v, Indexed_impl& c) {
		using value_type = typename T::value_type;
		vector<pair<value_type, int>> result;
		result.reserve(size(v));
		int index = 0;
		for (const auto& i : v) {
			result.emplace_back(i, index++);
		}
		return result;
	}
} Indexed;
struct AllOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (!f(i)) return false;
			}
			return true;
		});
	}
} AllOf;
struct AnyOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return true;
			}
			return false;
		});
	}
} AnyOf;
struct NoneOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return false;
			}
			return true;
		});
	}
} NoneOf;

struct Tally_impl {
	template <class F> auto operator()(size_t max_val) {
		return Callable([&](auto v) {
			vector<size_t> result(max_val);
			for (const auto& i : v) {
				result[static_cast<size_t>(i)]++;
			}
			return result;
		});
	}
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, Tally_impl& c) {
		map<value_type, size_t> result;
		for (const auto& i : v) {
			result[i]++;
		}
		return result;
	}
} Tally;

template <class T> auto operator*(const vector<T>& a, size_t n) {
	T result;
	for (size_t i = 0; i < n; ++i) {
		result.insert(result.end(), a.begin(), a.end());
	}
	return result;
}
auto operator*(string a, size_t n) {
	string result;
	for (size_t i = 0; i < n; ++i) {
		result += a;
	}
	return result;
}
template <class T, class U> auto& operator<<(vector<T>& a, const U& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T> auto& operator<<(string& a, const T& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T, class U> auto operator+(vector<T> a, const U& b) {
	a << b;
	return a;
}
template <class T> auto operator+(string a, const T& b) {
	a << b;
	return a;
}
#line 7 "/home/yuruhiya/programming/library/template/functions.cpp"
using namespace std;

template <class T = long long> constexpr T TEN(size_t n) {
	T result = 1;
	for (size_t i = 0; i < n; ++i) result *= 10;
	return result;
}
template <class T, class U,
          enable_if_t<is_integral_v<T> && is_integral_v<U>, nullptr_t> = nullptr>
constexpr auto div_ceil(T n, U m) {
	return (n + m - 1) / m;
}
template <class T, class U> constexpr auto div_ceil2(T n, U m) {
	return div_ceil(n, m) * m;
}
template <class T> constexpr T triangle(T n) {
	return (n & 1) ? (n + 1) / 2 * n : n / 2 * (n + 1);
}
template <class T> constexpr T nC2(T n) {
	return (n & 1) ? (n - 1) / 2 * n : n / 2 * (n - 1);
}
template <class T, class U> constexpr auto middle(const T& l, const U& r) {
	return l + (r - l) / 2;
}
template <class T, class U, class V>
constexpr bool in_range(const T& v, const U& lower, const V& upper) {
	return lower <= v && v < upper;
}
template <class T, enable_if_t<is_integral_v<T>, nullptr_t> = nullptr>
constexpr bool is_square(T n) {
	T s = sqrt(n);
	return s * s == n || (s + 1) * (s + 1) == n;
}
template <class T = long long> constexpr T BIT(int b) {
	return T(1) << b;
}
template <class T> constexpr int BIT(T x, int i) {
	return (x & (T(1) << i)) ? 1 : 0;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Pow(T a, U n) {
	assert(n >= 0);
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result *= a;
			n--;
		} else {
			a *= a;
			n >>= 1;
		}
	}
	return result;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Powmod(T a, U n, T mod) {
	assert(n >= 0);
	if (a > mod) a %= mod;
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result = result * a % mod;
			n--;
		} else {
			a = a * a % mod;
			n >>= 1;
		}
	}
	return result;
}
template <class T> bool chmax(T& a, const T& b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> bool chmin(T& a, const T& b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> int sz(const T& v) {
	return v.size();
}
template <class T, class U> int lower_index(const T& a, const U& v) {
	return lower_bound(all(a), v) - a.begin();
}
template <class T, class U> int upper_index(const T& a, const U& v) {
	return upper_bound(all(a), v) - a.begin();
}
template <class T> auto Slice(const T& v, size_t i, size_t len) {
	return i < v.size() ? T(v.begin() + i, v.begin() + min(i + len, v.size())) : T();
}
template <class T, class U = typename T::value_type> U Gcdv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), gcd<U, U>);
}
template <class T, class U = typename T::value_type> U Lcmv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), lcm<U, U>);
}
namespace internal {
	template <class T, size_t N> auto make_vector(vector<int>& sizes, const T& init) {
		if constexpr (N == 1) {
			return vector(sizes[0], init);
		} else {
			int size = sizes[N - 1];
			sizes.pop_back();
			return vector(size, make_vector<T, N - 1>(sizes, init));
		}
	}
}  // namespace internal
template <class T, size_t N>
auto make_vector(const int (&sizes)[N], const T& init = T()) {
	vector s(rbegin(sizes), rend(sizes));
	return internal::make_vector<T, N>(s, init);
}
#line 9 "/home/yuruhiya/programming/library/template/template.cpp"
#if __has_include(<library/dump.hpp>)
#include <library/dump.hpp>
#define LOCAL
#else
#define dump(...) ((void)0)
#endif

template <class T> constexpr T oj_local(const T& oj, const T& local) {
#ifndef LOCAL
	return oj;
#else
	return local;
#endif
}
#line 5 "/home/yuruhiya/programming/library/Graph/GraphTemplate.cpp"
using namespace std;

using Weight = long long;
constexpr Weight INF = numeric_limits<Weight>::max();
struct Edge {
	int to;
	Weight cost;
	Edge() : to(-1), cost(-1) {}
	Edge(int _to, Weight _cost = 1) : to(_to), cost(_cost) {}
	friend bool operator<(const Edge& e1, const Edge& e2) {
		return e1.cost < e2.cost;
	}
	friend bool operator>(const Edge& e1, const Edge& e2) {
		return e1.cost > e2.cost;
	}
	friend ostream& operator<<(ostream& os, const Edge& e) {
		return os << "->" << e.to << '(' << e.cost << ')';
	}
};
using Graph = vector<vector<Edge>>;
struct Edge2 {
	int from, to;
	Weight cost;
	Edge2() : from(-1), to(-1), cost(0) {}
	Edge2(int _from, int _to, Weight _cost) : from(_from), to(_to), cost(_cost) {}
	friend bool operator<(const Edge2& e1, const Edge2& e2) {
		return e1.cost < e2.cost;
	}
	friend bool operator>(const Edge2& e1, const Edge2& e2) {
		return e1.cost > e2.cost;
	}
	friend ostream& operator<<(ostream& os, const Edge2& e) {
		return os << e.from << "->" << e.to << '(' << e.cost << ')';
	}
};
using Edges = vector<Edge2>;
using Matrix = vector<vector<Weight>>;
#line 5 "/home/yuruhiya/programming/library/Graph/Dijkstra.cpp"
using namespace std;

vector<Weight> Dijkstra(const Graph& graph, int s) {
	int V = graph.size();
	vector<Weight> dist(V, INF);
	dist[s] = 0;
	priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
	pq.emplace(s, 0);
	while (!pq.empty()) {
		Edge p = pq.top();
		pq.pop();
		int v = p.to;
		if (dist[v] < p.cost) continue;
		for (auto e : graph[v]) {
			if (dist[e.to] > dist[v] + e.cost) {
				dist[e.to] = dist[v] + e.cost;
				pq.emplace(e.to, dist[e.to]);
			}
		}
	}
	return dist;
}
Weight Dijkstra(const Graph& graph, int s, int t) {
	int V = graph.size();
	vector<Weight> dist(V, INF);
	dist[s] = 0;
	priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
	pq.emplace(s, 0);
	while (!pq.empty()) {
		Edge p = pq.top();
		pq.pop();
		int v = p.to;
		if (v == t) return dist[t];
		if (dist[v] < p.cost) continue;
		for (auto e : graph[v]) {
			if (dist[e.to] > dist[v] + e.cost) {
				dist[e.to] = dist[v] + e.cost;
				pq.emplace(e.to, dist[e.to]);
			}
		}
	}
	return dist[t];
}
#line 3 "a.cpp"

int main() {
	inl(sx, sy, gx, gy);

	const int range = 50;
	VL x_val, y_val;
	x_val << step(sx - range, sx + range).to_a();
	x_val << step(gx - range, gx + range).to_a();
	y_val << step(sy - range, sy + range).to_a();
	y_val << step(gy - range, gy + range).to_a();
	x_val = x_val | Uniq;
	y_val = y_val | Uniq;
	dump(x_val, y_val);

	const int MAX_V = sz(x_val) * sz(y_val) * 2;
	Graph g(MAX_V);
	auto to_i = [&](ll x, ll y, ll time) {
		return lower_index(x_val, x) * sz(y_val) * 2 + lower_index(y_val, y) * 2 + time;
	};
	auto add_edge = [&](ll x1, ll y1, ll t1, ll x2, ll y2, ll t2, ll cost) {
		g[to_i(x1, y1, t1)].emplace_back(to_i(x2, y2, t2), cost);
	};
	auto add_edge2 = [&](ll x1, ll y1, ll t1, ll x2, ll y2, ll t2, ll cost) {
		add_edge(x1, y1, t1, x2, y2, t2, cost);
		add_edge(x2, y2, t2, x1, y1, t1, cost);
	};

	for (ll x : x_val) {
		for (ll y : y_val) {
			for (ll f : {0, 1}) {
				add_edge2(x, y, f, x, y, 1 - f, 1);
			}
		}
	}
	for (auto [x1, x2] : x_val | EachConsPair) {
		for (ll y : y_val) {
			for (ll f : {0, 1}) {
				if (x1 + 1 == x2) {
					if (x1 % 2 == 0 || f == 0) {
						add_edge2(x1, y, f, x2, y, 1 - f, 1);
					}
				} else {
					if ((x1 % 2 == 1 && f == 0) || (x1 % 2 == 0 && f == 1)) {
						add_edge(x1, y, f, x2, y, (f + x2 - x1) % 2, x2 - x1);
					}
					if ((x2 % 2 == 0 && f == 0) || (x2 % 2 == 1 && f == 1)) {
						add_edge(x2, y, f, x1, y, (f + x2 - x1) % 2, x2 - x1);
					}
				}
			}
		}
	}
	for (ll x : x_val) {
		for (auto [y1, y2] : y_val | EachConsPair) {
			for (ll f : {0, 1}) {
				if (y1 + 1 == y2) {
					if (y1 % 2 == 0 || f == 1) {
						add_edge2(x, y1, f, x, y2, 1 - f, 1);
					}
				} else {
					if ((y1 % 2 == 1 && f == 1) || (y1 % 2 == 0 && f == 0)) {
						add_edge(x, y1, f, x, y2, (f + y2 - y1) % 2, y2 - y1);
					}
					if ((y2 % 2 == 0 && f == 1) || (y2 % 2 == 1 && f == 0)) {
						add_edge(x, y2, f, x, y1, (f + y2 - y1) % 2, y2 - y1);
					}
				}
			}
		}
	}

	ll ans1 = Dijkstra(g, to_i(sx, sy, 0), to_i(gx, gy, 0));
	ll ans2 = Dijkstra(g, to_i(sx, sy, 0), to_i(gx, gy, 1));
	out(min(ans1, ans2));
}
accuracy: 0.0425531914893617
time_ms: 40
memory_kb: 17076
final_rank: 20

code_snippet: #line 2 "/home/yuruhiya/programming/library/template/template.cpp"
#include <bits/stdc++.h>
#line 4 "/home/yuruhiya/programming/library/template/constants.cpp"
#include <string_view>
#line 7 "/home/yuruhiya/programming/library/template/constants.cpp"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rfor(i, m, n) for (int i = (m); i >= (n); --i)
#define unless(c) if (!(c))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define range_it(a, l, r) (a).begin() + (l), (a).begin() + (r)

using namespace std;
using ll = long long;
using LD = long double;
using VB = vector<bool>;
using VVB = vector<VB>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VS = vector<string>;
using VD = vector<LD>;
using PII = pair<int, int>;
using VP = vector<PII>;
using PLL = pair<ll, ll>;
using VPL = vector<PLL>;
template <class T> using PQ = priority_queue<T>;
template <class T> using PQS = priority_queue<T, vector<T>, greater<T>>;
constexpr int inf = 1000000000;
constexpr long long inf_ll = 1000000000000000000ll, MOD = 1000000007;
constexpr long double PI = 3.14159265358979323846, EPS = 1e-12;
#line 7 "/home/yuruhiya/programming/library/template/Input.cpp"
using namespace std;

#ifdef _WIN32
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#define fwrite_unlocked fwrite
#define fflush_unlocked fflush
#endif
class Scanner {
	static int gc() {
		return getchar_unlocked();
	}
	static char next_char() {
		char c;
		read(c);
		return c;
	}
	template <class T> static void read(T& v) {
		cin >> v;
	}
	static void read(char& v) {
		while (isspace(v = gc()))
			;
	}
	static void read(bool& v) {
		v = next_char() != '0';
	}
	static void read(string& v) {
		v.clear();
		for (char c = next_char(); !isspace(c); c = gc()) v += c;
	}
	static void read(int& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(long long& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(double& v) {
		v = 0;
		double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	static void read(long double& v) {
		v = 0;
		long double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	template <class T, class U> static void read(pair<T, U>& v) {
		read(v.first);
		read(v.second);
	}
	template <class T> static void read(vector<T>& v) {
		for (auto& e : v) read(e);
	}
	template <size_t N = 0, class T> static void read_tuple_impl(T& v) {
		if constexpr (N < tuple_size_v<T>) {
			read(get<N>(v));
			read_tuple_impl<N + 1>(v);
		}
	}
	template <class... T> static void read(tuple<T...>& v) {
		read_tuple_impl(v);
	}
	struct ReadVectorHelper {
		size_t n;
		ReadVectorHelper(size_t _n) : n(_n) {}
		template <class T> operator vector<T>() {
			vector<T> v(n);
			read(v);
			return v;
		}
	};
	struct Read2DVectorHelper {
		size_t n, m;
		Read2DVectorHelper(const pair<size_t, size_t>& nm) : n(nm.first), m(nm.second) {}
		template <class T> operator vector<vector<T>>() {
			vector<vector<T>> v(n, vector<T>(m));
			read(v);
			return v;
		}
	};

public:
	string read_line() const {
		string v;
		for (char c = gc(); c != '\n' && c != '\0'; c = gc()) v += c;
		return v;
	}
	template <class T> T read() const {
		T v;
		read(v);
		return v;
	}
	template <class T> vector<T> read_vector(size_t n) const {
		vector<T> a(n);
		read(a);
		return a;
	}
	template <class T> operator T() const {
		return read<T>();
	}
	int operator--(int) const {
		return read<int>() - 1;
	}
	ReadVectorHelper operator[](size_t n) const {
		return ReadVectorHelper(n);
	}
	Read2DVectorHelper operator[](const pair<size_t, size_t>& nm) const {
		return Read2DVectorHelper(nm);
	}
	void operator()() const {}
	template <class H, class... T> void operator()(H&& h, T&&... t) const {
		read(h);
		operator()(forward<T>(t)...);
	}

private:
	template <template <class...> class, class...> struct Multiple;
	template <template <class...> class V, class Head, class... Tail>
	struct Multiple<V, Head, Tail...> {
		template <class... Args> using vec = V<vector<Head>, Args...>;
		using type = typename Multiple<vec, Tail...>::type;
	};
	template <template <class...> class V> struct Multiple<V> { using type = V<>; };
	template <class... T> using multiple_t = typename Multiple<tuple, T...>::type;
	template <size_t N = 0, class T> void multiple_impl(T& t) const {
		if constexpr (N < tuple_size_v<T>) {
			auto& vec = get<N>(t);
			using V = typename remove_reference_t<decltype(vec)>::value_type;
			vec.push_back(read<V>());
			multiple_impl<N + 1>(t);
		}
	}

public:
	template <class... T> auto multiple(size_t h) const {
		multiple_t<T...> result;
		while (h--) multiple_impl(result);
		return result;
	}
} in;
#define inputs(T, ...) \
	T __VA_ARGS__;     \
	in(__VA_ARGS__)
#define ini(...) inputs(int, __VA_ARGS__)
#define inl(...) inputs(long long, __VA_ARGS__)
#define ins(...) inputs(string, __VA_ARGS__)
#line 7 "/home/yuruhiya/programming/library/template/Output.cpp"
#include <charconv>
#line 10 "/home/yuruhiya/programming/library/template/Output.cpp"
using namespace std;

struct BoolStr {
	const char *t, *f;
	BoolStr(const char* _t, const char* _f) : t(_t), f(_f) {}
} Yes("Yes", "No"), yes("yes", "no"), YES("YES", "NO"), Int("1", "0");
struct DivStr {
	const char *d, *l;
	DivStr(const char* _d, const char* _l) : d(_d), l(_l) {}
} spc(" ", "\n"), no_spc("", "\n"), end_line("\n", "\n"), comma(",", "\n"),
    no_endl(" ", "");
class Printer {
	BoolStr B{Yes};
	DivStr D{spc};

public:
	void print(int v) const {
		char buf[12]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void print(long long v) const {
		char buf[21]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void print(bool v) const {
		print(v ? B.t : B.f);
	}
	void print(vector<bool>::reference v) const {
		print(v ? B.t : B.f);
	}
	void print(char v) const {
		putchar_unlocked(v);
	}
	void print(const char* v) const {
		fwrite_unlocked(v, 1, strlen(v), stdout);
	}
	void print(double v) const {
		printf("%.20f", v);
	}
	void print(long double v) const {
		printf("%.20Lf", v);
	}
	template <class T> void print(const T& v) const {
		cout << v;
	}
	template <class T, class U> void print(const pair<T, U>& v) const {
		print(v.first);
		print(D.d);
		print(v.second);
	}
	template <class InputIterater>
	void print_range(const InputIterater& begin, const InputIterater& end) const {
		for (InputIterater i = begin; i != end; ++i) {
			if (i != begin) print(D.d);
			print(*i);
		}
	}
	template <class T> void print(const vector<T>& v) const {
		print_range(v.begin(), v.end());
	}
	template <class T, size_t N> void print(const array<T, N>& v) const {
		print_range(v.begin(), v.end());
	}
	template <class T> void print(const vector<vector<T>>& v) const {
		for (size_t i = 0; i < v.size(); ++i) {
			if (i) print(D.l);
			print(v[i]);
		}
	}

	Printer() = default;
	Printer(const BoolStr& _boolstr, const DivStr& _divstr) : B(_boolstr), D(_divstr) {}
	Printer& operator()() {
		print(D.l);
		return *this;
	}
	template <class H> Printer& operator()(H&& h) {
		print(h);
		print(D.l);
		return *this;
	}
	template <class H, class... T> Printer& operator()(H&& h, T&&... t) {
		print(h);
		print(D.d);
		return operator()(forward<T>(t)...);
	}
	template <class InputIterator>
	Printer& range(const InputIterator& begin, const InputIterator& end) {
		print_range(begin, end);
		print(D.l);
		return *this;
	}
	template <class T> Printer& range(const T& a) {
		range(a.begin(), a.end());
		return *this;
	}
	template <class... T> void exit(T&&... t) {
		operator()(forward<T>(t)...);
		std::exit(EXIT_SUCCESS);
	}
	Printer& flush() {
		fflush_unlocked(stdout);
		return *this;
	}
	Printer& set(const BoolStr& b) {
		B = b;
		return *this;
	}
	Printer& set(const DivStr& d) {
		D = d;
		return *this;
	}
	Printer& set(const char* t, const char* f) {
		B = BoolStr(t, f);
		return *this;
	}
} out;
#line 3 "/home/yuruhiya/programming/library/template/Step.cpp"
using namespace std;

template <class T> struct Step {
	using value_type = T;

	class iterator {
		value_type a, b, c;

	public:
		constexpr iterator() : a(value_type()), b(value_type()), c(value_type()) {}
		constexpr iterator(value_type _b, value_type _c, value_type _s)
		    : a(_b), b(_c), c(_s) {}
		constexpr iterator& operator++() {
			--b;
			a += c;
			return *this;
		}
		constexpr iterator operator++(int) {
			iterator tmp = *this;
			--b;
			a += c;
			return tmp;
		}
		constexpr const value_type& operator*() const {
			return a;
		}
		constexpr const value_type* operator->() const {
			return &a;
		}
		constexpr bool operator==(const iterator& i) const {
			return b == i.b;
		}
		constexpr bool operator!=(const iterator& i) const {
			return !(b == i.b);
		}
		constexpr value_type start() const {
			return a;
		}
		constexpr value_type size() const {
			return b;
		}
		constexpr value_type step() const {
			return c;
		}
	};
	constexpr Step(value_type b, value_type c, value_type s) : be(b, c, s) {}
	constexpr iterator begin() const {
		return be;
	}
	constexpr iterator end() const {
		return en;
	}
	constexpr value_type start() const {
		return be.start();
	}
	constexpr value_type size() const {
		return be.size();
	}
	constexpr value_type step() const {
		return be.step();
	}
	constexpr value_type sum() const {
		return start() * size() + step() * (size() * (size() - 1) / 2);
	}
	operator vector<value_type>() const {
		return to_a();
	}
	auto to_a() const {
		vector<value_type> result;
		result.reserve(size());
		for (auto i : *this) {
			result.push_back(i);
		}
		return result;
	}

private:
	iterator be, en;
};
template <class T> constexpr auto step(T a) {
	return Step<T>(0, a, 1);
}
template <class T> constexpr auto step(T a, T b) {
	return Step<T>(a, b - a, 1);
}
template <class T> constexpr auto step(T a, T b, T c) {
	return Step<T>(a, a < b ? (b - a - 1) / c + 1 : 0, c);
}
#line 8 "/home/yuruhiya/programming/library/template/Ruby.cpp"
using namespace std;

template <class F> struct Callable {
	F func;
	Callable(const F& f) : func(f) {}
};
template <class T, class F> auto operator|(const T& v, const Callable<F>& c) {
	return c.func(v);
}

struct Sort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const Sort_impl& c) {
		sort(begin(v), end(v));
		return v;
	}
} Sort;
struct SortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) < f(j); });
			return v;
		});
	}
} SortBy;
struct RSort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(rbegin(v), rend(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const RSort_impl& c) {
		sort(rbegin(v), rend(v));
		return v;
	}
} RSort;
struct RSortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) > f(j); });
			return v;
		});
	}
} RSortBy;
struct Reverse_impl {
	template <class T> friend auto operator|(T v, const Reverse_impl& c) {
		reverse(begin(v), end(v));
		return v;
	}
} Reverse;
struct Unique_impl {
	template <class T> friend auto operator|(T v, const Unique_impl& c) {
		v.erase(unique(begin(v), end(v), end(v)));
		return v;
	}
} Unique;
struct Uniq_impl {
	template <class T> friend auto operator|(T v, const Uniq_impl& c) {
		sort(begin(v), end(v));
		v.erase(unique(begin(v), end(v)), end(v));
		return v;
	}
} Uniq;
struct Rotate_impl {
	auto operator()(int&& left) {
		return Callable([&](auto v) {
			int s = static_cast<int>(size(v));
			assert(-s <= left && left <= s);
			if (0 <= left) {
				rotate(begin(v), begin(v) + left, end(v));
			} else {
				rotate(begin(v), end(v) + left, end(v));
			}
			return v;
		});
	}
} Rotate;
struct Max_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *max_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Max_impl& c) {
		return *max_element(begin(v), end(v));
	}
} Max;
struct Min_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *min_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Min_impl& c) {
		return *min_element(begin(v), end(v));
	}
} Min;
struct MaxPos_impl {
	template <class T> friend auto operator|(T v, const MaxPos_impl& c) {
		return max_element(begin(v), end(v)) - begin(v);
	}
} MaxPos;
struct MinPos_impl {
	template <class T> friend auto operator|(T v, const MinPos_impl& c) {
		return min_element(begin(v), end(v)) - begin(v);
	}
} MinPos;
struct MaxBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_it = begin(v);
			auto max_val = f(*max_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_it = it;
					max_val = val;
				}
			}
			return *max_it;
		});
	}
} MaxBy;
struct MinBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_it = begin(v);
			auto min_val = f(*min_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_it = it;
					min_val = val;
				}
			}
			return *min_it;
		});
	}
} MinBy;
struct MaxOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_val = val;
				}
			}
			return max_val;
		});
	}
} MaxOf;
struct MinOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_val = val;
				}
			}
			return min_val;
		});
	}
} MinOf;
struct Count_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return count(begin(v), end(v), val); });
	}
} Count;
struct CountIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return count_if(begin(v), end(v), f); });
	}
} CountIf;
struct Index_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(begin(v), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
	template <class V> auto operator()(const V& val, size_t i) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(next(begin(v), i), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} Index;
struct IndexIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} IndexIf;
struct FindIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<typename decltype(v)::value_type> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(*result) : nullopt;
		});
	}
} FindIf;
struct Sum_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			return accumulate(next(begin(v)), end(v), f(*begin(v)),
			                  [&](const auto& a, const auto& b) { return a + f(b); });
		});
	}
	template <class T> friend auto operator|(T v, const Sum_impl& c) {
		return accumulate(begin(v), end(v), typename T::value_type{});
	}
} Sum;
struct Includes {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return find(begin(v), end(v), val) != end(v); });
	}
} Includes;
struct IncludesIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return find_if(begin(v), end(v), f) != end(v); });
	}
} IncludesIf;
struct RemoveIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) {
			v.erase(remove_if(begin(v), end(v), f), end(v));
			return v;
		});
	}
} RemoveIf;
struct Each_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				f(i);
			}
		});
	}
} Each;
struct EachConsPair_impl {
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, EachConsPair_impl& c) {
		vector<pair<value_type, value_type>> result;
		if (size(v) >= 2) {
			result.reserve(size(v) - 1);
			for (size_t i = 0; i < size(v) - 1; ++i) {
				result.emplace_back(v[i], v[i + 1]);
			}
		}
		return result;
	}
} EachConsPair;
struct Select_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using value_type = typename decltype(v)::value_type;
			vector<value_type> result;
			for (const auto& i : v) {
				if (f(i)) result.push_back(i);
			}
			return result;
		});
	}
} Select;
struct Map_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using result_type = invoke_result_t<F, typename decltype(v)::value_type>;
			vector<result_type> result;
			result.reserve(size(v));
			for (const auto& i : v) {
				result.push_back(f(i));
			}
			return result;
		});
	}
} Map;
struct Indexed_impl {
	template <class T> friend auto operator|(const T& v, Indexed_impl& c) {
		using value_type = typename T::value_type;
		vector<pair<value_type, int>> result;
		result.reserve(size(v));
		int index = 0;
		for (const auto& i : v) {
			result.emplace_back(i, index++);
		}
		return result;
	}
} Indexed;
struct AllOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (!f(i)) return false;
			}
			return true;
		});
	}
} AllOf;
struct AnyOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return true;
			}
			return false;
		});
	}
} AnyOf;
struct NoneOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return false;
			}
			return true;
		});
	}
} NoneOf;

struct Tally_impl {
	template <class F> auto operator()(size_t max_val) {
		return Callable([&](auto v) {
			vector<size_t> result(max_val);
			for (const auto& i : v) {
				result[static_cast<size_t>(i)]++;
			}
			return result;
		});
	}
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, Tally_impl& c) {
		map<value_type, size_t> result;
		for (const auto& i : v) {
			result[i]++;
		}
		return result;
	}
} Tally;

template <class T> auto operator*(const vector<T>& a, size_t n) {
	T result;
	for (size_t i = 0; i < n; ++i) {
		result.insert(result.end(), a.begin(), a.end());
	}
	return result;
}
auto operator*(string a, size_t n) {
	string result;
	for (size_t i = 0; i < n; ++i) {
		result += a;
	}
	return result;
}
template <class T, class U> auto& operator<<(vector<T>& a, const U& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T> auto& operator<<(string& a, const T& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T, class U> auto operator+(vector<T> a, const U& b) {
	a << b;
	return a;
}
template <class T> auto operator+(string a, const T& b) {
	a << b;
	return a;
}
#line 7 "/home/yuruhiya/programming/library/template/functions.cpp"
using namespace std;

template <class T = long long> constexpr T TEN(size_t n) {
	T result = 1;
	for (size_t i = 0; i < n; ++i) result *= 10;
	return result;
}
template <class T, class U,
          enable_if_t<is_integral_v<T> && is_integral_v<U>, nullptr_t> = nullptr>
constexpr auto div_ceil(T n, U m) {
	return (n + m - 1) / m;
}
template <class T, class U> constexpr auto div_ceil2(T n, U m) {
	return div_ceil(n, m) * m;
}
template <class T> constexpr T triangle(T n) {
	return (n & 1) ? (n + 1) / 2 * n : n / 2 * (n + 1);
}
template <class T> constexpr T nC2(T n) {
	return (n & 1) ? (n - 1) / 2 * n : n / 2 * (n - 1);
}
template <class T, class U> constexpr auto middle(const T& l, const U& r) {
	return l + (r - l) / 2;
}
template <class T, class U, class V>
constexpr bool in_range(const T& v, const U& lower, const V& upper) {
	return lower <= v && v < upper;
}
template <class T, enable_if_t<is_integral_v<T>, nullptr_t> = nullptr>
constexpr bool is_square(T n) {
	T s = sqrt(n);
	return s * s == n || (s + 1) * (s + 1) == n;
}
template <class T = long long> constexpr T BIT(int b) {
	return T(1) << b;
}
template <class T> constexpr int BIT(T x, int i) {
	return (x & (T(1) << i)) ? 1 : 0;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Pow(T a, U n) {
	assert(n >= 0);
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result *= a;
			n--;
		} else {
			a *= a;
			n >>= 1;
		}
	}
	return result;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Powmod(T a, U n, T mod) {
	assert(n >= 0);
	if (a > mod) a %= mod;
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result = result * a % mod;
			n--;
		} else {
			a = a * a % mod;
			n >>= 1;
		}
	}
	return result;
}
template <class T> bool chmax(T& a, const T& b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> bool chmin(T& a, const T& b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> int sz(const T& v) {
	return v.size();
}
template <class T, class U> int lower_index(const T& a, const U& v) {
	return lower_bound(all(a), v) - a.begin();
}
template <class T, class U> int upper_index(const T& a, const U& v) {
	return upper_bound(all(a), v) - a.begin();
}
template <class T> auto Slice(const T& v, size_t i, size_t len) {
	return i < v.size() ? T(v.begin() + i, v.begin() + min(i + len, v.size())) : T();
}
template <class T, class U = typename T::value_type> U Gcdv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), gcd<U, U>);
}
template <class T, class U = typename T::value_type> U Lcmv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), lcm<U, U>);
}
namespace internal {
	template <class T, size_t N> auto make_vector(vector<int>& sizes, const T& init) {
		if constexpr (N == 1) {
			return vector(sizes[0], init);
		} else {
			int size = sizes[N - 1];
			sizes.pop_back();
			return vector(size, make_vector<T, N - 1>(sizes, init));
		}
	}
}  // namespace internal
template <class T, size_t N>
auto make_vector(const int (&sizes)[N], const T& init = T()) {
	vector s(rbegin(sizes), rend(sizes));
	return internal::make_vector<T, N>(s, init);
}
#line 9 "/home/yuruhiya/programming/library/template/template.cpp"
#if __has_include(<library/dump.hpp>)
#include <library/dump.hpp>
#define LOCAL
#else
#define dump(...) ((void)0)
#endif

template <class T> constexpr T oj_local(const T& oj, const T& local) {
#ifndef LOCAL
	return oj;
#else
	return local;
#endif
}
#line 5 "/home/yuruhiya/programming/library/Graph/GraphTemplate.cpp"
using namespace std;

using Weight = long long;
constexpr Weight INF = numeric_limits<Weight>::max();
struct Edge {
	int to;
	Weight cost;
	Edge() : to(-1), cost(-1) {}
	Edge(int _to, Weight _cost = 1) : to(_to), cost(_cost) {}
	friend bool operator<(const Edge& e1, const Edge& e2) {
		return e1.cost < e2.cost;
	}
	friend bool operator>(const Edge& e1, const Edge& e2) {
		return e1.cost > e2.cost;
	}
	friend ostream& operator<<(ostream& os, const Edge& e) {
		return os << "->" << e.to << '(' << e.cost << ')';
	}
};
using Graph = vector<vector<Edge>>;
struct Edge2 {
	int from, to;
	Weight cost;
	Edge2() : from(-1), to(-1), cost(0) {}
	Edge2(int _from, int _to, Weight _cost) : from(_from), to(_to), cost(_cost) {}
	friend bool operator<(const Edge2& e1, const Edge2& e2) {
		return e1.cost < e2.cost;
	}
	friend bool operator>(const Edge2& e1, const Edge2& e2) {
		return e1.cost > e2.cost;
	}
	friend ostream& operator<<(ostream& os, const Edge2& e) {
		return os << e.from << "->" << e.to << '(' << e.cost << ')';
	}
};
using Edges = vector<Edge2>;
using Matrix = vector<vector<Weight>>;
#line 5 "/home/yuruhiya/programming/library/Graph/Dijkstra.cpp"
using namespace std;

vector<Weight> Dijkstra(const Graph& graph, int s) {
	int V = graph.size();
	vector<Weight> dist(V, INF);
	dist[s] = 0;
	priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
	pq.emplace(s, 0);
	while (!pq.empty()) {
		Edge p = pq.top();
		pq.pop();
		int v = p.to;
		if (dist[v] < p.cost) continue;
		for (auto e : graph[v]) {
			if (dist[e.to] > dist[v] + e.cost) {
				dist[e.to] = dist[v] + e.cost;
				pq.emplace(e.to, dist[e.to]);
			}
		}
	}
	return dist;
}
Weight Dijkstra(const Graph& graph, int s, int t) {
	int V = graph.size();
	vector<Weight> dist(V, INF);
	dist[s] = 0;
	priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
	pq.emplace(s, 0);
	while (!pq.empty()) {
		Edge p = pq.top();
		pq.pop();
		int v = p.to;
		if (v == t) return dist[t];
		if (dist[v] < p.cost) continue;
		for (auto e : graph[v]) {
			if (dist[e.to] > dist[v] + e.cost) {
				dist[e.to] = dist[v] + e.cost;
				pq.emplace(e.to, dist[e.to]);
			}
		}
	}
	return dist[t];
}
#line 3 "a.cpp"

int main() {
	inl(sx, sy, gx, gy);

	const int range = 50;
	VL x_val, y_val;
	x_val << step(sx - range, sx + range).to_a();
	x_val << step(gx - range, gx + range).to_a();
	y_val << step(sy - range, sy + range).to_a();
	y_val << step(gy - range, gy + range).to_a();
	x_val = x_val | Uniq;
	y_val = y_val | Uniq;
	dump(x_val, y_val);

	const int MAX_V = sz(x_val) * sz(y_val) * 2;
	Graph g(MAX_V);
	auto to_i = [&](ll x, ll y, ll time) {
		return lower_index(x_val, x) * sz(y_val) * 2 + lower_index(y_val, y) * 2 + time;
	};
	auto add_edge = [&](ll x1, ll y1, ll t1, ll x2, ll y2, ll t2, ll cost) {
		g[to_i(x1, y1, t1)].emplace_back(to_i(x2, y2, t2), cost);
	};
	auto add_edge2 = [&](ll x1, ll y1, ll t1, ll x2, ll y2, ll t2, ll cost) {
		add_edge(x1, y1, t1, x2, y2, t2, cost);
		add_edge(x2, y2, t2, x1, y1, t1, cost);
	};

	for (ll x : x_val) {
		for (ll y : y_val) {
			for (ll f : {0, 1}) {
				add_edge2(x, y, f, x, y, 1 - f, 1);
			}
		}
	}
	for (auto [x1, x2] : x_val | EachConsPair) {
		for (ll y : y_val) {
			for (ll f : {0, 1}) {
				if (x1 + 1 == x2) {
					if (x1 % 2 == 0 || f == 0) {
						add_edge2(x1, y, f, x2, y, 1 - f, 1);
					}
				} else {
					if ((x1 % 2 == 1 && f == 0) || (x1 % 2 == 0 && f == 1)) {
						add_edge2(x1, y, f, x2, y, (f + x2 - x1) % 2, x2 - x1);
					}
				}
			}
		}
	}
	for (ll x : x_val) {
		for (auto [y1, y2] : y_val | EachConsPair) {
			for (ll f : {0, 1}) {
				if (y1 + 1 == y2) {
					if (y1 % 2 == 0 || f == 1) {
						add_edge2(x, y1, f, x, y2, 1 - f, 1);
					}
				} else {
					if ((y1 % 2 == 1 && f == 1) || (y1 % 2 == 0 && f == 0)) {
						add_edge2(x, y1, f, x, y2, (f + y2 - y1) % 2, y2 - y1);
					}
				}
			}
		}
	}

	ll ans1 = Dijkstra(g, to_i(sx, sy, 0), to_i(gx, gy, 0));
	ll ans2 = Dijkstra(g, to_i(sx, sy, 0), to_i(gx, gy, 1));
	out(min(ans1, ans2));
}
accuracy: 0.06382978723404255
time_ms: 40
memory_kb: 17320
final_rank: 18

code_snippet: #line 2 "/home/yuruhiya/programming/library/template/template.cpp"
#include <bits/stdc++.h>
#line 4 "/home/yuruhiya/programming/library/template/constants.cpp"
#include <string_view>
#line 7 "/home/yuruhiya/programming/library/template/constants.cpp"

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define rrep(i, n) for (int i = (n)-1; i >= 0; --i)
#define rfor(i, m, n) for (int i = (m); i >= (n); --i)
#define unless(c) if (!(c))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define range_it(a, l, r) (a).begin() + (l), (a).begin() + (r)

using namespace std;
using ll = long long;
using LD = long double;
using VB = vector<bool>;
using VVB = vector<VB>;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VS = vector<string>;
using VD = vector<LD>;
using PII = pair<int, int>;
using VP = vector<PII>;
using PLL = pair<ll, ll>;
using VPL = vector<PLL>;
template <class T> using PQ = priority_queue<T>;
template <class T> using PQS = priority_queue<T, vector<T>, greater<T>>;
constexpr int inf = 1000000000;
constexpr long long inf_ll = 1000000000000000000ll, MOD = 1000000007;
constexpr long double PI = 3.14159265358979323846, EPS = 1e-12;
#line 7 "/home/yuruhiya/programming/library/template/Input.cpp"
using namespace std;

#ifdef _WIN32
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#define fwrite_unlocked fwrite
#define fflush_unlocked fflush
#endif
class Scanner {
	static int gc() {
		return getchar_unlocked();
	}
	static char next_char() {
		char c;
		read(c);
		return c;
	}
	template <class T> static void read(T& v) {
		cin >> v;
	}
	static void read(char& v) {
		while (isspace(v = gc()))
			;
	}
	static void read(bool& v) {
		v = next_char() != '0';
	}
	static void read(string& v) {
		v.clear();
		for (char c = next_char(); !isspace(c); c = gc()) v += c;
	}
	static void read(int& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(long long& v) {
		v = 0;
		bool neg = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c); c = gc()) v = v * 10 + (c - '0');
		if (neg) v = -v;
	}
	static void read(double& v) {
		v = 0;
		double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	static void read(long double& v) {
		v = 0;
		long double dp = 1;
		bool neg = false, after_dp = false;
		char c = next_char();
		if (c == '-') {
			neg = true;
			c = gc();
		}
		for (; isdigit(c) || c == '.'; c = gc()) {
			if (c == '.') {
				after_dp = true;
			} else if (after_dp) {
				v += (c - '0') * (dp *= 0.1);
			} else {
				v = v * 10 + (c - '0');
			}
		}
		if (neg) v = -v;
	}
	template <class T, class U> static void read(pair<T, U>& v) {
		read(v.first);
		read(v.second);
	}
	template <class T> static void read(vector<T>& v) {
		for (auto& e : v) read(e);
	}
	template <size_t N = 0, class T> static void read_tuple_impl(T& v) {
		if constexpr (N < tuple_size_v<T>) {
			read(get<N>(v));
			read_tuple_impl<N + 1>(v);
		}
	}
	template <class... T> static void read(tuple<T...>& v) {
		read_tuple_impl(v);
	}
	struct ReadVectorHelper {
		size_t n;
		ReadVectorHelper(size_t _n) : n(_n) {}
		template <class T> operator vector<T>() {
			vector<T> v(n);
			read(v);
			return v;
		}
	};
	struct Read2DVectorHelper {
		size_t n, m;
		Read2DVectorHelper(const pair<size_t, size_t>& nm) : n(nm.first), m(nm.second) {}
		template <class T> operator vector<vector<T>>() {
			vector<vector<T>> v(n, vector<T>(m));
			read(v);
			return v;
		}
	};

public:
	string read_line() const {
		string v;
		for (char c = gc(); c != '\n' && c != '\0'; c = gc()) v += c;
		return v;
	}
	template <class T> T read() const {
		T v;
		read(v);
		return v;
	}
	template <class T> vector<T> read_vector(size_t n) const {
		vector<T> a(n);
		read(a);
		return a;
	}
	template <class T> operator T() const {
		return read<T>();
	}
	int operator--(int) const {
		return read<int>() - 1;
	}
	ReadVectorHelper operator[](size_t n) const {
		return ReadVectorHelper(n);
	}
	Read2DVectorHelper operator[](const pair<size_t, size_t>& nm) const {
		return Read2DVectorHelper(nm);
	}
	void operator()() const {}
	template <class H, class... T> void operator()(H&& h, T&&... t) const {
		read(h);
		operator()(forward<T>(t)...);
	}

private:
	template <template <class...> class, class...> struct Multiple;
	template <template <class...> class V, class Head, class... Tail>
	struct Multiple<V, Head, Tail...> {
		template <class... Args> using vec = V<vector<Head>, Args...>;
		using type = typename Multiple<vec, Tail...>::type;
	};
	template <template <class...> class V> struct Multiple<V> { using type = V<>; };
	template <class... T> using multiple_t = typename Multiple<tuple, T...>::type;
	template <size_t N = 0, class T> void multiple_impl(T& t) const {
		if constexpr (N < tuple_size_v<T>) {
			auto& vec = get<N>(t);
			using V = typename remove_reference_t<decltype(vec)>::value_type;
			vec.push_back(read<V>());
			multiple_impl<N + 1>(t);
		}
	}

public:
	template <class... T> auto multiple(size_t h) const {
		multiple_t<T...> result;
		while (h--) multiple_impl(result);
		return result;
	}
} in;
#define inputs(T, ...) \
	T __VA_ARGS__;     \
	in(__VA_ARGS__)
#define ini(...) inputs(int, __VA_ARGS__)
#define inl(...) inputs(long long, __VA_ARGS__)
#define ins(...) inputs(string, __VA_ARGS__)
#line 7 "/home/yuruhiya/programming/library/template/Output.cpp"
#include <charconv>
#line 10 "/home/yuruhiya/programming/library/template/Output.cpp"
using namespace std;

struct BoolStr {
	const char *t, *f;
	BoolStr(const char* _t, const char* _f) : t(_t), f(_f) {}
} Yes("Yes", "No"), yes("yes", "no"), YES("YES", "NO"), Int("1", "0");
struct DivStr {
	const char *d, *l;
	DivStr(const char* _d, const char* _l) : d(_d), l(_l) {}
} spc(" ", "\n"), no_spc("", "\n"), end_line("\n", "\n"), comma(",", "\n"),
    no_endl(" ", "");
class Printer {
	BoolStr B{Yes};
	DivStr D{spc};

public:
	void print(int v) const {
		char buf[12]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void print(long long v) const {
		char buf[21]{};
		if (auto [ptr, e] = to_chars(begin(buf), end(buf), v); e == errc{}) {
			fwrite(buf, sizeof(char), ptr - buf, stdout);
		} else {
			assert(false);
		}
	}
	void print(bool v) const {
		print(v ? B.t : B.f);
	}
	void print(vector<bool>::reference v) const {
		print(v ? B.t : B.f);
	}
	void print(char v) const {
		putchar_unlocked(v);
	}
	void print(const char* v) const {
		fwrite_unlocked(v, 1, strlen(v), stdout);
	}
	void print(double v) const {
		printf("%.20f", v);
	}
	void print(long double v) const {
		printf("%.20Lf", v);
	}
	template <class T> void print(const T& v) const {
		cout << v;
	}
	template <class T, class U> void print(const pair<T, U>& v) const {
		print(v.first);
		print(D.d);
		print(v.second);
	}
	template <class InputIterater>
	void print_range(const InputIterater& begin, const InputIterater& end) const {
		for (InputIterater i = begin; i != end; ++i) {
			if (i != begin) print(D.d);
			print(*i);
		}
	}
	template <class T> void print(const vector<T>& v) const {
		print_range(v.begin(), v.end());
	}
	template <class T, size_t N> void print(const array<T, N>& v) const {
		print_range(v.begin(), v.end());
	}
	template <class T> void print(const vector<vector<T>>& v) const {
		for (size_t i = 0; i < v.size(); ++i) {
			if (i) print(D.l);
			print(v[i]);
		}
	}

	Printer() = default;
	Printer(const BoolStr& _boolstr, const DivStr& _divstr) : B(_boolstr), D(_divstr) {}
	Printer& operator()() {
		print(D.l);
		return *this;
	}
	template <class H> Printer& operator()(H&& h) {
		print(h);
		print(D.l);
		return *this;
	}
	template <class H, class... T> Printer& operator()(H&& h, T&&... t) {
		print(h);
		print(D.d);
		return operator()(forward<T>(t)...);
	}
	template <class InputIterator>
	Printer& range(const InputIterator& begin, const InputIterator& end) {
		print_range(begin, end);
		print(D.l);
		return *this;
	}
	template <class T> Printer& range(const T& a) {
		range(a.begin(), a.end());
		return *this;
	}
	template <class... T> void exit(T&&... t) {
		operator()(forward<T>(t)...);
		std::exit(EXIT_SUCCESS);
	}
	Printer& flush() {
		fflush_unlocked(stdout);
		return *this;
	}
	Printer& set(const BoolStr& b) {
		B = b;
		return *this;
	}
	Printer& set(const DivStr& d) {
		D = d;
		return *this;
	}
	Printer& set(const char* t, const char* f) {
		B = BoolStr(t, f);
		return *this;
	}
} out;
#line 3 "/home/yuruhiya/programming/library/template/Step.cpp"
using namespace std;

template <class T> struct Step {
	using value_type = T;

	class iterator {
		value_type a, b, c;

	public:
		constexpr iterator() : a(value_type()), b(value_type()), c(value_type()) {}
		constexpr iterator(value_type _b, value_type _c, value_type _s)
		    : a(_b), b(_c), c(_s) {}
		constexpr iterator& operator++() {
			--b;
			a += c;
			return *this;
		}
		constexpr iterator operator++(int) {
			iterator tmp = *this;
			--b;
			a += c;
			return tmp;
		}
		constexpr const value_type& operator*() const {
			return a;
		}
		constexpr const value_type* operator->() const {
			return &a;
		}
		constexpr bool operator==(const iterator& i) const {
			return b == i.b;
		}
		constexpr bool operator!=(const iterator& i) const {
			return !(b == i.b);
		}
		constexpr value_type start() const {
			return a;
		}
		constexpr value_type size() const {
			return b;
		}
		constexpr value_type step() const {
			return c;
		}
	};
	constexpr Step(value_type b, value_type c, value_type s) : be(b, c, s) {}
	constexpr iterator begin() const {
		return be;
	}
	constexpr iterator end() const {
		return en;
	}
	constexpr value_type start() const {
		return be.start();
	}
	constexpr value_type size() const {
		return be.size();
	}
	constexpr value_type step() const {
		return be.step();
	}
	constexpr value_type sum() const {
		return start() * size() + step() * (size() * (size() - 1) / 2);
	}
	operator vector<value_type>() const {
		return to_a();
	}
	auto to_a() const {
		vector<value_type> result;
		result.reserve(size());
		for (auto i : *this) {
			result.push_back(i);
		}
		return result;
	}

private:
	iterator be, en;
};
template <class T> constexpr auto step(T a) {
	return Step<T>(0, a, 1);
}
template <class T> constexpr auto step(T a, T b) {
	return Step<T>(a, b - a, 1);
}
template <class T> constexpr auto step(T a, T b, T c) {
	return Step<T>(a, a < b ? (b - a - 1) / c + 1 : 0, c);
}
#line 8 "/home/yuruhiya/programming/library/template/Ruby.cpp"
using namespace std;

template <class F> struct Callable {
	F func;
	Callable(const F& f) : func(f) {}
};
template <class T, class F> auto operator|(const T& v, const Callable<F>& c) {
	return c.func(v);
}

struct Sort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const Sort_impl& c) {
		sort(begin(v), end(v));
		return v;
	}
} Sort;
struct SortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) < f(j); });
			return v;
		});
	}
} SortBy;
struct RSort_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(rbegin(v), rend(v), f);
			return v;
		});
	}
	template <class T> friend auto operator|(T v, [[maybe_unused]] const RSort_impl& c) {
		sort(rbegin(v), rend(v));
		return v;
	}
} RSort;
struct RSortBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			sort(begin(v), end(v),
			     [&](const auto& i, const auto& j) { return f(i) > f(j); });
			return v;
		});
	}
} RSortBy;
struct Reverse_impl {
	template <class T> friend auto operator|(T v, const Reverse_impl& c) {
		reverse(begin(v), end(v));
		return v;
	}
} Reverse;
struct Unique_impl {
	template <class T> friend auto operator|(T v, const Unique_impl& c) {
		v.erase(unique(begin(v), end(v), end(v)));
		return v;
	}
} Unique;
struct Uniq_impl {
	template <class T> friend auto operator|(T v, const Uniq_impl& c) {
		sort(begin(v), end(v));
		v.erase(unique(begin(v), end(v)), end(v));
		return v;
	}
} Uniq;
struct Rotate_impl {
	auto operator()(int&& left) {
		return Callable([&](auto v) {
			int s = static_cast<int>(size(v));
			assert(-s <= left && left <= s);
			if (0 <= left) {
				rotate(begin(v), begin(v) + left, end(v));
			} else {
				rotate(begin(v), end(v) + left, end(v));
			}
			return v;
		});
	}
} Rotate;
struct Max_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *max_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Max_impl& c) {
		return *max_element(begin(v), end(v));
	}
} Max;
struct Min_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) { return *min_element(begin(v), end(v), f); });
	}
	template <class T> friend auto operator|(T v, const Min_impl& c) {
		return *min_element(begin(v), end(v));
	}
} Min;
struct MaxPos_impl {
	template <class T> friend auto operator|(T v, const MaxPos_impl& c) {
		return max_element(begin(v), end(v)) - begin(v);
	}
} MaxPos;
struct MinPos_impl {
	template <class T> friend auto operator|(T v, const MinPos_impl& c) {
		return min_element(begin(v), end(v)) - begin(v);
	}
} MinPos;
struct MaxBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_it = begin(v);
			auto max_val = f(*max_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_it = it;
					max_val = val;
				}
			}
			return *max_it;
		});
	}
} MaxBy;
struct MinBy_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_it = begin(v);
			auto min_val = f(*min_it);
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_it = it;
					min_val = val;
				}
			}
			return *min_it;
		});
	}
} MinBy;
struct MaxOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto max_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); max_val < val) {
					max_val = val;
				}
			}
			return max_val;
		});
	}
} MaxOf;
struct MinOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			auto min_val = f(*begin(v));
			for (auto it = next(begin(v)); it != end(v); ++it) {
				if (auto val = f(*it); min_val > val) {
					min_val = val;
				}
			}
			return min_val;
		});
	}
} MinOf;
struct Count_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return count(begin(v), end(v), val); });
	}
} Count;
struct CountIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return count_if(begin(v), end(v), f); });
	}
} CountIf;
struct Index_impl {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(begin(v), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
	template <class V> auto operator()(const V& val, size_t i) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find(next(begin(v), i), end(v), val);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} Index;
struct IndexIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<int> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(result - begin(v)) : nullopt;
		});
	}
} IndexIf;
struct FindIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) -> optional<typename decltype(v)::value_type> {
			auto result = find_if(begin(v), end(v), f);
			return result != end(v) ? optional(*result) : nullopt;
		});
	}
} FindIf;
struct Sum_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			return accumulate(next(begin(v)), end(v), f(*begin(v)),
			                  [&](const auto& a, const auto& b) { return a + f(b); });
		});
	}
	template <class T> friend auto operator|(T v, const Sum_impl& c) {
		return accumulate(begin(v), end(v), typename T::value_type{});
	}
} Sum;
struct Includes {
	template <class V> auto operator()(const V& val) {
		return Callable([&](auto v) { return find(begin(v), end(v), val) != end(v); });
	}
} Includes;
struct IncludesIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) { return find_if(begin(v), end(v), f) != end(v); });
	}
} IncludesIf;
struct RemoveIf_impl {
	template <class F> auto operator()(const F& f) {
		return Callable([&](auto v) {
			v.erase(remove_if(begin(v), end(v), f), end(v));
			return v;
		});
	}
} RemoveIf;
struct Each_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				f(i);
			}
		});
	}
} Each;
struct EachConsPair_impl {
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, EachConsPair_impl& c) {
		vector<pair<value_type, value_type>> result;
		if (size(v) >= 2) {
			result.reserve(size(v) - 1);
			for (size_t i = 0; i < size(v) - 1; ++i) {
				result.emplace_back(v[i], v[i + 1]);
			}
		}
		return result;
	}
} EachConsPair;
struct Select_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using value_type = typename decltype(v)::value_type;
			vector<value_type> result;
			for (const auto& i : v) {
				if (f(i)) result.push_back(i);
			}
			return result;
		});
	}
} Select;
struct Map_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			using result_type = invoke_result_t<F, typename decltype(v)::value_type>;
			vector<result_type> result;
			result.reserve(size(v));
			for (const auto& i : v) {
				result.push_back(f(i));
			}
			return result;
		});
	}
} Map;
struct Indexed_impl {
	template <class T> friend auto operator|(const T& v, Indexed_impl& c) {
		using value_type = typename T::value_type;
		vector<pair<value_type, int>> result;
		result.reserve(size(v));
		int index = 0;
		for (const auto& i : v) {
			result.emplace_back(i, index++);
		}
		return result;
	}
} Indexed;
struct AllOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (!f(i)) return false;
			}
			return true;
		});
	}
} AllOf;
struct AnyOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return true;
			}
			return false;
		});
	}
} AnyOf;
struct NoneOf_impl {
	template <class F> auto operator()(F&& f) {
		return Callable([&](auto v) {
			for (const auto& i : v) {
				if (f(i)) return false;
			}
			return true;
		});
	}
} NoneOf;

struct Tally_impl {
	template <class F> auto operator()(size_t max_val) {
		return Callable([&](auto v) {
			vector<size_t> result(max_val);
			for (const auto& i : v) {
				result[static_cast<size_t>(i)]++;
			}
			return result;
		});
	}
	template <class T, class value_type = typename T::value_type>
	friend auto operator|(const T& v, Tally_impl& c) {
		map<value_type, size_t> result;
		for (const auto& i : v) {
			result[i]++;
		}
		return result;
	}
} Tally;

template <class T> auto operator*(const vector<T>& a, size_t n) {
	T result;
	for (size_t i = 0; i < n; ++i) {
		result.insert(result.end(), a.begin(), a.end());
	}
	return result;
}
auto operator*(string a, size_t n) {
	string result;
	for (size_t i = 0; i < n; ++i) {
		result += a;
	}
	return result;
}
template <class T, class U> auto& operator<<(vector<T>& a, const U& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T> auto& operator<<(string& a, const T& b) {
	a.insert(a.end(), all(b));
	return a;
}
template <class T, class U> auto operator+(vector<T> a, const U& b) {
	a << b;
	return a;
}
template <class T> auto operator+(string a, const T& b) {
	a << b;
	return a;
}
#line 7 "/home/yuruhiya/programming/library/template/functions.cpp"
using namespace std;

template <class T = long long> constexpr T TEN(size_t n) {
	T result = 1;
	for (size_t i = 0; i < n; ++i) result *= 10;
	return result;
}
template <class T, class U,
          enable_if_t<is_integral_v<T> && is_integral_v<U>, nullptr_t> = nullptr>
constexpr auto div_ceil(T n, U m) {
	return (n + m - 1) / m;
}
template <class T, class U> constexpr auto div_ceil2(T n, U m) {
	return div_ceil(n, m) * m;
}
template <class T> constexpr T triangle(T n) {
	return (n & 1) ? (n + 1) / 2 * n : n / 2 * (n + 1);
}
template <class T> constexpr T nC2(T n) {
	return (n & 1) ? (n - 1) / 2 * n : n / 2 * (n - 1);
}
template <class T, class U> constexpr auto middle(const T& l, const U& r) {
	return l + (r - l) / 2;
}
template <class T, class U, class V>
constexpr bool in_range(const T& v, const U& lower, const V& upper) {
	return lower <= v && v < upper;
}
template <class T, enable_if_t<is_integral_v<T>, nullptr_t> = nullptr>
constexpr bool is_square(T n) {
	T s = sqrt(n);
	return s * s == n || (s + 1) * (s + 1) == n;
}
template <class T = long long> constexpr T BIT(int b) {
	return T(1) << b;
}
template <class T> constexpr int BIT(T x, int i) {
	return (x & (T(1) << i)) ? 1 : 0;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Pow(T a, U n) {
	assert(n >= 0);
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result *= a;
			n--;
		} else {
			a *= a;
			n >>= 1;
		}
	}
	return result;
}
template <class T, class U, enable_if_t<is_integral_v<U>, nullptr_t> = nullptr>
constexpr T Powmod(T a, U n, T mod) {
	assert(n >= 0);
	if (a > mod) a %= mod;
	T result = 1;
	while (n > 0) {
		if (n & 1) {
			result = result * a % mod;
			n--;
		} else {
			a = a * a % mod;
			n >>= 1;
		}
	}
	return result;
}
template <class T> bool chmax(T& a, const T& b) {
	if (a < b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> bool chmin(T& a, const T& b) {
	if (a > b) {
		a = b;
		return true;
	}
	return false;
}
template <class T> int sz(const T& v) {
	return v.size();
}
template <class T, class U> int lower_index(const T& a, const U& v) {
	return lower_bound(all(a), v) - a.begin();
}
template <class T, class U> int upper_index(const T& a, const U& v) {
	return upper_bound(all(a), v) - a.begin();
}
template <class T> auto Slice(const T& v, size_t i, size_t len) {
	return i < v.size() ? T(v.begin() + i, v.begin() + min(i + len, v.size())) : T();
}
template <class T, class U = typename T::value_type> U Gcdv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), gcd<U, U>);
}
template <class T, class U = typename T::value_type> U Lcmv(const T& v) {
	return accumulate(next(v.begin()), v.end(), U(*v.begin()), lcm<U, U>);
}
namespace internal {
	template <class T, size_t N> auto make_vector(vector<int>& sizes, const T& init) {
		if constexpr (N == 1) {
			return vector(sizes[0], init);
		} else {
			int size = sizes[N - 1];
			sizes.pop_back();
			return vector(size, make_vector<T, N - 1>(sizes, init));
		}
	}
}  // namespace internal
template <class T, size_t N>
auto make_vector(const int (&sizes)[N], const T& init = T()) {
	vector s(rbegin(sizes), rend(sizes));
	return internal::make_vector<T, N>(s, init);
}
#line 9 "/home/yuruhiya/programming/library/template/template.cpp"
#if __has_include(<library/dump.hpp>)
#include <library/dump.hpp>
#define LOCAL
#else
#define dump(...) ((void)0)
#endif

template <class T> constexpr T oj_local(const T& oj, const T& local) {
#ifndef LOCAL
	return oj;
#else
	return local;
#endif
}
#line 5 "/home/yuruhiya/programming/library/Graph/GraphTemplate.cpp"
using namespace std;

using Weight = long long;
constexpr Weight INF = numeric_limits<Weight>::max();
struct Edge {
	int to;
	Weight cost;
	Edge() : to(-1), cost(-1) {}
	Edge(int _to, Weight _cost = 1) : to(_to), cost(_cost) {}
	friend bool operator<(const Edge& e1, const Edge& e2) {
		return e1.cost < e2.cost;
	}
	friend bool operator>(const Edge& e1, const Edge& e2) {
		return e1.cost > e2.cost;
	}
	friend ostream& operator<<(ostream& os, const Edge& e) {
		return os << "->" << e.to << '(' << e.cost << ')';
	}
};
using Graph = vector<vector<Edge>>;
struct Edge2 {
	int from, to;
	Weight cost;
	Edge2() : from(-1), to(-1), cost(0) {}
	Edge2(int _from, int _to, Weight _cost) : from(_from), to(_to), cost(_cost) {}
	friend bool operator<(const Edge2& e1, const Edge2& e2) {
		return e1.cost < e2.cost;
	}
	friend bool operator>(const Edge2& e1, const Edge2& e2) {
		return e1.cost > e2.cost;
	}
	friend ostream& operator<<(ostream& os, const Edge2& e) {
		return os << e.from << "->" << e.to << '(' << e.cost << ')';
	}
};
using Edges = vector<Edge2>;
using Matrix = vector<vector<Weight>>;
#line 5 "/home/yuruhiya/programming/library/Graph/Dijkstra.cpp"
using namespace std;

vector<Weight> Dijkstra(const Graph& graph, int s) {
	int V = graph.size();
	vector<Weight> dist(V, INF);
	dist[s] = 0;
	priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
	pq.emplace(s, 0);
	while (!pq.empty()) {
		Edge p = pq.top();
		pq.pop();
		int v = p.to;
		if (dist[v] < p.cost) continue;
		for (auto e : graph[v]) {
			if (dist[e.to] > dist[v] + e.cost) {
				dist[e.to] = dist[v] + e.cost;
				pq.emplace(e.to, dist[e.to]);
			}
		}
	}
	return dist;
}
Weight Dijkstra(const Graph& graph, int s, int t) {
	int V = graph.size();
	vector<Weight> dist(V, INF);
	dist[s] = 0;
	priority_queue<Edge, vector<Edge>, greater<Edge>> pq;
	pq.emplace(s, 0);
	while (!pq.empty()) {
		Edge p = pq.top();
		pq.pop();
		int v = p.to;
		if (v == t) return dist[t];
		if (dist[v] < p.cost) continue;
		for (auto e : graph[v]) {
			if (dist[e.to] > dist[v] + e.cost) {
				dist[e.to] = dist[v] + e.cost;
				pq.emplace(e.to, dist[e.to]);
			}
		}
	}
	return dist[t];
}
#line 3 "a.cpp"

int main() {
	inl(sx, sy, gx, gy);

	const int range = 50;
	VL x_val, y_val;
	x_val << step(sx - range, sx + range).to_a();
	x_val << step(gx - range, gx + range).to_a();
	y_val << step(sy - range, sy + range).to_a();
	y_val << step(gy - range, gy + range).to_a();
	x_val = x_val | Uniq;
	y_val = y_val | Uniq;

	const int MAX_V = sz(x_val) * sz(y_val) * 2;
	Graph g(MAX_V);
	auto to_i = [&](int x, int y, int time) {
		return lower_index(x_val, x) * sz(y_val) * 2 + lower_index(y_val, y) * 2 + time;
	};
	auto add_edge = [&](int x1, int y1, int t1, int x2, int y2, int t2, ll cost) {
		g[to_i(x1, y1, t1)].emplace_back(to_i(x2, y2, t2), cost);
	};
	auto add_edge2 = [&](int x1, int y1, int t1, int x2, int y2, int t2, ll cost) {
		add_edge(x1, y1, t1, x2, y2, t2, cost);
		add_edge(x2, y2, t2, x1, y1, t1, cost);
	};

	for (ll x : x_val) {
		for (ll y : y_val) {
			for (int f : {0, 1}) {
				add_edge2(x, y, f, x, y, 1 - f, 1);
			}
		}
	}
	for (auto [x1, x2] : x_val | EachConsPair) {
		for (ll y : y_val) {
			for (int f : {0, 1}) {
				if (x1 + 1 == x2) {
					if (x1 % 2 == 0 || f == 0) {
						add_edge2(x1, y, f, x2, y, 1 - f, 1);
					}
				} else {
					if (x1 % 2 == 1 && f == 0) {
						add_edge2(x1, y, f, x2, y, (f + x2 - x1) % 2, x2 - x1);
					}
				}
			}
		}
	}
	for (ll x : x_val) {
		for (auto [y1, y2] : y_val | EachConsPair) {
			for (int f : {0, 1}) {
				if (y1 + 1 == y2) {
					if (y1 % 2 == 0 || f == 1) {
						add_edge2(x, y1, f, x, y2, 1 - f, 1);
					}
				} else {
					if (y1 % 2 == 1 && f == 1) {
						add_edge2(x, y1, f, x, y2, (f + y2 - y1) % 2, y2 - y1);
					}
				}
			}
		}
	}

	ll ans1 = Dijkstra(g, to_i(sx, sy, 0), to_i(gx, gy, 0));
	ll ans2 = Dijkstra(g, to_i(sx, sy, 0), to_i(gx, gy, 1));
	out(min(ans1, ans2));
}
accuracy: 0.0425531914893617
time_ms: 10
memory_kb: 13020
final_rank: 19

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
#include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 2e18;
const int MOD = 1e9 + 7;

signed main() {
  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;

  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim) -> void {
    if (lim == 8) return;
    if (y == Gy && x == Gx) {
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if (x % 2 == 0 || t % 2 == 0) {
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if (x % 2 == 1 || t % 2 == 0) {
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if (y % 2 == 0 || t % 2 == 1) {
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if (y % 2 == 1 || t % 2 == 1) {
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    /* ----- 一気に行く ----- */
    if ((Gx - x) >= 0 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if ((x - Gx) >= 0 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if ((Gy - y) >= 0 && (y % 2 == t % 2)) {
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if ((y - Gy) >= 0 && (y % 2 != t % 2)) {
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }

    /* ----- 1つ手前まで行く ----- */
    if ((Gx - x) >= 1 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 1, t + (Gx - x) - 1, lim + 1);
    }
    if ((x - Gx) >= 1 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 1, t + (x - Gx) - 1, lim + 1);
    }
    if ((Gy - y) >= 1 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 1, x, t + (Gy - y) - 1, lim + 1);
    }
    if ((y - Gy) >= 1 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 1, x, t + (y - Gy) - 1, lim + 1);
    }

    /* ----- 2つ手前まで行く ----- */
    if ((Gx - x) >= 2 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 2, t + (Gx - x) - 2, lim + 1);
    }
    if ((x - Gx) >= 2 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 2, t + (x - Gx) - 2, lim + 1);
    }
    if ((Gy - y) >= 2 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 2, x, t + (Gy - y) - 2, lim + 1);
    }
    if ((y - Gy) >= 2 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 2, x, t + (y - Gy) - 2, lim + 1);
    }

    /* ----- 3つ手前まで行く ----- */
    if ((Gx - x) >= 3 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 3, t + (Gx - x) - 3, lim + 1);
    }
    if ((x - Gx) >= 3 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 3, t + (x - Gx) - 3, lim + 1);
    }
    if ((Gy - y) >= 3 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 3, x, t + (Gy - y) - 3, lim + 1);
    }
    if ((y - Gy) >= 3 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 3, x, t + (y - Gy) - 3, lim + 1);
    }

    // /* ----- ジグザグ ----- */
    // if ((Gx - x) > 0 && (Gy - y) > 0 && (x % 2 == 0 && t % 2 == 0)) {
    //   int dy = abs(Gy - y), dx = abs(Gx - x);
    //   int d = min(dy, dx);
    //   dfs(dfs, y + d, x + d, t + d * 2, lim + 1);
    // }
    // if ((Gx - x) < 0 && (Gy - y) > 0 && (x % 2 == 1 && t % 2 == 0)) {
    //   int dy = abs(Gy - y), dx = abs(Gx - x);
    //   int d = min(dy, dx);
    //   dfs(dfs, y + d, x - d, t + d * 2, lim + 1);
    // }
    // if ((Gx - x) < 0 && (Gy - y) < 0 && (x % 2 == 0 && t % 2 == 1)) {
    //   int dy = abs(Gy - y), dx = abs(Gx - x);
    //   int d = min(dy, dx);
    //   dfs(dfs, y - d, x - d, t + d * 2, lim + 1);
    // }
    // if ((Gx - x) > 0 && (Gy - y) < 0 && (x % 2 == 1 && t % 2 == 1)) {
    //   int dy = abs(Gy - y), dx = abs(Gx - x);
    //   int d = min(dy, dx);
    //   dfs(dfs, y - d, x + d, t + d * 2, lim + 1);
    // }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3432
final_rank: 2

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
#include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 2e18;
const int MOD = 1e9 + 7;

signed main() {
  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;

  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim) -> void {
    if (lim == 8) return;
    if (y == Gy && x == Gx) {
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if (x % 2 == 0 || t % 2 == 0) {
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if (x % 2 == 1 || t % 2 == 0) {
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if (y % 2 == 0 || t % 2 == 1) {
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if (y % 2 == 1 || t % 2 == 1) {
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    /* ----- 一気に行く ----- */
    if ((Gx - x) >= 0 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if ((x - Gx) >= 0 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if ((Gy - y) >= 0 && (y % 2 == t % 2)) {
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if ((y - Gy) >= 0 && (y % 2 != t % 2)) {
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }

    /* ----- 1つ手前まで行く ----- */
    if ((Gx - x) >= 1 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 1, t + (Gx - x) - 1, lim + 1);
    }
    if ((x - Gx) >= 1 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 1, t + (x - Gx) - 1, lim + 1);
    }
    if ((Gy - y) >= 1 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 1, x, t + (Gy - y) - 1, lim + 1);
    }
    if ((y - Gy) >= 1 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 1, x, t + (y - Gy) - 1, lim + 1);
    }

    /* ----- 2つ手前まで行く ----- */
    if ((Gx - x) >= 2 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 2, t + (Gx - x) - 2, lim + 1);
    }
    if ((x - Gx) >= 2 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 2, t + (x - Gx) - 2, lim + 1);
    }
    if ((Gy - y) >= 2 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 2, x, t + (Gy - y) - 2, lim + 1);
    }
    if ((y - Gy) >= 2 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 2, x, t + (y - Gy) - 2, lim + 1);
    }

    /* ----- 3つ手前まで行く ----- */
    if ((Gx - x) >= 3 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 3, t + (Gx - x) - 3, lim + 1);
    }
    if ((x - Gx) >= 3 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 3, t + (x - Gx) - 3, lim + 1);
    }
    if ((Gy - y) >= 3 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 3, x, t + (Gy - y) - 3, lim + 1);
    }
    if ((y - Gy) >= 3 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 3, x, t + (y - Gy) - 3, lim + 1);
    }

    /* ----- ジグザグ ----- */
    if ((Gx - x) > 0 && (Gy - y) > 0 && (x % 2 == 0 && t % 2 == 0)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x + d, t + d * 2, lim + 1);
    }
    if ((Gx - x) < 0 && (Gy - y) > 0 && (x % 2 == 1 && t % 2 == 0)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x - d, t + d * 2, lim + 1);
    }
    if ((Gx - x) < 0 && (Gy - y) < 0 && (x % 2 == 0 && t % 2 == 1)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x - d, t + d * 2, lim + 1);
    }
    if ((Gx - x) > 0 && (Gy - y) < 0 && (x % 2 == 1 && t % 2 == 1)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x + d, t + d * 2, lim + 1);
    }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3432
final_rank: 3

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
  #include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 1LL << 61;
const int MOD = 1e9 + 7;

signed main(){

  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;
  
  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim)->void{
    if(lim == 10) return;
    if(y == Gy && x == Gx){
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if(x % 2 == 0 || t % 2 == 0){
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if(x % 2 == 1 || t % 2 == 0){
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if(y % 2 == 0 || t % 2 == 1){
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if(y % 2 == 1 || t % 2 == 1){
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    if((Gx - x) >= 0 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if((x - Gx) >= 0 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if((Gy - y) >= 0 && (x % 2 != t % 2)){
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if((y - Gy) >= 0 && (x % 2 != t % 2)){
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 0.8723404255319149
time_ms: 40
memory_kb: 3432
final_rank: 7

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
  #include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 1LL << 61;
const int MOD = 1e9 + 7;

signed main(){

  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;
  
  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim)->void{
    if(lim == 8) return;
    if(y == Gy && x == Gx){
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if(x % 2 == 0 || t % 2 == 0){
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if(x % 2 == 1 || t % 2 == 0){
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if(y % 2 == 0 || t % 2 == 1){
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if(y % 2 == 1 || t % 2 == 1){
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    /* ----- 一気に行く ----- */
    if((Gx - x) >= 0 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if((x - Gx) >= 0 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if((Gy - y) >= 0 && (y % 2 == t % 2)){
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if((y - Gy) >= 0 && (y % 2 != t % 2)){
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }

    /* ----- 1つ手前まで行く ----- */
    if((Gx - x) >= 1 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-1, t + (Gx - x) - 1, lim + 1);
    }
    if((x - Gx) >= 1 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+1, t + (x - Gx) - 1, lim + 1);
    }
    if((Gy - y) >= 1 && (y % 2 == t % 2)){
      dfs(dfs, Gy-1, x, t + (Gy - y) - 1, lim + 1);
    }
    if((y - Gy) >= 1 && (y % 2 != t % 2)){
      dfs(dfs, Gy+1, x, t + (y - Gy) - 1, lim + 1);
    }

    /* ----- 2つ手前まで行く ----- */
    if((Gx - x) >= 2 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-2, t + (Gx - x) - 2, lim + 1);
    }
    if((x - Gx) >= 2 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+2, t + (x - Gx) - 2, lim + 1);
    }
    if((Gy - y) >= 2 && (y % 2 == t % 2)){
      dfs(dfs, Gy-2, x, t + (Gy - y) - 2, lim + 1);
    }
    if((y - Gy) >= 2 && (y % 2 != t % 2)){
      dfs(dfs, Gy+2, x, t + (y - Gy) - 2, lim + 1);
    }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 1
time_ms: 10
memory_kb: 3432
final_rank: 1

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
#include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 1LL << 61;
const int MOD = 1e9 + 7;

signed main() {
  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;

  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim) -> void {
    if (lim == 8) return;
    if (y == Gy && x == Gx) {
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if (x % 2 == 0 || t % 2 == 0) {
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if (x % 2 == 1 || t % 2 == 0) {
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if (y % 2 == 0 || t % 2 == 1) {
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if (y % 2 == 1 || t % 2 == 1) {
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    /* ----- 一気に行く ----- */
    if ((Gx - x) >= 0 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if ((x - Gx) >= 0 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if ((Gy - y) >= 0 && (y % 2 == t % 2)) {
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if ((y - Gy) >= 0 && (y % 2 != t % 2)) {
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }

    /* ----- 1つ手前まで行く ----- */
    if ((Gx - x) >= 1 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 1, t + (Gx - x) - 1, lim + 1);
    }
    if ((x - Gx) >= 1 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 1, t + (x - Gx) - 1, lim + 1);
    }
    if ((Gy - y) >= 1 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 1, x, t + (Gy - y) - 1, lim + 1);
    }
    if ((y - Gy) >= 1 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 1, x, t + (y - Gy) - 1, lim + 1);
    }

    /* ----- 2つ手前まで行く ----- */
    if ((Gx - x) >= 2 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 2, t + (Gx - x) - 2, lim + 1);
    }
    if ((x - Gx) >= 2 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 2, t + (x - Gx) - 2, lim + 1);
    }
    if ((Gy - y) >= 2 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 2, x, t + (Gy - y) - 2, lim + 1);
    }
    if ((y - Gy) >= 2 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 2, x, t + (y - Gy) - 2, lim + 1);
    }

    /* ----- 3つ手前まで行く ----- */
    if ((Gx - x) >= 3 && (x % 2 != t % 2)) {
      dfs(dfs, y, Gx - 3, t + (Gx - x) - 3, lim + 1);
    }
    if ((x - Gx) >= 3 && (x % 2 == t % 2)) {
      dfs(dfs, y, Gx + 3, t + (x - Gx) - 3, lim + 1);
    }
    if ((Gy - y) >= 3 && (y % 2 == t % 2)) {
      dfs(dfs, Gy - 3, x, t + (Gy - y) - 3, lim + 1);
    }
    if ((y - Gy) >= 3 && (y % 2 != t % 2)) {
      dfs(dfs, Gy + 3, x, t + (y - Gy) - 3, lim + 1);
    }

    /* ----- ジグザグ ----- */
    if ((Gx - x) > 0 && (Gy - y) > 0 && (x % 2 == 0 && t % 2 == 0)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x + d, t + d * 2, lim + 1);
    }
    if ((Gx - x) < 0 && (Gy - y) > 0 && (x % 2 == 1 && t % 2 == 0)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x - d, t + d * 2, lim + 1);
    }
    if ((Gx - x) < 0 && (Gy - y) < 0 && (x % 2 == 0 && t % 2 == 1)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x - d, t + d * 2, lim + 1);
    }
    if ((Gx - x) > 0 && (Gy - y) < 0 && (x % 2 == 1 && t % 2 == 1)) {
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x + d, t + d * 2, lim + 1);
    }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3436
final_rank: 4

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
  #include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 1LL << 60;
const int MOD = 1e9 + 7;

signed main(){

  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;
  
  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim)->void{
    if(lim == 8) return;
    if(y == Gy && x == Gx){
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if(x % 2 == 0 || t % 2 == 0){
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if(x % 2 == 1 || t % 2 == 0){
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if(y % 2 == 0 || t % 2 == 1){
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if(y % 2 == 1 || t % 2 == 1){
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    /* ----- 一気に行く ----- */
    if((Gx - x) >= 0 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if((x - Gx) >= 0 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if((Gy - y) >= 0 && (y % 2 == t % 2)){
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if((y - Gy) >= 0 && (y % 2 != t % 2)){
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }

    /* ----- 1つ手前まで行く ----- */
    if((Gx - x) >= 1 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-1, t + (Gx - x) - 1, lim + 1);
    }
    if((x - Gx) >= 1 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+1, t + (x - Gx) - 1, lim + 1);
    }
    if((Gy - y) >= 1 && (y % 2 == t % 2)){
      dfs(dfs, Gy-1, x, t + (Gy - y) - 1, lim + 1);
    }
    if((y - Gy) >= 1 && (y % 2 != t % 2)){
      dfs(dfs, Gy+1, x, t + (y - Gy) - 1, lim + 1);
    }

    /* ----- 2つ手前まで行く ----- */
    if((Gx - x) >= 2 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-2, t + (Gx - x) - 2, lim + 1);
    }
    if((x - Gx) >= 2 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+2, t + (x - Gx) - 2, lim + 1);
    }
    if((Gy - y) >= 2 && (y % 2 == t % 2)){
      dfs(dfs, Gy-2, x, t + (Gy - y) - 2, lim + 1);
    }
    if((y - Gy) >= 2 && (y % 2 != t % 2)){
      dfs(dfs, Gy+2, x, t + (y - Gy) - 2, lim + 1);
    }

    /* ----- 3つ手前まで行く ----- */
    if((Gx - x) >= 3 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-3, t + (Gx - x) - 3, lim + 1);
    }
    if((x - Gx) >= 3 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+3, t + (x - Gx) - 3, lim + 1);
    }
    if((Gy - y) >= 3 && (y % 2 == t % 2)){
      dfs(dfs, Gy-3, x, t + (Gy - y) - 3, lim + 1);
    }
    if((y - Gy) >= 3 && (y % 2 != t % 2)){
      dfs(dfs, Gy+3, x, t + (y - Gy) - 3, lim + 1);
    }

    /* ----- ジグザグ ----- */
    if((Gx - x) > 0 && (Gy - y) > 0 && (x % 2  == 0 && t % 2 == 0)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x + d, t + d * 2, lim + 1);
    }
    if((Gx - x) < 0 && (Gy - y) > 0 && (x % 2  == 1 && t % 2 == 0)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x - d, t + d * 2, lim + 1);
    }
    if((Gx - x) < 0 && (Gy - y) < 0 && (x % 2  == 0 && t % 2 == 1)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x - d, t + d * 2, lim + 1);
    }
    if((Gx - x) > 0 && (Gy - y) < 0 && (x % 2  == 1 && t % 2 == 1)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x + d, t + d * 2, lim + 1);
    }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 0.19148936170212766
time_ms: 50
memory_kb: 3432
final_rank: 15

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
  #include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 1LL << 60;
const int MOD = 1e9 + 7;

signed main(){

  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;
  
  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim)->void{
    if(lim == 8) return;
    if(y == Gy && x == Gx){
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if(x % 2 == 0 || t % 2 == 0){
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if(x % 2 == 1 || t % 2 == 0){
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if(y % 2 == 0 || t % 2 == 1){
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if(y % 2 == 1 || t % 2 == 1){
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    /* ----- 一気に行く ----- */
    if((Gx - x) >= 0 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if((x - Gx) >= 0 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if((Gy - y) >= 0 && (y % 2 == t % 2)){
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if((y - Gy) >= 0 && (y % 2 != t % 2)){
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }

    /* ----- 1つ手前まで行く ----- */
    if((Gx - x) >= 1 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-1, t + (Gx - x) - 1, lim + 1);
    }
    if((x - Gx) >= 1 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+1, t + (x - Gx) - 1, lim + 1);
    }
    if((Gy - y) >= 1 && (y % 2 == t % 2)){
      dfs(dfs, Gy-1, x, t + (Gy - y) - 1, lim + 1);
    }
    if((y - Gy) >= 1 && (y % 2 != t % 2)){
      dfs(dfs, Gy+1, x, t + (y - Gy) - 1, lim + 1);
    }

    /* ----- 2つ手前まで行く ----- */
    if((Gx - x) >= 2 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-2, t + (Gx - x) - 2, lim + 1);
    }
    if((x - Gx) >= 2 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+2, t + (x - Gx) - 2, lim + 1);
    }
    if((Gy - y) >= 2 && (y % 2 == t % 2)){
      dfs(dfs, Gy-2, x, t + (Gy - y) - 2, lim + 1);
    }
    if((y - Gy) >= 2 && (y % 2 != t % 2)){
      dfs(dfs, Gy+2, x, t + (y - Gy) - 2, lim + 1);
    }

    /* ----- 3つ手前まで行く ----- */
    if((Gx - x) >= 3 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-3, t + (Gx - x) - 3, lim + 1);
    }
    if((x - Gx) >= 3 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+3, t + (x - Gx) - 3, lim + 1);
    }
    if((Gy - y) >= 3 && (y % 2 == t % 2)){
      dfs(dfs, Gy-3, x, t + (Gy - y) - 3, lim + 1);
    }
    if((y - Gy) >= 3 && (y % 2 != t % 2)){
      dfs(dfs, Gy+3, x, t + (y - Gy) - 3, lim + 1);
    }

    /* ----- ジグザグ ----- */
    if((Gx - x) > 0 && (Gy - y) > 0 && !(x % 2 != t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x + d, t + d * 2, lim + 1);
    }
    if((Gx - x) < 0 && (Gy - y) > 0 && !(x % 2 == t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x - d, t + d * 2, lim + 1);
    }
    if((Gx - x) < 0 && (Gy - y) < 0 && !(y % 2 == t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x - d, t + d * 2, lim + 1);
    }
    if((Gx - x) > 0 && (Gy - y) < 0 && !(y % 2 != t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x + d, t + d * 2, lim + 1);
    }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 0.19148936170212766
time_ms: 60
memory_kb: 3464
final_rank: 17

code_snippet: #include <bits/stdc++.h>
using namespace std;
#ifdef _DEBUG
  #include "_DEBUG.hpp"
#endif
#define int long long
const int INF = 1LL << 60;
const int MOD = 1e9 + 7;

signed main(){

  int Sx, Sy, Gx, Gy;
  cin >> Sx >> Sy >> Gx >> Gy;
  
  int ans = INF;
  auto dfs = [&](auto&& dfs, int y, int x, int t, int lim)->void{
    if(lim == 8) return;
    if(y == Gy && x == Gx){
      ans = min(ans, t);
      return;
    }
    /* ----- x + 1 ----- */
    if(x % 2 == 0 || t % 2 == 0){
      dfs(dfs, y, x + 1, t + 1, lim + 1);
    }
    /* ----- x - 1 ----- */
    if(x % 2 == 1 || t % 2 == 0){
      dfs(dfs, y, x - 1, t + 1, lim + 1);
    }
    /* ----- y + 1 ----- */
    if(y % 2 == 0 || t % 2 == 1){
      dfs(dfs, y + 1, x, t + 1, lim + 1);
    }
    /* ----- y - 1 ----- */
    if(y % 2 == 1 || t % 2 == 1){
      dfs(dfs, y - 1, x, t + 1, lim + 1);
    }
    /* ----- + 0 ----- */
    dfs(dfs, y, x, t + 1, lim + 1);

    /* ----- 一気に行く ----- */
    if((Gx - x) >= 0 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx, t + (Gx - x), lim + 1);
    }
    if((x - Gx) >= 0 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx, t + (x - Gx), lim + 1);
    }
    if((Gy - y) >= 0 && (y % 2 == t % 2)){
      dfs(dfs, Gy, x, t + (Gy - y), lim + 1);
    }
    if((y - Gy) >= 0 && (y % 2 != t % 2)){
      dfs(dfs, Gy, x, t + (y - Gy), lim + 1);
    }

    /* ----- 1つ手前まで行く ----- */
    if((Gx - x) >= 1 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-1, t + (Gx - x) - 1, lim + 1);
    }
    if((x - Gx) >= 1 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+1, t + (x - Gx) - 1, lim + 1);
    }
    if((Gy - y) >= 1 && (y % 2 == t % 2)){
      dfs(dfs, Gy-1, x, t + (Gy - y) - 1, lim + 1);
    }
    if((y - Gy) >= 1 && (y % 2 != t % 2)){
      dfs(dfs, Gy+1, x, t + (y - Gy) - 1, lim + 1);
    }

    /* ----- 2つ手前まで行く ----- */
    if((Gx - x) >= 2 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-2, t + (Gx - x) - 2, lim + 1);
    }
    if((x - Gx) >= 2 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+2, t + (x - Gx) - 2, lim + 1);
    }
    if((Gy - y) >= 2 && (y % 2 == t % 2)){
      dfs(dfs, Gy-2, x, t + (Gy - y) - 2, lim + 1);
    }
    if((y - Gy) >= 2 && (y % 2 != t % 2)){
      dfs(dfs, Gy+2, x, t + (y - Gy) - 2, lim + 1);
    }

    /* ----- 3つ手前まで行く ----- */
    if((Gx - x) >= 3 && (x % 2 != t % 2)){
      dfs(dfs, y, Gx-3, t + (Gx - x) - 3, lim + 1);
    }
    if((x - Gx) >= 3 && (x % 2 == t % 2)){
      dfs(dfs, y, Gx+3, t + (x - Gx) - 3, lim + 1);
    }
    if((Gy - y) >= 3 && (y % 2 == t % 2)){
      dfs(dfs, Gy-3, x, t + (Gy - y) - 3, lim + 1);
    }
    if((y - Gy) >= 3 && (y % 2 != t % 2)){
      dfs(dfs, Gy+3, x, t + (y - Gy) - 3, lim + 1);
    }

    /* ----- ジグザグ ----- */
    if((Gx - x) > 0 && (Gy - y) > 0 && !(x % 2 != t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x + d, t + d * 2, lim + 1);
    }
    if((Gx - x) < 0 && (Gy - y) > 0 && !(x % 2 == t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y + d, x - d, t + d * 2, lim + 1);
    }
    if((Gx - x) < 0 && (Gy - y) < 0 && !(y % 2 == t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x - d, t + d * 2, lim + 1);
    }
    if((Gx - x) > 0 && (Gy - y) < 0 && !(y % 2 != t % 2)){
      int dy = abs(Gy - y), dx = abs(Gx - x);
      int d = min(dy, dx);
      dfs(dfs, y - d, x + d, t + d * 2, lim + 1);
    }
  };
  dfs(dfs, Sy, Sx, 0, 0);
  cout << ans << endl;

  return 0;
}
accuracy: 0.19148936170212766
time_ms: 60
memory_kb: 3432
final_rank: 16

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>

using namespace std;

#define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

struct state {
  int x, y, t;
  state(int x, int y, int t): x(x), y(y), t(t){}  
};

int Sx[5][2] = {{30, 31},
		{30, 31},
		{14, 15},
		{21, 20},
		{20, 21}};
int Sy[5][2] = {{40, 41},
		{40, 41},
		{24, 25},
		{31, 30},
		{30, 31}};
int Gx[5][2] = {{30, 31},
		{14, 15},
		{30, 31},
		{20, 21},
		{21, 20}};
int Gy[5][2] = {{40, 41},
		{24, 25},
		{40, 41},
		{30, 31},
		{31, 30}};

int pre_calc[5][5][2][2][2][2];

int  bfs(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return (t - (abs(sx-gx)+abs(sy-gy)));      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

int bfs2(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return t;      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);

  for ( int k = 0; k < 5; k++ ) {
    for ( int l = 0; l < 5; l++ ) {
      for ( int i = 0; i < (1<<4); i++ ) {
	int sx = Sx[k][(i>>0)&1];
	int sy = Sy[l][(i>>1)&1];
	int gx = Gx[k][(i>>2)&1];
	int gy = Gy[l][(i>>3)&1];	
	pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] = bfs(sx, sy, gx, gy);
	/*if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) {
	  cout << "aaa " << k << " " << l << " " << bfs(sx, sy, gx, gy) << " " << pre_calc[2][0][0][0][0][0] << endl;
	  
	  }*/
	/*if ( k == 2 && l == 0 && sx%2 == 0 && sy%2 == 0 && gx%2 == 0 && gy%2 == 0 ) {
	  cout << k << " " << l << " " << sx << " " << sy << " " << gx << " " << gy << endl;	  
	  cout << pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] << endl;	  	  
	  }*/	
      }
    }
  }

  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;

  /*cout << Sx[2][0] << " " << Sy[0][0] << " " << Gx[2][0] << " " << Gy[0][0] << endl;
    cout << pre_calc[2][0][0][0][0][0] << endl;  */

  int abs_x = min(sx, gx);
  int abs_y = min(sy, gy);
  int hiku_x = abs_x / 2 * 2;
  int hiku_y = abs_y / 2 * 2;
  sx -= hiku_x;
  sy -= hiku_y;
  gx -= hiku_x;
  gy -= hiku_y;
  // cerr << sx << " " << sy << endl;
  if ( sx < 50 && sy < 50 && gx < 50 && gy < 50 ) {
    cout << bfs2(sx, sy, gx, gy) << endl;    
  } else {  

    int ans = abs(sx-gx)+abs(sy-gy);    
    int k = 0, l = 0;
    if (sx == gx + 1) {
      k = 3;
    } else if (gx == sx + 1) {
      k = 4;
    } else {
      if ( sx > gx ) k = 1;
      if ( sx < gx ) k = 2;
    }

    
    if (sy == gy + 1) {
      l = 3;
    } else if (gy == sy + 1) {
      l = 4;
    } else {
      if ( sy > gy ) l = 1;
      if ( sy < gy ) l = 2;
    }

    ans += pre_calc[k][l][sx%2][sy%2][gx%2][gy%2];
    
    cout << ans << endl;
  }
  return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 3888
final_rank: 5

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>

using namespace std;

#define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

struct state {
  int x, y, t;
  state(int x, int y, int t): x(x), y(y), t(t){}  
};

int Sx[5][2] = {{30, 31},
		{30, 31},
		{14, 15},
		{21, 20},
		{20, 21}};
int Sy[5][2] = {{40, 41},
		{40, 41},
		{24, 25},
		{31, 30},
		{30, 31}};
int Gx[5][2] = {{30, 31},
		{14, 15},
		{30, 31},
		{20, 21},
		{21, 20}};
int Gy[5][2] = {{40, 41},
		{24, 25},
		{40, 41},
		{30, 31},
		{31, 30}};

int pre_calc[5][5][2][2][2][2];

int  bfs(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return (t - (abs(sx-gx)+abs(sy-gy)));      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

int bfs2(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return t;      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);

  for ( int k = 0; k < 5; k++ ) {
    for ( int l = 0; l < 5; l++ ) {
      for ( int i = 0; i < (1<<4); i++ ) {
	int sx = Sx[k][(i>>0)&1];
	int sy = Sy[l][(i>>1)&1];
	int gx = Gx[k][(i>>2)&1];
	int gy = Gy[l][(i>>3)&1];	
	pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] = bfs(sx, sy, gx, gy);
	/*if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) {
	  cout << "aaa " << k << " " << l << " " << bfs(sx, sy, gx, gy) << " " << pre_calc[2][0][0][0][0][0] << endl;
	  
	  }*/
	/*if ( k == 2 && l == 0 && sx%2 == 0 && sy%2 == 0 && gx%2 == 0 && gy%2 == 0 ) {
	  cout << k << " " << l << " " << sx << " " << sy << " " << gx << " " << gy << endl;	  
	  cout << pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] << endl;	  	  
	  }*/	
      }
    }
  }

  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;

  /*cout << Sx[2][0] << " " << Sy[0][0] << " " << Gx[2][0] << " " << Gy[0][0] << endl;
    cout << pre_calc[2][0][0][0][0][0] << endl;  */

  int abs_x = min(sx, gx); int abs_y = min(sy, gy);
  int hiku = min(abs_x, abs_y) / 2 * 2;
  sx -= hiku;
  sy -= hiku;
  gx -= hiku;
  gy -= hiku;
  // cerr << sx << " " << sy << endl;
  if ( sx < 50 && sy < 50 && gx < 50 && gy < 50 ) {
    cout << bfs2(sx, sy, gx, gy) << endl;    
  } else {  

    int ans = abs(sx-gx)+abs(sy-gy);    
    int k = 0, l = 0;
    if (sx == gx + 1) {
      k = 3;
    } else if (gx == sx + 1) {
      k = 4;
    } else {
      if ( sx > gx ) k = 1;
      if ( sx < gx ) k = 2;
    }

    
    if (sy == gy + 1) {
      l = 3;
    } else if (gy == sy + 1) {
      l = 4;
    } else {
      if ( sy > gy ) l = 1;
      if ( sy < gy ) l = 2;
    }

    ans += pre_calc[k][l][sx%2][sy%2][gx%2][gy%2];
    
    cout << ans << endl;
  }
  return 0;
}
accuracy: 0.6808510638297872
time_ms: 100
memory_kb: 3856
final_rank: 10

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>

using namespace std;

#define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

struct state {
  int x, y, t;
  state(int x, int y, int t): x(x), y(y), t(t){}  
};

int Sx[5][2] = {{30, 31},
		{30, 31},
		{14, 15},
		{21, 20},
		{20, 21}};
int Sy[5][2] = {{40, 41},
		{40, 41},
		{24, 25},
		{31, 30},
		{30, 31}};
int Gx[5][2] = {{30, 31},
		{14, 15},
		{30, 31},
		{20, 21},
		{21, 20}};
int Gy[5][2] = {{40, 41},
		{24, 25},
		{40, 41},
		{30, 31},
		{31, 30}};

int pre_calc[5][5][2][2][2][2];

int  bfs(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return (t - (abs(sx-gx)+abs(sy-gy)));      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

int bfs2(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return t;      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);

  for ( int k = 0; k < 5; k++ ) {
    for ( int l = 0; l < 5; l++ ) {
      for ( int i = 0; i < (1<<4); i++ ) {
	int sx = Sx[k][(i>>0)&1];
	int sy = Sy[l][(i>>1)&1];
	int gx = Gx[k][(i>>2)&1];
	int gy = Gy[l][(i>>3)&1];	
	pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] = bfs(sx, sy, gx, gy);
	/*if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) {
	  cout << "aaa " << k << " " << l << " " << bfs(sx, sy, gx, gy) << " " << pre_calc[2][0][0][0][0][0] << endl;
	  
	  }*/
	/*if ( k == 2 && l == 0 && sx%2 == 0 && sy%2 == 0 && gx%2 == 0 && gy%2 == 0 ) {
	  cout << k << " " << l << " " << sx << " " << sy << " " << gx << " " << gy << endl;	  
	  cout << pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] << endl;	  	  
	  }*/	
      }
    }
  }

  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;

  /*cout << Sx[2][0] << " " << Sy[0][0] << " " << Gx[2][0] << " " << Gy[0][0] << endl;
    cout << pre_calc[2][0][0][0][0][0] << endl;  */

  int abs_x = abs(sx-gx), abs_y = abs(sy-gy);
  int hiku = min(abs_x, abs_y) / 2 * 2;
  sx -= hiku;
  sy -= hiku;
  gx -= hiku;
  gy -= hiku;
  if ( sx < 50 && sy < 50 && gx < 50 && gy < 50 ) {
    cout << bfs2(sx, sy, gx, gy) << endl;    
  } else {  

    int ans = abs(sx-gx)+abs(sy-gy);    
    int k = 0, l = 0;
    if (sx == gx + 1) {
      k = 3;
    } else if (gx == sx + 1) {
      k = 4;
    } else {
      if ( sx > gx ) k = 1;
      if ( sx < gx ) k = 2;
    }

    
    if (sy == gy + 1) {
      l = 3;
    } else if (gy == sy + 1) {
      l = 4;
    } else {
      if ( sy > gy ) l = 1;
      if ( sy < gy ) l = 2;
    }

    ans += pre_calc[k][l][sx%2][sy%2][gx%2][gy%2];
    
    cout << ans << endl;
  }
  return 0;
}
accuracy: 0.6808510638297872
time_ms: 80
memory_kb: 3856
final_rank: 8

code_snippet: #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <functional>
#include <bitset>

using namespace std;

#define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

struct state {
  int x, y, t;
  state(int x, int y, int t): x(x), y(y), t(t){}  
};

int Sx[5][2] = {{30, 31},
		{30, 31},
		{14, 15},
		{21, 20},
		{20, 21}};
int Sy[5][2] = {{40, 41},
		{40, 41},
		{24, 25},
		{31, 30},
		{30, 31}};
int Gx[5][2] = {{30, 31},
		{14, 15},
		{30, 31},
		{20, 21},
		{21, 20}};
int Gy[5][2] = {{40, 41},
		{24, 25},
		{40, 41},
		{31, 30},
		{30, 31}};

int pre_calc[5][5][2][2][2][2];

int  bfs(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return (t - (abs(sx-gx)+abs(sy-gy)));      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

int bfs2(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return t;      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);

  for ( int k = 0; k < 5; k++ ) {
    for ( int l = 0; l < 5; l++ ) {
      for ( int i = 0; i < (1<<4); i++ ) {
	int sx = Sx[k][(i>>0)&1];
	int sy = Sy[l][(i>>1)&1];
	int gx = Gx[k][(i>>2)&1];
	int gy = Gy[l][(i>>3)&1];	
	pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] = bfs(sx, sy, gx, gy);
	/*if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) {
	  cout << "aaa " << k << " " << l << " " << bfs(sx, sy, gx, gy) << " " << pre_calc[2][0][0][0][0][0] << endl;
	  
	  }*/
	/*if ( k == 2 && l == 0 && sx%2 == 0 && sy%2 == 0 && gx%2 == 0 && gy%2 == 0 ) {
	  cout << k << " " << l << " " << sx << " " << sy << " " << gx << " " << gy << endl;	  
	  cout << pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] << endl;	  	  
	  }*/	
      }
    }
  }

  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;

  /*cout << Sx[2][0] << " " << Sy[0][0] << " " << Gx[2][0] << " " << Gy[0][0] << endl;
    cout << pre_calc[2][0][0][0][0][0] << endl;  */

  int abs_x = abs(sx-gx), abs_y = abs(sy-gy);
  int hiku = min(abs_x, abs_y) / 2 * 2;
  sx -= hiku;
  sy -= hiku;
  gx -= hiku;
  gy -= hiku;
  if ( sx < 50 && sy < 50 && gx < 50 && gy < 50 ) {
    cout << bfs2(sx, sy, gx, gy) << endl;    
  } else {  

    int ans = abs(sx-gx)+abs(sy-gy);    
    int k = 0, l = 0;
    if (sx == gx + 1) {
      k = 3;
    } else if (gx == sx + 1) {
      k = 4;
    } else {
      if ( sx > gx ) k = 1;
      if ( sx < gx ) k = 2;
    }

    
    if (sy == gy + 1) {
      l = 3;
    } else if (gy == sy + 1) {
      l = 4;
    } else {
      if ( sy > gy ) l = 1;
      if ( sy < gy ) l = 2;
    }

    ans += pre_calc[k][l][sx%2][sy%2][gx%2][gy%2];
    
    cout << ans << endl;
  }
  return 0;
}
accuracy: 0.6808510638297872
time_ms: 90
memory_kb: 3856
final_rank: 9

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

#define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

struct state {
  int x, y, t;
  state(int x, int y, int t): x(x), y(y), t(t){}  
};

int Sx[3][2] = {{30, 31},
		{30, 31},
		{14, 15}};
int Sy[3][2] = {{40, 41},
		{40, 41},
		{24, 25}};
int Gx[3][2] = {{30, 31},
		{14, 15},
		{30, 31}};
int Gy[3][2] = {{40, 41},
		{24, 25},
		{40, 41}};

int pre_calc[3][3][2][2][2][2];

int  bfs(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return (t - (abs(sx-gx)+abs(sy-gy)));      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

int bfs2(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return t;      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  for ( int k = 0; k < 3; k++ ) {
    for ( int l = 0; l < 3; l++ ) {
      for ( int i = 0; i < (1<<4); i++ ) {
	int sx = Sx[k][(i>>0)&1];
	int sy = Sy[l][(i>>1)&1];
	int gx = Gx[k][(i>>2)&1];
	int gy = Gy[l][(i>>3)&1];	
	pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] = bfs(sx, sy, gx, gy);
	/*if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) {
	  cout << "aaa " << k << " " << l << " " << bfs(sx, sy, gx, gy) << " " << pre_calc[2][0][0][0][0][0] << endl;
	  
	  }*/
	/*if ( k == 2 && l == 0 && sx%2 == 0 && sy%2 == 0 && gx%2 == 0 && gy%2 == 0 ) {
	  cout << k << " " << l << " " << sx << " " << sy << " " << gx << " " << gy << endl;	  
	  cout << pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] << endl;	  	  
	  }*/	
      }
    }
  }

  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;

  /*cout << Sx[2][0] << " " << Sy[0][0] << " " << Gx[2][0] << " " << Gy[0][0] << endl;
    cout << pre_calc[2][0][0][0][0][0] << endl;  */

  int abs_x = abs(sx-gx), abs_y = abs(sy-gy);
  int hiku = min(abs_x, abs_y) / 2 * 2;
  sx -= hiku;
  sy -= hiku;
  gx -= hiku;
  gy -= hiku;
  if ( sx < 50 && sy < 50 && gx < 50 && gy < 50 ) {
    cout << bfs2(sx, sy, gx, gy) << endl;    
  } else {  

    int ans = abs(sx-gx)+abs(sy-gy);    
    int k = 0, l = 0;
    if ( sx > gx ) k = 1;
    if ( sx < gx ) k = 2;
    if ( sy > gy ) l = 1;
    if ( sy < gy ) l = 2;
    ans += pre_calc[k][l][sx%2][sy%2][gx%2][gy%2];
    
    cout << ans << endl;
  }
  return 0;
}
accuracy: 0.6170212765957447
time_ms: 50
memory_kb: 3892
final_rank: 12

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

#define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

struct state {
  int x, y, t;
  state(int x, int y, int t): x(x), y(y), t(t){}  
};

int Sx[3][2] = {{30, 31},
		{30, 31},
		{14, 15}};
int Sy[3][2] = {{40, 41},
		{40, 41},
		{24, 25}};
int Gx[3][2] = {{30, 31},
		{14, 15},
		{30, 31}};
int Gy[3][2] = {{40, 41},
		{24, 25},
		{40, 41}};

int pre_calc[3][3][2][2][2][2];

int  bfs(int sx, int sy, int gx, int gy) {
  bool used[50][50][100];
  fill_n(**used, 50*50*100, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();
 
    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return (t - (abs(sx-gx)+abs(sy-gy)));      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 100 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  for ( int k = 0; k < 3; k++ ) {
    for ( int l = 0; l < 3; l++ ) {
      for ( int i = 0; i < (1<<4); i++ ) {
	int sx = Sx[k][(i>>0)&1];
	int sy = Sy[l][(i>>1)&1];
	int gx = Gx[k][(i>>2)&1];
	int gy = Gy[l][(i>>3)&1];	
	pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] = bfs(sx, sy, gx, gy);
	/*if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) {
	  cout << "aaa " << k << " " << l << " " << bfs(sx, sy, gx, gy) << " " << pre_calc[2][0][0][0][0][0] << endl;
	  
	  }*/
	/*if ( k == 2 && l == 0 && sx%2 == 0 && sy%2 == 0 && gx%2 == 0 && gy%2 == 0 ) {
	  cout << k << " " << l << " " << sx << " " << sy << " " << gx << " " << gy << endl;	  
	  cout << pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] << endl;	  	  
	  }*/	
      }
    }
  }

  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;

  /*cout << Sx[2][0] << " " << Sy[0][0] << " " << Gx[2][0] << " " << Gy[0][0] << endl;
    cout << pre_calc[2][0][0][0][0][0] << endl;  */  

  int ans = abs(sx-gx)+abs(sy-gy);    
  int k = 0, l = 0;
  if ( sx > gx ) k = 1;
  if ( sx < gx ) k = 2;
  if ( sy > gy ) l = 1;
  if ( sy < gy ) l = 2;
  ans += pre_calc[k][l][sx%2][sy%2][gx%2][gy%2];

  cout << ans << endl;

  return 0;
}
accuracy: 0.6170212765957447
time_ms: 60
memory_kb: 3876
final_rank: 13

code_snippet: #pragma target("avx")
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef unordered_map<ll, ll> U_MAP;
typedef priority_queue<ll> pq;
typedef priority_queue<ll, vector<ll>, greater<ll>> rpq;
constexpr ll INF = 1e9, MOD = 1e9 + 7, ohara = 1e6 + 10;
constexpr ll LINF = 1e18;

#define rep(i, n) for (ll(i) = 0; (i) < (int)(n); (i)++)
#define rrep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrrep(i, a, b) for (ll i = (a); i >= (b); i--)
#define all(v) (v).begin(), (v).end()
#define Size(n) (n).size()
#define Cout(x) cout << (x) << endl
#define doublecout(a) cout << fixed << setprecision(15) << a << endl;
#define fi first
#define se second
#define m_p make_pair
#define p_b push_back
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto& x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

//------ Believe yourself as a genius!!!!!! ------

int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
// int dy[]={-1,0,1,-1,1,-1,0,1};int dx[]={-1,-1,-1,0,0,1,1,1};
string alph("abcdefghijklmnopqrstuvwxyz"), s;
ll n, cnt, ans, a, b, c, d, tmp, m, h, w, x, y, sum, k, q, sx, sy, gx, gy;
ll dat[210][210][210];

int main(void) {
  cin.tie(0);
  cout.tie(0);
  ios::sync_with_stdio(false);

  cin >> sx >> sy >> gx >> gy;
  if (abs(gy - sy) + abs(gx - sx) <= 50) {
    tmp = abs(sx - gx);
    if (min(sx, gx) % 2 == 1) {
      if (sx < gx) {
        sx = 1;
        gx = sx + tmp;
      } else {
        gx = 1;
        sx = gx + tmp;
      }
    } else {
      if (sx < gx) {
        sx = 0;
        gx = sx + tmp;
      } else {
        gx = 0;
        sx = gx + tmp;
      }
    }
    tmp = abs(sy - gy);
    if (min(sy, gy) % 2 == 1) {
      if (sy < gy) {
        sy = 1;
        gy = sy + tmp;
      } else {
        gy = 1;
        sy = gy + tmp;
      }
    } else {
      if (sy < gy) {
        sy = 0;
        gy = sy + tmp;
      } else {
        gy = 0;
        sy = gy + tmp;
      }
    }
    priority_queue<pair<P, P>, vector<pair<P, P>>, greater<pair<P, P>>> que;
    que.push({{0, 0}, {sy, sx}});
    ans = INF;
    rep(i, 200) rep(j, 200) rep(k, 200) dat[i][j][k] = INF;
    dat[0][sy][sx] = 0;

    while (1) {
      if (que.empty()) break;
      pair<P, P> X;
      X = que.top();
      que.pop();

      int time = X.fi.se, nowy = X.se.fi, nowx = X.se.se, cost = X.fi.fi;
      // cout << time << " " << nowx << " " << nowy << "\n";

      if (dat[time][nowy][nowx] < cost) continue;

      if (time % 2 == 0) {
        if (dat[time + 1][nowy][nowx - 1] > cost + 1 && nowx - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy, nowx - 1}});
          dat[time + 1][nowy][nowx - 1] = cost + 1;
        }
        if (dat[time + 1][nowy][nowx + 1] > cost + 1 && nowx + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy, nowx + 1}});
          dat[time + 1][nowy][nowx + 1] = cost + 1;
        }
      } else {
        if (dat[time + 1][nowy - 1][nowx] > cost + 1 && nowy - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy - 1, nowx}});
          dat[time + 1][nowy - 1][nowx] = cost + 1;
        }
        if (dat[time + 1][nowy + 1][nowx] > cost + 1 && nowy + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy + 1, nowx}});
          dat[time + 1][nowy + 1][nowx] = cost + 1;
        }
      }
      if (nowx % 2 == 0) {
        if (dat[time + 1][nowy][nowx + 1] > cost + 1 && nowx + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy, nowx + 1}});
          dat[time + 1][nowy][nowx + 1] = cost + 1;
        }
      } else {
        if (dat[time + 1][nowy][nowx - 1] > cost + 1 && nowx - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy, nowx - 1}});
          dat[time + 1][nowy][nowx - 1] = cost + 1;
        }
      }
      if (nowy % 2 == 0) {
        if (dat[time + 1][nowy + 1][nowx] > cost + 1 && nowy + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy + 1, nowx}});
          dat[time + 1][nowy + 1][nowx] = cost + 1;
        }
      } else {
        if (dat[time + 1][nowy - 1][nowx] > cost + 1 && nowy - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy - 1, nowx}});
          dat[time + 1][nowy - 1][nowx] = cost + 1;
        }
      }
      if (dat[time + 1][nowy][nowx] > cost + 1) {
        que.push({{cost + 1, time + 1}, {nowy, nowx}});
        dat[time + 1][nowy][nowx] = cost + 1;
      }
    }
    rep(i, 200) ans = min(ans, dat[i][gy][gx]);
    Cout(ans);
    return 0;
  }
  if (sx == gx && sy == gy) {
    Cout(0);
  } else if (sx < gx && sy < gy) {
    Cout(abs(gy - sy) + abs(gx - sx));
  } else if (sx < gx && sy > gy) {
    Cout(abs(gy - sy) + abs(gx - sx));
  } else if (sx > gx && sy < gy) {
    Cout(abs(gy - sy) + abs(gx - sx));
  } else if (sx > gx && sy > gy) {
    Cout(abs(gy - sy) + abs(gx - sx));  //さぼった
  } else {
    if (sx == gx) {
      if (sy < gy) {
        if (sy % 2 == 1)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      } else {
        if (sy % 2 == 0)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      }
    } else {
      if (sx < gx) {
        if (sx % 2 == 0)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      } else {
        if (sx % 2 == 1)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      }
    }
  }
  return 0;
}
accuracy: 1
time_ms: 180
memory_kb: 70656
final_rank: 6

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

#define int long long
#define REP(i, n) for ( int i = 0; i < (n); i++ )

struct state {
  int x, y, t;
  state(int x, int y, int t): x(x), y(y), t(t){}  
};

int Sx[3][2] = {{30, 31},
		{30, 31},
		{14, 15}};
int Sy[3][2] = {{40, 41},
		{40, 41},
		{24, 25}};
int Gx[3][2] = {{30, 31},
		{14, 15},
		{30, 31}};
int Gy[3][2] = {{40, 41},
		{24, 25},
		{40, 41}};

int pre_calc[3][3][2][2][2][2];

int  bfs(int sx, int sy, int gx, int gy) {
  bool used[50][50][50];
  fill_n(**used, 50*50*50, false);    
  queue<state> Q;
  Q.push(state(sx, sy, 0));
  while ( !Q.empty() ) {
    int x = Q.front().x;      
    int y = Q.front().y;
    int t = Q.front().t;
    Q.pop();

    if ( x == gx && y == gy ) {
      // if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) cout << t << " " << (abs(sx-gx)+abs(sy-gy)) << endl;      
      return (t - (abs(sx-gx)+abs(sy-gy)));      
      break;	
    }

    if ( x < 0 || y < 0 || t < 0 || x >= 50 || y >= 50 || t >= 50 ) continue;      
      
    if ( used[y][x][t] ) continue;
    used[y][x][t] = true;      

    if ( x%2 == 0 || t%2 == 0 ) {
      Q.push(state(x+1, y, t+1));	
    }
    if ( x%2 == 1 || t%2 == 0 ) {
      Q.push(state(x-1, y, t+1));	
    }
    if ( y%2 == 0 || t%2 == 1 ) {
      Q.push(state(x, y+1, t+1));	
    }
    if ( y%2 == 1 || t%2 == 1 ) {
      Q.push(state(x, y-1, t+1));	
    }
    Q.push(state(x, y, t+1));      
  }

  return 0;  
}

signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(0);
  cout << fixed << setprecision(12);

  for ( int k = 0; k < 3; k++ ) {
    for ( int l = 0; l < 3; l++ ) {
      for ( int i = 0; i < (1<<4); i++ ) {
	int sx = Sx[k][(i>>0)&1];
	int sy = Sy[l][(i>>1)&1];
	int gx = Gx[k][(i>>2)&1];
	int gy = Gy[l][(i>>3)&1];	
	pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] = bfs(sx, sy, gx, gy);
	/*if ( sx == 14 && sy == 40 && gx == 30 && gy == 40 ) {
	  cout << "aaa " << k << " " << l << " " << bfs(sx, sy, gx, gy) << " " << pre_calc[2][0][0][0][0][0] << endl;
	  
	  }*/
	/*if ( k == 2 && l == 0 && sx%2 == 0 && sy%2 == 0 && gx%2 == 0 && gy%2 == 0 ) {
	  cout << k << " " << l << " " << sx << " " << sy << " " << gx << " " << gy << endl;	  
	  cout << pre_calc[k][l][sx%2][sy%2][gx%2][gy%2] << endl;	  	  
	  }*/	
      }
    }
  }

  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;

  /*cout << Sx[2][0] << " " << Sy[0][0] << " " << Gx[2][0] << " " << Gy[0][0] << endl;
    cout << pre_calc[2][0][0][0][0][0] << endl;  */  

  int ans = abs(sx-gx)+abs(sy-gy);    
  int k = 0, l = 0;
  if ( sx > gx ) k = 1;
  if ( sx < gx ) k = 2;
  if ( sy > gy ) l = 1;
  if ( sy < gy ) l = 2;
  ans += pre_calc[k][l][sx%2][sy%2][gx%2][gy%2];

  cout << ans << endl;

  return 0;
}
accuracy: 0.6170212765957447
time_ms: 50
memory_kb: 3756
final_rank: 11

code_snippet: #pragma target("avx")
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef unordered_map<ll, ll> U_MAP;
typedef priority_queue<ll> pq;
typedef priority_queue<ll, vector<ll>, greater<ll>> rpq;
constexpr ll INF = 1e9, MOD = 1e9 + 7, ohara = 1e6 + 10;
constexpr ll LINF = 1e18;

#define rep(i, n) for (ll(i) = 0; (i) < (int)(n); (i)++)
#define rrep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrrep(i, a, b) for (ll i = (a); i >= (b); i--)
#define all(v) (v).begin(), (v).end()
#define Size(n) (n).size()
#define Cout(x) cout << (x) << endl
#define doublecout(a) cout << fixed << setprecision(15) << a << endl;
#define fi first
#define se second
#define m_p make_pair
#define p_b push_back
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto& x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

//------ Believe yourself as a genius!!!!!! ------

int dy[] = {1, 0, -1, 0};
int dx[] = {0, 1, 0, -1};
// int dy[]={-1,0,1,-1,1,-1,0,1};int dx[]={-1,-1,-1,0,0,1,1,1};
string alph("abcdefghijklmnopqrstuvwxyz"), s;
ll n, cnt, ans, a, b, c, d, tmp, m, h, w, x, y, sum, k, q, sx, sy, gx, gy;
ll dat[210][210][210];

int main(void) {
  cin.tie(0);
  cout.tie(0);
  ios::sync_with_stdio(false);

  cin >> sx >> sy >> gx >> gy;
  if (abs(gy - sy) + abs(gx - sx) <= 50) {
    tmp = abs(sx - gx);
    if (min(sx, gx) % 2 == 1) {
      if (sx < gx) {
        sx = 1;
        gx = sx + tmp;
      } else {
        gx = 1;
        sx = gx + tmp;
      }
    } else {
      if (sx < gx) {
        sx = 0;
        gx = sx + tmp;
      } else {
        gx = 0;
        sx = gx + tmp;
      }
    }
    tmp = abs(sy - gy);
    if (min(sy, gy) % 2 == 1) {
      if (sy < gy) {
        sy = 1;
        gy = sy + tmp;
      } else {
        gy = 1;
        sy = gy + tmp;
      }
    } else {
      if (sy < gy) {
        sy = 0;
        gy = sy + tmp;
      } else {
        gy = 0;
        sy = gy + tmp;
      }
    }
    priority_queue<pair<P, P>, vector<pair<P, P>>, greater<pair<P, P>>> que;
    que.push({{0, 0}, {sy, sx}});
    ans = INF;
    rep(i, 200) rep(j, 200) rep(k, 200) dat[i][j][k] = INF;
    dat[0][sy][sx] = 0;

    while (1) {
      if (que.empty()) break;
      pair<P, P> X;
      X = que.top();
      que.pop();

      int time = X.fi.se, nowy = X.se.fi, nowx = X.se.se, cost = X.fi.fi;
      // cout << time << " " << nowx << " " << nowy << "\n";

      if (dat[time][nowy][nowx] < cost) continue;

      if (time % 2 == 0) {
        if (dat[time + 1][nowy][nowx - 1] > cost + 1 && nowx - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy, nowx - 1}});
          dat[time + 1][nowy][nowx - 1] = cost + 1;
        }
        if (dat[time + 1][nowy][nowx + 1] > cost + 1 && nowx + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy, nowx + 1}});
          dat[time + 1][nowy][nowx + 1] = cost + 1;
        }
      } else {
        if (dat[time + 1][nowy - 1][nowx] > cost + 1 && nowy - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy - 1, nowx}});
          dat[time + 1][nowy - 1][nowx] = cost + 1;
        }
        if (dat[time + 1][nowy + 1][nowx] > cost + 1 && nowy + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy + 1, nowx}});
          dat[time + 1][nowy + 1][nowx] = cost + 1;
        }
      }
      if (nowx % 2 == 0) {
        if (dat[time + 1][nowy][nowx + 1] > cost + 1 && nowx + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy, nowx + 1}});
          dat[time + 1][nowy][nowx + 1] = cost + 1;
        }
      } else {
        if (dat[time + 1][nowy][nowx - 1] > cost + 1 && nowx - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy, nowx - 1}});
          dat[time + 1][nowy][nowx - 1] = cost + 1;
        }
      }
      if (nowy % 2 == 0) {
        if (dat[time + 1][nowy + 1][nowx] > cost + 1 && nowy + 1 < 200) {
          que.push({{cost + 1, time + 1}, {nowy + 1, nowx}});
          dat[time + 1][nowy + 1][nowx] = cost + 1;
        }
      } else {
        if (dat[time + 1][nowy - 1][nowx] > cost + 1 && nowy - 1 >= 0) {
          que.push({{cost + 1, time + 1}, {nowy - 1, nowx}});
          dat[time + 1][nowy - 1][nowx] = cost + 1;
        }
      }
      if (dat[time + 1][nowy][nowx] > cost + 1) {
        que.push({{cost + 1, time + 1}, {nowy, nowx}});
        dat[time + 1][nowy][nowx] = cost + 1;
      }
    }
    rep(i, 200) ans = min(ans, dat[i][gy][gx]);
    Cout(ans);
    return 0;
  }
  if (sx == gx && sy == gy) {
    Cout(0);
  } else if (sx < gx && sy < gy) {
    Cout(abs(gy - sy) + abs(gx - sx));
  } else if (sx < gx && sy > gy) {
    Cout(abs(gy - sy) + abs(gx - sx));
  } else if (sx > gx && sy < gy) {
    Cout(abs(gy - sy) + abs(gx - sx));
  } else if (sx < gx && sy < gy) {
    Cout(abs(gy - sy) + abs(gx - sx));  //さぼった
  } else {
    if (sx == gx) {
      if (sy < gy) {
        if (sy % 2 == 1)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      } else {
        if (sy % 2 == 0)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      }
    } else {
      if (sx < gx) {
        if (sx % 2 == 0)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      } else {
        if (sx % 2 == 1)
          Cout(abs(gy - sy) + abs(gx - sx) + 1);
        else
          Cout(abs(gy - sy) + abs(gx - sx));
      }
    }
  }
  return 0;
}
accuracy: 0.2765957446808511
time_ms: 170
memory_kb: 70352
final_rank: 14