fork download
copy 
  1. // #pragma GCC optimize("O3", "unroll-loops")
  2. // #pragma GCC target("avx2", "bmi", "bmi2", "lzcnt", "popcnt")
  3.  
  4. #include <bits/stdc++.h>
  5. #define ldb long double
  6. //#define double ldb
  7. #define db double
  8. #define unomap unordered_map
  9. #define unoset unordered_set
  10. #define endl '\n'
  11. #define str string
  12. #define strstr stringstream
  13. #define sz(a) (int)a.size()
  14. //#define ll long long
  15. // #define int ll
  16. #define pii pair <int, int>
  17. #define pll pair <ll, ll>
  18. #define Unique(a) a.resize(unique(all(a)) - a.begin())
  19. #define ull unsigned long long
  20. #define fir first
  21. #define sec second
  22. #define idc cin.ignore()
  23. #define lb lower_bound
  24. #define ub upper_bound
  25. #define all(s) s.begin(), s.end()
  26. #define rall(s) s.rbegin(), s.rend()
  27. #define rev reverse
  28. #define gcd __gcd
  29. #define pushb push_back
  30. #define popb pop_back
  31. #define pushf push_front
  32. #define popf pop_front
  33. #define emp emplace
  34. #define empb emplace_back
  35. #define empf emplace_front
  36. #define mul2x(a, x) a << x
  37. #define div2x(a, x) a >> x
  38. #define lcm(a, b) (a / __gcd(a, b) * b)
  39. #define log_base(x, base) log(x) / log(base)
  40. #define debug cerr<<"No errors!",exit(0);
  41. #define forw(i, a, b)  for (int i = a; i <= b; ++i)
  42. #define forw2(i, a, b) for (ll i = a; i <= b; ++i)
  43. #define fors(i, a, b)  for (int i = a; i >= b; --i)
  44. #define fors2(i, a, b) for (ll i = a; i >= b; --i)
  45. #define pqueue priority_queue
  46. #define sqrt sqrtl
  47. #define i128 __int128
  48. #define popcount __builtin_popcountll
  49. #define BIT(x, i) (((x) >> (i)) & 1)
  50. #define MASK(x) ((1LL) << (x))
  51. #define want_digit(x) cout << fixed << setprecision(x);
  52. #define excuting_time 1000.0 * clock() / CLOCKS_PER_SEC
  53. #define mapa make_pair
  54. using namespace std;
  55. const int MOD = 1e9 + 7; // 998244353
  56. const int inf = 1e9;
  57. //const ll INF = 1e18; // MASK(63) - 1
  58. const int limN = 2e5 + 5;
  59.  
  60. //mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
  61. //inline ll random(const ll &L, const ll &R) {
  62. //    return uniform_int_distribution<ll> (L, R) (rng);
  63. //}
  64.  
  65. /* -------~~~~~~===== END OF TEMPLATE =====~~~~~~------- */
  66.  
  67. namespace BigNum {
  68.     typedef long long ll;
  69.     typedef long double ld;
  70.     typedef complex<ld> pt;
  71.     const int32_t MOD = 1e9 + 7;
  72.     const ld PI = acos(-1.L);
  73.  
  74.     template<class T> struct cplx {
  75.         T x, y;
  76.         cplx() {
  77.             x = 0.0;
  78.             y = 0.0;
  79.         }
  80.         cplx(T nx, T ny = 0) {
  81.             x = nx;
  82.             y = ny;
  83.         }
  84.         cplx operator+(const cplx &c) const {
  85.             return {x + c.x, y + c.y};
  86.         }
  87.         cplx operator-(const cplx &c) const {
  88.             return {x - c.x, y - c.y};
  89.         }
  90.         cplx operator*(const cplx &c) const {
  91.             return {x*c.x - y * c.y, x*c.y + y * c.x};
  92.         }
  93.         cplx& operator*=(const cplx &c) {
  94.             return *this = {x*c.x - y * c.y, x*c.y + y * c.x};
  95.         }
  96.         inline T real() const {
  97.             return x;
  98.         }
  99.         inline T imag() const {
  100.             return y;
  101.         }
  102.         // Only supports right scalar multiplication like p*c
  103.         template<class U> cplx operator*(const U &c) const {
  104.             return {x * c, y * c};
  105.         }
  106.         template<class U> cplx operator/(const U &c) const {
  107.             return {x / c, y / c};
  108.         }
  109.         template<class U> void operator/=(const U &c) {
  110.             x /= c;
  111.             y /= c;
  112.         }
  113.     };
  114.     #define polar(r,a)  (cplx<ld>){r*cos(a),r*sin(a)}
  115.  
  116.     const int32_t DIG = 9, FDIG = 4;
  117.     const int32_t BASE = 1e9, FBASE = 1e4;
  118.     typedef cplx<ld> Cplx;
  119.  
  120.  
  121.     // use mulmod when taking mod by int32_t v and v>2e9
  122.     // you can use mod by bigint in that case too
  123.     struct bigint {
  124.         int32_t sgn;
  125.         vector<int32_t> a;
  126.         bigint() : sgn(1) {}
  127.         bigint(ll v) {
  128.             *this = v;
  129.         }
  130.         bigint& operator = (ll v) {
  131.             sgn = 1;
  132.             if (v < 0) sgn = -1, v = -v;
  133.             a.clear();
  134.             for (; v > 0; v /= BASE) a.push_back(v % BASE);
  135.             return *this;
  136.         }
  137.         bigint(const bigint& other) {
  138.             sgn = other.sgn;
  139.             a = other.a;
  140.         }
  141.         friend void swap(bigint& a, bigint& b) {
  142.             swap(a.sgn, b.sgn);
  143.             swap(a.a, b.a);
  144.         }
  145.         bigint& operator = (bigint other) {
  146.             swap(*this, other);
  147.             return *this;
  148.         }
  149.         bigint(bigint&& other) : bigint() {
  150.             swap(*this, other);
  151.         }
  152.         bigint(const string& s) {
  153.             read(s);
  154.         }
  155.         void read(const string& s) {
  156.             sgn = 1;
  157.             a.clear();
  158.             int32_t k = 0;
  159.             for (; k < (int32_t) s.size() && (s[k] == '-' | s[k] == '+'); k++)
  160.                 if (s[k] == '-') sgn = -sgn;
  161.             for (int32_t i = s.size() - 1; i >= k; i -= DIG) {
  162.                 int32_t x = 0;
  163.                 for (int32_t j = max(k, i - DIG + 1); j <= i; j++) x = x * 10 + s[j] - '0';
  164.                 a.push_back(x);
  165.             }
  166.             trim();
  167.         }
  168.         friend istream& operator>>(istream &in, bigint &v) {
  169.             string s;
  170.             in >> s;
  171.             v.read(s);
  172.             return in;
  173.         }
  174.         friend ostream& operator<<(ostream &out, const bigint &v) {
  175.             if (v.sgn == -1 && !v.zero()) out << '-';
  176.             out << (v.a.empty() ? 0 : v.a.back());
  177.             for (int32_t i = (int32_t) v.a.size() - 2; i >= 0; --i)
  178.                 out << setw(DIG) << setfill('0') << v.a[i];
  179.             return out;
  180.         }
  181.         bool operator<(const bigint &v) const {
  182.             if (sgn != v.sgn) return sgn < v.sgn;
  183.             if (a.size() != v.a.size()) return a.size() * sgn < v.a.size() * v.sgn;
  184.             for (int32_t i = (int32_t)a.size() - 1; i >= 0; i--)
  185.                 if (a[i] != v.a[i]) return a[i] * sgn < v.a[i] * sgn;
  186.             return 0;
  187.         }
  188.         bool operator>(const bigint &v) const {
  189.             return v < *this;
  190.         }
  191.         bool operator<=(const bigint &v) const {
  192.             return !(v < *this);
  193.         }
  194.         bool operator>=(const bigint &v) const {
  195.             return !(*this < v);
  196.         }
  197.         bool operator==(const bigint &v) const {
  198.             return !(*this < v) && !(v < *this);
  199.         }
  200.         bool operator!=(const bigint &v) const {
  201.             return *this < v || v < *this;
  202.         }
  203.         friend int32_t __cmp(const bigint& x, const bigint& y) {
  204.             if (x.a.size() != y.a.size()) return x.a.size() < y.a.size() ? -1 : 1;
  205.             for (int32_t i = (int32_t) x.a.size() - 1; i >= 0; --i) if (x.a[i] != y.a[i])
  206.                     return x.a[i] < y.a[i] ? -1 : 1;
  207.             return 0;
  208.         }
  209.  
  210.         bigint operator-() const {
  211.             bigint res = *this;
  212.             if (zero()) return res;
  213.             res.sgn = -sgn;
  214.             return res;
  215.         }
  216.  
  217.         void __add(const bigint& v) {
  218.             if (a.size() < v.a.size()) a.resize(v.a.size(), 0);
  219.             for (int32_t i = 0, carry = 0; i < (int32_t) max(a.size(), v.a.size()) || carry; ++i) {
  220.                 if (i == (int32_t) a.size()) a.push_back(0);
  221.                 a[i] += carry + (i < (int32_t) v.a.size() ? v.a[i] : 0);
  222.                 carry = a[i] >= BASE;
  223.                 if (carry) a[i] -= BASE;
  224.             }
  225.         }
  226.  
  227.         void __sub(const bigint& v) {
  228.             for (int32_t i = 0, carry = 0; i < (int32_t) v.a.size() || carry; ++i) {
  229.                 a[i] -= carry + (i < (int32_t) v.a.size() ? v.a[i] : 0);
  230.                 carry = a[i] < 0;
  231.                 if (carry) a[i] += BASE;
  232.             }
  233.             this->trim();
  234.         }
  235.  
  236.         bigint operator+=(const bigint& v) {
  237.             if (sgn == v.sgn) __add(v);
  238.             else if (__cmp(*this, v) >= 0) __sub(v);
  239.             else {
  240.                 bigint vv = v;
  241.                 swap(*this, vv);
  242.                 __sub(vv);
  243.             }
  244.             return *this;
  245.         }
  246.  
  247.         bigint operator-=(const bigint& v) {
  248.             if (sgn == v.sgn) {
  249.                 if (__cmp(*this, v) >= 0) __sub(v);
  250.                 else {
  251.                     bigint vv = v;
  252.                     swap(*this, vv);
  253.                     __sub(vv);
  254.                     sgn = -sgn;
  255.                 }
  256.             } else __add(v);
  257.             return *this;
  258.         }
  259.  
  260.         template< typename L, typename R >
  261.         typename enable_if <
  262.         is_convertible<L, bigint>::value &&
  263.         is_convertible<R, bigint>::value &&
  264.         is_lvalue_reference < R&& >::value,
  265.         bigint >::type friend operator + (L&& l, R&& r) {
  266.             bigint result(forward<L>(l));
  267.             result += r;
  268.             return result;
  269.         }
  270.         template< typename L, typename R >
  271.         typename enable_if <
  272.         is_convertible<L, bigint>::value &&
  273.         is_convertible<R, bigint>::value &&
  274.         is_rvalue_reference < R&& >::value,
  275.         bigint >::type friend operator + (L&& l, R&& r) {
  276.             bigint result(move(r));
  277.             result += l;
  278.             return result;
  279.         }
  280.         template< typename L, typename R >
  281.         typename enable_if <
  282.         is_convertible<L, bigint>::value &&
  283.         is_convertible<R, bigint>::value,
  284.         bigint >::type friend operator - (L&& l, R&& r) {
  285.             bigint result(forward<L>(l));
  286.             result -= r;
  287.             return result;
  288.         }
  289.  
  290.         friend pair<bigint, bigint> divmod(const bigint& a1, const bigint& b1) {
  291.             ll norm = BASE / (b1.a.back() + 1);
  292.             bigint a = a1.abs() * norm, b = b1.abs() * norm, q = 0, r = 0;
  293.             q.a.resize(a.a.size());
  294.             for (int32_t i = a.a.size() - 1; i >= 0; i--) {
  295.                 r *= BASE;
  296.                 r += a.a[i];
  297.                 ll s1 = r.a.size() <= b.a.size() ? 0 : r.a[b.a.size()];
  298.                 ll s2 = r.a.size() <= b.a.size() - 1 ? 0 : r.a[b.a.size() - 1];
  299.                 ll d = ((ll) BASE * s1 + s2) / b.a.back();
  300.                 r -= b * d;
  301.                 while (r < 0) r += b, --d;
  302.                 q.a[i] = d;
  303.             }
  304.             q.sgn = a1.sgn * b1.sgn;
  305.             r.sgn = a1.sgn;
  306.             q.trim();
  307.             r.trim();
  308.             auto res = make_pair(q, r / norm);
  309.             if (res.second < 0) res.second += b1;
  310.             return res;
  311.         }
  312.         bigint operator/(const bigint &v) const {
  313.             return divmod(*this, v).first;
  314.         }
  315.         bigint operator%(const bigint &v) const {
  316.             return divmod(*this, v).second;
  317.         }
  318.         void operator/=(int32_t v) {
  319.             if (llabs(v) >= BASE) {
  320.                 *this /= bigint(v);
  321.                 return;
  322.             }
  323.             if (v < 0) sgn = -sgn, v = -v;
  324.             for (int32_t i = (int32_t) a.size() - 1, rem = 0; i >= 0; --i) {
  325.                 ll cur = a[i] + rem * (ll)BASE;
  326.                 a[i] = (int32_t) (cur / v);
  327.                 rem = (int32_t) (cur % v);
  328.             }
  329.             trim();
  330.         }
  331.         bigint operator/(int32_t v) const {
  332.             if (llabs(v) >= BASE) return *this / bigint(v);
  333.             bigint res = *this;
  334.             res /= v;
  335.             return res;
  336.         }
  337.         void operator/=(const bigint &v) {
  338.             *this = *this / v;
  339.         }
  340.         ll operator%(ll v) const {
  341.             int32_t m = 0;
  342.             for (int32_t i = a.size() - 1; i >= 0; --i) m = (a[i] + m * (ll) BASE) % v;
  343.             return m * sgn;
  344.         }
  345.         void operator*=(int32_t v) {
  346.             if (llabs(v) >= BASE) {
  347.                 *this *= bigint(v);
  348.                 return;
  349.             }
  350.             if (v < 0) sgn = -sgn, v = -v;
  351.             for (int32_t i = 0, carry = 0; i < (int32_t) a.size() || carry; ++i) {
  352.                 if (i == (int32_t) a.size()) a.push_back(0);
  353.                 ll cur = a[i] * (ll) v + carry;
  354.                 carry = (int32_t) (cur / BASE);
  355.                 a[i] = (int32_t) (cur % BASE);
  356.             }
  357.             trim();
  358.         }
  359.         bigint operator*(int32_t v) const {
  360.             if (llabs(v) >= BASE) return *this * bigint(v);
  361.             bigint res = *this;
  362.             res *= v;
  363.             return res;
  364.         }
  365.  
  366.         static vector<int32_t> convert_base(const vector<int32_t> &a, int32_t old_digits, int32_t new_digits) {
  367.             vector<ll> p(max(old_digits, new_digits) + 1);
  368.             p[0] = 1;
  369.             for (int32_t i = 1; i < (int32_t) p.size(); i++)
  370.                 p[i] = p[i - 1] * 10;
  371.             vector<int32_t> res;
  372.             ll cur = 0;
  373.             int32_t cur_digits = 0;
  374.             for (int32_t i = 0; i < (int32_t) a.size(); i++) {
  375.                 cur += a[i] * p[cur_digits];
  376.                 cur_digits += old_digits;
  377.                 while (cur_digits >= new_digits) {
  378.                     res.push_back((ll)(cur % p[new_digits]));
  379.                     cur /= p[new_digits];
  380.                     cur_digits -= new_digits;
  381.                 }
  382.             }
  383.             res.push_back((int32_t) cur);
  384.             while (!res.empty() && !res.back())
  385.                 res.pop_back();
  386.             return res;
  387.         }
  388.  
  389.         void fft(vector<Cplx>& a, bool invert) const {
  390.             int32_t n = a.size();
  391.             for (int32_t i = 1, j = 0; i < n; ++i) {
  392.                 int32_t bit = n / 2;
  393.                 for (; j >= bit; bit /= 2) j -= bit;
  394.                 j += bit;
  395.                 if (i < j) swap(a[i], a[j]);
  396.             }
  397.             for (int32_t len = 2; len <= n; len *= 2) {
  398.                 ld ang = 2 * PI / len * (invert ? -1 : 1);
  399.                 Cplx wlen = polar(1, ang);
  400.                 for (int32_t i = 0; i < n; i += len) {
  401.                     Cplx w(1);
  402.                     for (int32_t j = 0; j < len / 2; ++j) {
  403.                         Cplx u = a[i + j], v = a[i + j + len / 2] * w;
  404.                         a[i + j] = u + v;
  405.                         a[i + j + len / 2] = u - v;
  406.                         w *= wlen;
  407.                     }
  408.                 }
  409.             }
  410.             if (invert) for (int32_t i = 0; i < n; ++i) a[i] /= n;
  411.         }
  412.         void multiply_fft(const vector<int32_t> &a, const vector<int32_t> &b, vector<int32_t> &res) const {
  413.             vector<Cplx> fa(a.begin(), a.end()), fb(b.begin(), b.end());
  414.             int32_t n = 1;
  415.             while (n < (int32_t) max(a.size(), b.size())) n *= 2;
  416.             n *= 2;
  417.             fa.resize(n);
  418.             fb.resize(n);
  419.             fft(fa, 0);
  420.             fft(fb, 0);
  421.             for (int32_t i = 0; i < n; ++i) fa[i] *= fb[i];
  422.             fft(fa, 1);
  423.             res.resize(n);
  424.             ll carry = 0;
  425.             for (int32_t i = 0; i < n; i++) {
  426.                 ll t = (ll)(fa[i].real() + 0.5) + carry;
  427.                 carry = t / FBASE;
  428.                 res[i] = t % FBASE;
  429.             }
  430.         }
  431.         static inline int32_t rev_incr(int32_t a, int32_t n) {
  432.             int32_t msk = n / 2, cnt = 0;
  433.             while ( a & msk ) {
  434.                 cnt++;
  435.                 a <<= 1;
  436.             }
  437.             a &= msk - 1;
  438.             a |= msk;
  439.             while ( cnt-- ) a >>= 1;
  440.             return a;
  441.         }
  442.         static vector<Cplx> FFT(vector<Cplx> v, int32_t dir = 1) {
  443.             Cplx wm, w, u, t;
  444.             int32_t n = v.size();
  445.             vector<Cplx> V(n);
  446.             for (int32_t k = 0, a = 0; k < n; ++k, a = rev_incr(a, n))
  447.                 V[a] = v[k] / ld(dir > 0 ? 1 : n);
  448.             for (int32_t m = 2; m <= n; m <<= 1) {
  449.                 wm = polar( (ld)1, dir * 2 * PI / m );
  450.                 for (int32_t k = 0; k < n; k += m) {
  451.                     w = 1;
  452.                     for (int32_t j = 0; j < m / 2; ++j, w *= wm) {
  453.                         u = V[k + j];
  454.                         t = w * V[k + j + m / 2];
  455.                         V[k + j] = u + t;
  456.                         V[k + j + m / 2] = u - t;
  457.                     }
  458.                 }
  459.             }
  460.             return V;
  461.         }
  462.         static void convolution(const vector<int32_t>& a, const vector<int32_t>& b, vector<int32_t>& c) {
  463.             int32_t sz = a.size() + b.size() - 1;
  464.             int32_t n  = 1 << int32_t(ceil(log2(sz)));
  465.             vector<Cplx> av(n, 0), bv(n, 0), cv;
  466.             for (int32_t i = 0; i < (int32_t) a.size(); i++) av[i] = a[i];
  467.             for (int32_t i = 0; i < (int32_t) b.size(); i++) bv[i] = b[i];
  468.             cv = FFT(bv);
  469.             bv = FFT(av);
  470.             for (int32_t i = 0; i < n; i++) av[i] = bv[i] * cv[i];
  471.             cv = FFT(av, -1);
  472.             c.resize(n);
  473.             ll carry = 0;
  474.             for (int32_t i = 0; i < n; i++) {
  475.                 ll t = ll(cv[i].real() + 0.5) + carry;
  476.                 carry = t / FBASE;
  477.                 c[i] = t % FBASE;
  478.             }
  479.         }
  480.         bigint mul_simple(const bigint &v) const {
  481.             bigint res;
  482.             res.sgn = sgn * v.sgn;
  483.             res.a.resize(a.size() + v.a.size());
  484.             for (int32_t i = 0; i < (int32_t) a.size(); i++) if (a[i])
  485.                     for (int32_t j = 0, carry = 0; j < (int32_t) v.a.size() || carry; j++) {
  486.                         ll cur = res.a[i + j] + (ll) a[i] * (j < (int32_t) v.a.size() ? v.a[j] : 0) + carry;
  487.                         carry = (int32_t) (cur / BASE);
  488.                         res.a[i + j] = (int32_t) (cur % BASE);
  489.                     }
  490.             res.trim();
  491.             return res;
  492.         }
  493.         bigint mul_fft(const bigint& v) const {
  494.             bigint res;
  495.             convolution(convert_base(a, DIG, FDIG), convert_base(v.a, DIG, FDIG), res.a);
  496.             res.a = convert_base(res.a, FDIG, DIG);
  497.             res.trim();
  498.             return res;
  499.         }
  500.         void operator*=(const bigint &v) {
  501.             *this = *this * v;
  502.         }
  503.         bigint operator*(const bigint &v) const {
  504.             if (1LL * a.size() * v.a.size() <= 1000111) return mul_simple(v);
  505.             return mul_fft(v);
  506.         }
  507.  
  508.         bigint abs() const {
  509.             bigint res = *this;
  510.             res.sgn *= res.sgn;
  511.             return res;
  512.         }
  513.         void trim() {
  514.             while (!a.empty() && !a.back()) a.pop_back();
  515.         }
  516.         bool zero() const {
  517.             return a.empty() || (a.size() == 1 && !a[0]);
  518.         }
  519.         friend bigint gcd(const bigint &a, const bigint &b) {
  520.             return b.zero() ? a : gcd(b, a % b);
  521.         }
  522.     };
  523.     bigint power(bigint a, ll k) {
  524.         bigint ans = 1;
  525.         while (k > 0) {
  526.             if (k & 1) ans *= a;
  527.             a *= a;
  528.             k >>= 1;
  529.         }
  530.         return ans;
  531.     }
  532. }
  533.  
  534. using BigNum :: bigint;
  535. using BigNum :: power;
  536.  
  537. str s;
  538. void solve() {
  539.     cin >> s;
  540.     bigint ans = 0, pre = 0, num = 0;
  541.     char c = '?';
  542.     forw (i, 0, sz(s) - 1) {
  543.         if (isdigit(s[i])) num = num * 10 + (s[i] - '0');
  544.         else {
  545.             if (s[i] == c) {
  546.                 pre += num;
  547.                 ans = max(ans, pre);
  548.             }
  549.             else {
  550.                 ans = max(ans, num);
  551.                 pre = num;;
  552.                 c = s[i];
  553.             }
  554.             num = 0;
  555.         }
  556.     }
  557.  
  558.     cout << ans << endl;
  559. }
  560.  
  561. signed main() {
  562.     ios::sync_with_stdio(false), cin.tie(nullptr);
  563.     srand(time(NULL));
  564.     #define name "test"
  565.     if (fopen(name".INP", "r")) {
  566.         freopen(name".INP", "r", stdin);
  567.         freopen(name".OUT", "w", stdout);
  568.     }
  569.     bool testCase = false;
  570.     int numTest = 1;
  571.     // cin >> numTest;
  572.     forw (i, 1, numTest) {
  573.         if (testCase) cout << "Case #" << i << ": ";
  574.         solve();
  575.     }
  576.     return 0;
  577. }
  578.  
  579. /*
  580. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣀⣤⣤⣤⣴⣦⣶⣤⣤⣀⣀⣤⣤⣄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  581. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣾⠿⠿⣶⣦⣄⡀⠀⢀⣠⣴⣶⠿⠿⠛⠋⠉⠉⠉⠉⠀⠀⠈⠉⠛⠋⠉⠉⠙⠻⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  582. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣿⠏⠀⣠⣄⡀⠈⠙⣿⡾⠟⠋⠁⢀⣀⡤⠶⠖⠛⠛⠲⠞⠋⠉⠛⠛⠒⠲⢿⣷⣦⣄⠀⠉⠻⣷⣶⣤⣄⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  583. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣴⣶⡶⠾⠾⠿⠃⢀⣼⣿⣻⣿⡏⠀⠉⣀⣤⠶⠞⠉⢁⠠⠀⠄⡒⠀⠄⠂⠌⢀⠡⠐⠀⠀⠀⠈⠙⢿⣿⣦⣀⠀⠀⠈⠙⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  584. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣼⡿⠟⠃⠀⣀⣀⡀⠀⠀⣼⡿⣧⣿⣿⠇⢀⡼⠛⠀⠀⡀⠘⢀⠀⠄⢠⠃⠠⢀⠘⠀⠄⠀⠄⡀⠀⠀⠀⠀⠀⠸⢿⣿⣧⡀⠛⢧⡀⠘⢿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  585. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣴⡿⠋⠀⡠⠞⠋⠀⠀⠀⢀⣾⣿⣽⣿⣿⡿⣿⠋⠀⠄⠂⢁⠠⠈⡀⠄⢈⡏⢀⠐⠠⠀⡁⠂⢁⠠⠀⠀⠀⠀⢀⠀⡀⠈⠹⣟⣿⣦⠀⢻⡄⠈⢿⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  586. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⣠⠞⠀⡀⠀⠀⠀⠀⣾⣿⣳⣿⡿⢃⡾⠁⠀⠀⠂⢈⠀⢄⠞⠀⡐⣘⠀⠄⠂⠠⠁⡀⠌⠀⠀⠀⠀⠀⠀⠀⠁⠀⠐⡀⠙⣿⣿⠀⡀⢿⠀⠈⣿⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  587. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣼⡟⠀⢰⢏⣾⣿⣶⣎⣠⣤⣼⣿⣿⣿⡿⠁⣼⠃⠀⠀⠀⠀⠀⣀⡞⠀⡐⠀⣷⠀⠀⢈⠀⠐⠀⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⢂⠠⠀⠸⡟⢀⠐⣸⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  588. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⠃⢀⣿⣾⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⢃⢰⡇⠀⠀⠀⠀⠀⠀⡼⠀⠀⠄⠂⣽⣄⠀⠀⠀⢀⠀⠙⠧⣄⠀⠠⠀⠄⢀⠠⠐⠀⡀⢧⡐⠀⢂⠰⢸⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  589. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣄⣀⣼⡟⠀⣸⣟⣿⣽⣿⣟⠻⢿⣿⣼⣿⣿⣿⢊⣼⢡⠀⠀⠀⠀⠀⣸⠇⠀⠀⠐⢀⡇⠸⣦⡀⢈⠀⠀⠀⣇⠈⠛⣦⣐⠈⠀⠄⠂⡐⠀⡀⢧⠐⡀⢎⣹⠇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  590. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⠿⡷⡟⠿⢋⠿⢿⡿⠛⠀⢀⣼⠟⢸⣿⣿⢥⡟⣿⠀⠀⠀⠀⣰⠏⠀⡀⠄⠀⣸⠁⠀⡼⣿⣦⡀⠡⠀⠹⡄⠀⠀⠽⢷⣌⠀⠂⠄⠂⡀⠘⡄⠸⣄⢻⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  591. ⠀⠀⠀⠀⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣧⣛⠴⣩⠝⡊⠅⠀⠀⠀⣠⣿⠟⠀⣼⣿⣿⡎⣽⣿⠀⠀⠠⣱⠏⠀⢂⢠⠀⢠⣿⣀⡀⠀⠜⣿⣷⣦⡐⠀⢻⡄⠀⠀⣹⣿⣷⣅⠐⠠⢀⠁⡸⢐⠬⣻⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  592. ⠀⠀⠀⠀⠀⢀⣠⣶⡿⣿⣿⣿⣿⣿⣿⣿⣿⣧⠗⡌⠀⠀⠀⣠⣾⣿⠋⠀⢸⡇⠀⢸⣷⣾⣿⠇⠀⢡⡟⠀⠌⠀⡎⠀⣼⠋⠈⠉⠓⠲⢿⣿⣿⣿⣄⠈⣧⠀⠚⠁⠺⣹⢿⣷⡆⡄⢂⡘⡇⢎⣽⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  593. ⠀⠀⠀⣠⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣭⣛⢩⠁⠀⠀⠀⣠⣾⣿⡟⠁⠀⣰⣾⡇⠀⠈⣿⣿⣿⠁⢨⡿⠁⠐⠠⢁⡇⢐⣿⠀⠀⣄⠀⠀⠈⢻⣿⣿⣿⣇⢾⡇⠀⠀⣀⣼⣿⣿⣿⣷⢆⡜⣹⢂⣿⡄⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  594. ⠀⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⢿⣿⣷⣄⠀⢀⣴⣿⡿⠋⠀⣰⣴⣿⣿⣻⡶⢤⣼⣿⡿⢀⣿⠃⢀⠁⠂⢸⣧⢨⣿⣿⣶⣦⣄⠀⠀⠀⠻⣿⣿⣿⣿⡇⢠⣾⣿⣿⡽⢿⣿⣿⣿⡜⣳⠐⣾⡇⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  595. ⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣟⣛⠻⢿⣷⣝⢿⣿⣧⣾⣿⠟⠁⠀⠀⣿⣿⣿⣋⣼⣷⡛⡟⠿⣿⣼⣟⠀⠤⠈⢀⣿⣿⣸⣿⣿⡟⣻⠝⢧⠀⠀⠀⠈⠻⣿⣿⢷⣿⣿⣿⣼⡇⠈⣿⣿⣿⣞⠱⠈⣾⡇⠀⢻⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  596. ⢸⣿⣿⣿⣿⣿⢿⣿⣿⣿⣿⣿⣷⣤⠙⣿⣧⢿⣿⣿⠃⠀⡀⠀⠀⣿⡟⣿⣧⣿⣿⣿⣼⢲⡌⡽⣿⣤⠀⢂⢰⣿⣿⣿⠿⡿⠛⣿⠄⠀⠀⠀⠀⠀⠀⠈⠹⠎⢯⣙⠉⣸⠃⠸⢫⣿⣿⣯⠆⠁⢾⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  597. ⢸⣿⣿⣿⣿⡏⣼⣿⣿⣿⣿⣿⣿⣿⣇⠸⣿⣾⣿⡇⠀⠠⠆⣠⣼⣿⢀⣿⣿⣿⣿⣿⣿⣿⣼⠡⠎⠻⣿⣤⣼⡗⠻⠻⠦⣤⠴⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠛⠛⠁⠀⠀⣾⠘⣿⠛⡇⢈⢚⡇⠀⢸⣯⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  598. ⢸⣿⣿⣿⣿⡅⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⣿⣿⣿⡇⠀⢸⣿⣿⢿⣧⣼⣿⣿⣿⣿⣿⣿⣿⣿⣧⠉⠋⠙⠙⢻⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠀⡁⠠⠁⠂⡸⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  599. ⢸⣿⣿⡽⣿⣧⠹⣿⣿⣿⣿⣿⣿⣿⠏⣼⣿⣽⣿⡇⣰⠏⢸⣿⣾⣿⣿⣿⣿⣿⣿⣿⣿⡿⢛⠷⠈⠀⠀⠀⠀⠹⣧⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⢤⣿⡇⠐⠀⡁⠄⢁⠰⣿⠀⠈⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  600. ⠘⢿⣿⣿⣿⣿⣷⣬⣙⡛⠿⣻⣿⣫⣾⣿⣏⣿⣿⡶⠋⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠁⠃⠀⠀⠀⠀⠀⠀⢠⣿⣟⣳⣄⠀⠀⠀⠀⠀⠠⣴⣶⣶⣶⣾⠗⠀⠀⠀⣴⣿⣿⣿⠀⠂⠠⠐⢀⠐⣿⠀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  601. ⠀⠀⠻⣿⣼⣿⣿⣿⣿⣿⣿⣿⣿⢿⣿⣿⣿⢿⠏⠀⣴⢿⡝⠁⠈⠉⠙⢿⣿⣿⣿⣿⣟⠀⠀⠀⠀⠀⠀⠀⣀⣼⣯⣿⡟⠻⣷⣄⡀⠀⠀⠀⠈⠉⠉⠉⠁⠀⢀⣴⣾⣿⣿⣿⣿⡇⠀⡁⠐⡀⠂⣽⡇⠀⢿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  602. ⠀⠀⠐⣿⡧⣿⡿⢿⣻⣯⡿⣿⣯⣿⣾⢧⡟⠃⢠⣼⡟⡎⠀⠉⠉⠙⠛⠳⡞⣿⣿⣿⡇⠀⢀⣤⣤⣀⠀⣴⣿⡿⠟⠉⠙⢦⣽⣿⠿⢦⣤⣀⠀⠀⠀⠀⣰⠛⢻⣿⣿⣿⣿⣿⣿⣷⠀⠄⢁⠠⠐⡸⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  603. ⠀⠀⠀⣿⣷⣉⣿⣿⣿⣿⣿⣶⡝⣷⢿⣾⠃⣠⣾⣿⢇⡟⢀⡀⠐⠀⠀⠀⣇⢸⣿⣿⠇⠐⠋⠀⠀⢘⣿⡿⠋⠀⣠⡆⠀⣾⡟⣿⣿⣾⣿⣿⣿⣷⣾⣿⢿⡇⢸⣿⣿⣿⣿⣿⣿⡿⠀⢈⠀⠄⠂⠱⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  604. ⠀⠀⠀⣿⣿⣿⣟⣿⣿⣿⣿⣿⣿⢸⣿⣿⢠⣿⣿⣿⢸⣷⡸⢿⣦⣄⠀⣰⣇⣾⣿⣿⠂⠈⡀⠀⠀⣸⠋⠀⣠⣾⠟⠀⢠⡟⠻⠿⠛⠋⠀⠉⠉⠙⠿⠿⣦⡁⢿⣿⣿⣿⣿⣿⣿⡇⠀⢂⠀⠂⠌⠐⣿⠀⠘⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  605. ⠀⠀⠀⣽⣿⣿⣿⢹⣿⣿⣿⣿⡿⣸⣿⣏⣾⣿⣿⡯⣾⡿⠷⢮⣽⣿⣶⣿⠿⠻⡉⠟⣶⣀⠑⠤⠀⡿⠲⣶⡿⠋⠀⣀⠾⠁⠀⠀⠀⠀⠀⠀⠀⢰⡤⠴⠟⢧⡌⠻⢿⣿⣿⣿⣿⠃⠀⠌⠐⡀⠄⠐⣻⡀⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  606. ⠀⠀⠠⣿⣿⣯⠻⣷⣍⣛⣛⢻⣴⣿⠟⣱⣿⣿⣿⣿⡿⠁⠀⠀⠀⠀⠀⠀⠠⣅⣜⠠⠙⣿⣶⣄⣼⢧⡀⠈⠀⣀⣾⣟⣓⠂⠄⠀⠀⠀⠀⠀⠀⠘⠷⣤⣀⢨⡿⢷⣤⡈⠛⠛⠉⠋⠻⠶⣶⣦⣄⠂⢹⡇⠀⢿⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  607. ⠀⠀⠀⢻⣿⣿⣷⣮⣙⡛⢛⢻⣻⣥⣿⣿⣿⣿⠟⠛⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠁⣠⣿⣿⣿⣿⡄⠙⣄⠚⠉⠁⠀⠉⠙⣆⠈⠐⠠⠀⠀⠀⠀⠀⠈⢷⡄⠘⢦⡉⠉⠳⢦⡙⢦⠀⠀⠀⠉⠺⡛⢶⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  608. ⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⢁⠠⢠⠀⡄⢠⠀⠠⢀⠀⠀⠀⠀⠀⢀⡞⠙⣿⣿⣿⣿⡄⠹⡆⠀⠀⠀⠀⠀⢯⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⢻⡄⢀⠳⣤⠀⠀⠁⠈⠳⡀⠀⠀⠀⠈⢢⡻⡄⠸⣿⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  609. ⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣤⢃⠦⣡⠒⠤⠘⠠⠀⠀⠀⠀⣀⣤⠟⠁⢸⣿⣿⣿⣿⣿⡀⢹⡄⠀⠀⠀⠀⠩⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢻⣆⠀⡈⠳⣄⠀⠀⠀⠙⢦⡀⡀⠀⠀⠙⣇⠀⠈⢻⡿⢿⣦⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  610. ⠀⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠿⠿⠶⠿⠾⠷⠷⠶⠾⠟⠛⠉⠁⠀⡘⣿⣿⣿⣿⣿⣿⡇⠘⣧⠀⠀⠀⠀⢸⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠻⣧⡀⠐⠘⢷⣄⠉⠦⠿⣇⠁⠀⠀⠀⠈⠳⢦⣀⣧⡀⠈⠻⣷⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  611. ⠀⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡼⢅⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⣼⣿⣿⣿⣿⣿⣿⡿⢀⣿⠀⠀⠀⠀⢠⡁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣷⡈⢀⠂⠙⢿⡶⠶⠿⠶⢦⡀⠀⠀⠀⠀⠀⠙⣿⣦⠀⠙⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  612. ⠀⠀⠀⠀⠈⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣈⠰⢠⢂⠠⢀⡀⠀⠀⠀⠀⠀⢀⣡⣿⣿⣿⣿⣿⣿⣿⡇⢸⡇⠀⠀⠀⠀⢸⡇⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡆⠠⠁⡈⠱⡆⠀⠀⠲⣕⡀⠀⠀⠀⠀⢀⡟⣿⣷⡀⠈⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  613. ⠀⠀⠀⠀⠀⠀⠹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⢦⡙⡆⢬⡑⢢⠠⣉⣄⣠⡴⠞⠋⣿⣿⣿⣿⣿⣿⣿⡟⠀⡾⠀⠀⠀⠀⠀⣼⠄⢰⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠹⣿⡀⠐⡀⠁⠹⡄⠀⠀⠘⢿⡄⠀⠀⣠⡾⢁⣿⣿⣿⣦⡀⠨⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  614. ⠀⠀⠀⠀⠀⠀⠀⠈⣿⠛⣿⣿⣿⣿⡟⡟⠛⠛⠛⠿⠛⠿⠛⠛⠟⠛⠉⠁⠠⣄⣾⣿⣿⣿⣿⣿⣿⡟⠁⣼⠁⠀⠀⠀⠀⢸⡏⠀⣾⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠠⢀⠁⠂⢿⠀⠀⠀⠀⣿⣦⡾⢋⣴⣿⣿⣿⣿⣿⣿⣦⡀⠈⠻⣷⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀
  615. ⠀⠀⠀⠀⠀⠀⠀⢸⣿⠀⣘⣿⣿⣿⣿⡱⠡⠌⢂⣄⡀⠀⠄⢂⡀⠀⠀⠄⣱⣾⣿⣿⣿⣿⣿⡿⠋⣠⢾⡇⠀⠀⠀⠀⢠⣞⢁⣸⠇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠐⡀⠈⠄⡘⣇⠀⠀⠀⣿⣷⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠈⢻⣧⠀⠀⠀⠀⠀⠀⠀⠀
  616. ⠀⠀⠀⠀⠀⠀⠀⢸⡏⠀⢹⣿⣿⣿⣿⣇⠻⣌⠲⣌⠷⢬⠐⠠⢀⠂⣀⣴⣿⣿⣿⣿⠿⠛⢁⣤⠞⠁⠈⣿⣄⠀⠀⢀⣾⠇⣼⠋⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⠐⡀⠡⠀⠄⢿⠀⠀⠀⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⠈⣿⡆⠀⠀⠀⠀⠀⠀⠀
  617. ⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⡿⠈⠻⣿⡿⢿⢷⣾⣿⣾⣽⣦⣭⣶⠟⠛⠛⠛⠛⢉⣉⣠⡴⠞⠋⠀⣠⣶⡀⠘⢿⣦⣶⡿⠋⠚⠛⠓⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢨⡗⠠⠐⠀⠡⠀⢼⡆⠀⠀⢹⣿⡏⢹⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀
  618. ⠀⠀⠀⠀⠀⠀⢰⣿⠀⢰⡇⠠⢀⠀⢀⠀⠀⠀⠀⠀⠙⢿⣿⣿⣿⣿⣿⣾⠛⠛⠉⠁⣀⣤⣶⠿⠛⠻⣿⡀⠸⣿⡿⡖⠒⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡇⢀⠂⢁⠂⢁⠀⣧⠀⠀⠸⣿⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⣼⡏⠀⠀⠀⠀⠀⠀⠀⠀
  619. ⠀⠀⠀⠀⠀⠀⣸⡏⠀⣸⠀⠠⠀⠌⠀⠠⠈⢀⠐⠀⠂⠀⠈⠉⢉⣿⣿⣿⠀⢰⣾⠿⠛⠉⠀⠀⠀⠀⢿⣧⠀⢸⣷⣷⠀⠠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣇⠀⡐⠠⠐⠀⢂⢻⠀⠀⢸⣿⣿⣿⠟⣻⣿⣿⣿⣻⡟⣿⣿⡟⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀
  620. ⠀⠀⠀⠀⠀⠀⣿⡇⠀⣿⠀⡀⢁⠂⠈⠀⠄⠂⠀⠌⠀⠁⠀⠀⣾⣿⣿⣿⠀⠈⣿⠄⠀⠀⠀⠀⠀⠀⠩⣿⣆⠀⢻⣿⡆⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠠⠐⡀⠡⢀⢸⡆⠀⢸⣿⣿⣥⣿⣿⣿⣿⣿⣿⡿⠈⣿⠀⢠⣿⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀
  621. ⠀⠀⠀⠀⠀⢀⣿⠀⢰⡇⠀⠄⡀⠂⢁⠀⠂⢀⠐⠀⣈⣤⣄⣾⣿⣿⣿⣿⡄⠀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠸⣿⡄⠈⢿⣧⠤⠀⠀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠀⠡⠐⢀⠐⡀⠈⣷⠀⢸⣿⣿⣿⣿⣿⣿⣿⡿⡿⠁⣰⠇⠀⣾⡏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  622. ⠀⠀⠀⠀⠀⣸⡟⠀⢸⠃⢀⠂⠠⠐⠀⡀⠌⠀⠀⠄⣾⣿⣿⣿⢿⣿⣿⣿⡇⠀⢻⡇⠀⠀⠀⠀⠀⠀⠀⠀⢻⣷⡀⠘⣿⣆⠀⢀⠠⠐⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡅⠂⢈⠠⠀⠄⡁⠸⡆⢸⣿⣿⣿⣿⣿⣿⡿⢱⣇⣀⡟⠀⣼⡿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  623. ⠀⠀⠀⠀⠀⣿⡇⠀⡿⠀⠠⠀⡁⢀⠂⠀⠠⠐⠈⠀⣿⣿⣿⣯⣿⣿⣿⣿⡇⠀⢸⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣧⠀⢹⣿⡄⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⡇⠀⢂⠠⠈⡀⠄⠁⢿⣻⣿⣿⣿⣿⣿⡿⢠⣟⣼⡿⠁⢰⣿⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  624. ⠀⠀⠀⠀⢠⣿⠀⢰⡇⠀⡁⠠⠐⠀⠀⠀⠂⠀⠄⣠⣿⣿⣿⣟⣿⣿⣿⣿⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⡄⠀⢻⣧⠀⠀⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣻⣇⠈⡀⠄⠂⡀⠂⢁⠘⣿⣿⣿⣿⣿⣿⣥⡟⡴⣼⠃⢀⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  625. ⠀⠀⠀⠀⢸⣿⠀⢸⡇⠀⡄⠐⢠⠀⠁⠀⡄⣴⣾⣿⣿⣿⣿⣿⢻⣿⣿⣿⣿⠀⢸⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⡄⠈⣿⡆⠀⢠⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢹⣿⠀⡄⠂⠁⢠⠈⢠⠀⢹⣿⣿⣿⢻⣿⣾⢳⢳⡏⠀⣼⡟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  626. ⠀⠀⠀⢀⣾⡇⠀⣾⣄⣀⣄⣐⣀⣀⣀⣠⣾⣿⣿⣿⣿⣿⣷⣿⣿⣿⣿⣿⣿⡀⢸⣿⣠⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣿⣧⠀⣹⣿⣤⣀⣀⣀⣀⣀⣀⣀⡀⠀⠀⠀⠀⠀⣀⣀⣸⣿⣀⣠⣔⣈⣤⣐⣀⣈⣀⣈⣹⣿⣿⣾⣷⣏⣾⠁⣠⣿⡃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  627. ⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠈⠀⠈⠁⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠈⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
  628. */
  629.  
Success #stdin #stdout 0.01s 5296KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
0
https://ideone.com/SESpf6
language:
C++14 (gcc 8.3)
created:
7 days ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!