#ifdef LOCAL
#include "my_header.h"
#else
#define PRAGMA_OPTIMIZE(s) _Pragma(#s)
PRAGMA_OPTIMIZE(GCC optimize("Ofast"))
PRAGMA_OPTIMIZE(GCC optimize("unroll-loops")) // ループ
#pragma GCC optimize("fast-math", "no-stack-protector")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")//浮動小数点
// #pragma GCC target ("avx,avx2,fma")//四則演算
  #include <bits/stdc++.h>
  #include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>
  using namespace std;
#if __has_include(<atcoder/all>)
#include <atcoder/all>
using namespace atcoder;
using minta = modint998244353;
using mintb = modint1000000007;
std::ostream&operator<<(std::ostream& os,minta v){os << v.val();return os;}
std::istream&operator>>(std::istream&is,minta &v){long long t;is >> t;v=t;return is;}
std::ostream&operator<<(std::ostream& os,mintb v){os << v.val();return os;}
std::istream&operator>>(std::istream&is,mintb &v){long long t;is >> t;v=t;return is;}
istream &operator>>(istream &is, __int128_t &x) {
  string S;
  is >> S;
  x = 0;
  int flag = 0;
  for (auto &c : S) {
    if (c == '-') {
      flag = true;
      continue;
    }
    x *= 10;
    x += c - '0';
  }
  if (flag) x = -x;
  return is;
}
ostream &operator<<(ostream &os, __int128_t x) {
  if (x == 0) return os << 0;
  if (x < 0) os << '-', x = -x;
  string S;
  while (x) S.push_back('0' + x % 10), x /= 10;
  reverse(begin(S), end(S));
  return os << S;
}
template<typename T1,typename T2>ostream&operator<<(ostream&os,pair<T1,T2> v){os << '(' << v.first << ',' << v.second << ')';return os;}
template<typename T1,typename T2>istream&operator>>(istream&is,pair<T1,T2> &v){is >> v.first >> v.second;return is;}
template<typename T>istream&operator>>(istream&is,vector<T>&v){for(T&in:v)is>>in;return is;}
template<typename T>ostream&operator<<(ostream&os,vector<T>v){for(int i=0;i<int(v.size());i++)os<<v[i]<<(i+1!=v.size()?" ":"\n");return os;}
#define HAS_ACL 1
#else
#define HAS_ACL 0
#endif
using namespace std;
using ll=long long;
template <typename T1, typename T2>
struct ob2 {
    T1 a; T2 b;
    ob2() : a(), b() {}
    ob2(T1 a, T2 b) : a(a), b(b) {}
    friend auto operator<=>(const ob2&, const ob2&) = default;
    ob2 operator+(const ob2& o) const { return {a + o.a, b + o.b}; }
    ob2 operator-(const ob2& o) const { return {a - o.a, b - o.b}; }
    friend std::ostream& operator<<(std::ostream& os, const ob2& p) { 
        return os << "(" << p.a << ", " << p.b << ")"; 
    }
    friend std::istream& operator>>(std::istream& is, ob2& p) { 
        return is >> p.a >> p.b; 
    }
};

template <typename T1, typename T2, typename T3>
struct ob3 {
    T1 a; T2 b; T3 c;
    ob3() : a(), b(), c() {}
    ob3(T1 a, T2 b, T3 c) : a(a), b(b), c(c) {}
    friend auto operator<=>(const ob3&, const ob3&) = default;
    ob3 operator+(const ob3& o) const { return {a + o.a, b + o.b, c + o.c}; }
    ob3 operator-(const ob3& o) const { return {a - o.a, b - o.b, c - o.c}; }
    friend std::ostream& operator<<(std::ostream& os, const ob3& p) { 
        return os << "(" << p.a << ", " << p.b << ", " << p.c << ")"; 
    }
    friend std::istream& operator>>(std::istream& is, ob3& p) { 
        return is >> p.a >> p.b >> p.c; 
    }
};

template <typename T1, typename T2, typename T3, typename T4>
struct ob4 {
    T1 a; T2 b; T3 c; T4 d;
    ob4() : a(), b(), c(), d() {}
    ob4(T1 a, T2 b, T3 c, T4 d) : a(a), b(b), c(c), d(d) {}
    friend auto operator<=>(const ob4&, const ob4&) = default;
    ob4 operator+(const ob4& o) const { return {a + o.a, b + o.b, c + o.c, d + o.d}; }
    ob4 operator-(const ob4& o) const { return {a - o.a, b - o.b, c - o.c, d - o.d}; }
    friend std::ostream& operator<<(std::ostream& os, const ob4& p) { 
        return os << "(" << p.a << ", " << p.b << ", " << p.c << ", " << p.d << ")"; 
    }
    friend std::istream& operator>>(std::istream& is, ob4& p) { 
        return is >> p.a >> p.b >> p.c >> p.d; 
    }
};

template <typename T1, typename T2, typename T3, typename T4, typename T5>
struct ob5 {
    T1 a; T2 b; T3 c; T4 d; T5 e;
    ob5() : a(), b(), c(), d(), e() {}
    ob5(T1 a, T2 b, T3 c, T4 d, T5 e) : a(a), b(b), c(c), d(d), e(e) {}
    friend auto operator<=>(const ob5&, const ob5&) = default;
    ob5 operator+(const ob5& o) const { return {a + o.a, b + o.b, c + o.c, d + o.d, e + o.e}; }
    ob5 operator-(const ob5& o) const { return {a - o.a, b - o.b, c - o.c, d - o.d, e - o.e}; }
    friend std::ostream& operator<<(std::ostream& os, const ob5& p) { 
        return os << "(" << p.a << ", " << p.b << ", " << p.c << ", " << p.d << ", " << p.e << ")"; 
    }
    friend std::istream& operator>>(std::istream& is, ob5& p) { 
        return is >> p.a >> p.b >> p.c >> p.d >> p.e; 
    }
};

template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct ob6 {
    T1 a; T2 b; T3 c; T4 d; T5 e; T6 f;
    ob6() : a(), b(), c(), d(), e(), f() {}
    ob6(T1 a, T2 b, T3 c, T4 d, T5 e, T6 f) : a(a), b(b), c(c), d(d), e(e), f(f) {}
    friend auto operator<=>(const ob6&, const ob6&) = default;
    ob6 operator+(const ob6& o) const { return {a + o.a, b + o.b, c + o.c, d + o.d, e + o.e, f + o.f}; }
    ob6 operator-(const ob6& o) const { return {a - o.a, b - o.b, c - o.c, d - o.d, e - o.e, f - o.f}; }
    friend std::ostream& operator<<(std::ostream& os, const ob6& p) { 
        return os << "(" << p.a << ", " << p.b << ", " << p.c << ", " << p.d << ", " << p.e << ", " << p.f << ")"; 
    }
    friend std::istream& operator>>(std::istream& is, ob6& p) { 
        return is >> p.a >> p.b >> p.c >> p.d >> p.e >> p.f; 
    }
};
using ll = long long;
using ll2 = ob2<ll, ll>;
using ll3 = ob3<ll, ll, ll>;
using ll4 = ob4<ll, ll, ll, ll>;
using ll5 = ob5<ll, ll, ll, ll, ll>;
using ll6 = ob6<ll, ll, ll, ll, ll, ll>;
template<typename T> struct is_ob : std::false_type {};
template<typename... Ts> struct is_ob<ob2<Ts...>> : std::true_type {};
template<typename... Ts> struct is_ob<ob3<Ts...>> : std::true_type {};
template<typename... Ts> struct is_ob<ob4<Ts...>> : std::true_type {};
template<typename... Ts> struct is_ob<ob5<Ts...>> : std::true_type {};
template<typename... Ts> struct is_ob<ob6<Ts...>> : std::true_type {};
struct FastIO {
  char *p;
  char out_buf[1 << 21];
  int out_pos = 0;
  std::vector<char> fallback_buf;
  template<typename T> struct is_pair : std::false_type {};
  template<typename T, typename U> struct is_pair<std::pair<T,U>> : std::true_type {};
  FastIO() {
    struct stat st;
    if (isatty(0)) { p = nullptr; return; }
    if (fstat(0, &st) == 0 && st.st_size > 0) {
      void *res = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, 0, 0);
      if (res != MAP_FAILED) { p = (char*)res; return; }
    }
    setup_fallback();
  }
  void setup_fallback() {
    char buf[4096];
    while (true) {
      ssize_t len = read(0, buf, sizeof(buf));
      if (len <= 0) break;
      fallback_buf.insert(fallback_buf.end(), buf, buf + len);
    }
    if (!fallback_buf.empty()) { fallback_buf.push_back('\0'); p = fallback_buf.data(); }
    else p = nullptr;
  }
  ~FastIO() { flush(); }
  void flush() { if (out_pos > 0) { write(1, out_buf, out_pos); out_pos = 0; } }
  void write_char(char c) { out_buf[out_pos++] = c; if (out_pos >= (1<<20)) flush(); }
  // ---------- 入力 ----------
  template <typename T>
  void read_recursive(T &x) {
    if (!p) { cin >> x; return; }
    if constexpr (is_same_v<T, bool>) {
      long long t; read_recursive(t); x = (t != 0);
    } else if constexpr (
    #if HAS_ACL
      is_same_v<T, minta> || is_same_v<T, mintb>
    #else
      false
    #endif
    ) {
      long long t; read_recursive(t); x = t;
    } else if constexpr (is_same_v<T, __int128_t>) {
      x = 0; bool neg = false;
      while (p && *p && (*p < '0' || *p > '9') && *p != '-') p++;
      if (!p || !*p) return;
      if (*p == '-') { neg = true; p++; }
      while (*p >= '0' && *p <= '9') x = x * (__int128_t)10 + (*p++ - '0');
      if (neg) x = -x;
    } else if constexpr (is_same_v<T, uint64_t>) {
      x = 0;
      while (p && *p && (*p < '0' || *p > '9')) p++;
      if (!p || !*p) return;
      while (*p >= '0' && *p <= '9') x = x * (uint64_t)10 + (uint64_t)(*p++ - '0');
    } else if constexpr (is_same_v<T, char>) {
      while (p && *p && *p <= ' ') p++;
      if (p && *p) x = *p++;
    } else if constexpr (is_integral_v<T>) {
      x = 0; bool neg = false;
      while (p && *p && (*p < '0' || *p > '9') && *p != '-') p++;
      if (!p || !*p) return;
      if (*p == '-') { neg = true; p++; }
      while (*p >= '0' && *p <= '9') x = x * 10LL + (*p++ - '0');
      if (neg) x = -x;
    } else if constexpr (is_floating_point_v<T>) {
      while (p && *p && *p <= ' ') p++;
      if (!p || !*p) return;
      char *end; x = (T)strtod(p, &end); p = end;
    } else if constexpr (is_same_v<T, string>) {
      x.clear();
      while (p && *p && *p <= ' ') p++;
      if (!p || !*p) return;
      while (p && *p && *p > ' ') x += *p++;
    } else if constexpr (is_pair<T>::value) {
      read_recursive(x.first); read_recursive(x.second);
    } else if constexpr (is_same_v<T, vector<char>>) {
      // string と同様に空白区切りで1トークン読む
      x.clear();
      while (p && *p && *p <= ' ') p++;
      if (!p || !*p) return;
      while (p && *p && *p > ' ') x.push_back(*p++);
    } else if constexpr (is_same_v<T, vector<bool>>) {
      for (int i = 0; i < (int)x.size(); i++) { int t; read_recursive(t); x[i] = (bool)t; }
    } else if constexpr (is_ob<T>::value) {
      if constexpr (requires { x.a; }) read_recursive(x.a);
      if constexpr (requires { x.b; }) read_recursive(x.b);
      if constexpr (requires { x.c; }) read_recursive(x.c);
      if constexpr (requires { x.d; }) read_recursive(x.d);
      if constexpr (requires { x.e; }) read_recursive(x.e);
      if constexpr (requires { x.f; }) read_recursive(x.f);
    } else {
      for (auto &it : x) read_recursive(it);
    }
  }
  // ---------- 出力 ----------
  void write_int64(long long n) {
    if (n == 0) { write_char('0'); return; }
    if (n < 0) { write_char('-'); n = -n; }
    char tmp[20]; int t = 0;
    while (n > 0) { tmp[t++] = (char)((n % 10) + '0'); n /= 10; }
    for (int i = t-1; i >= 0; i--) write_char(tmp[i]);
  }
  void write_uint64(uint64_t n) {
    if (n == 0) { write_char('0'); return; }
    char tmp[20]; int t = 0;
    while (n > 0) { tmp[t++] = (char)((n % 10) + '0'); n /= 10; }
    for (int i = t-1; i >= 0; i--) write_char(tmp[i]);
  }
  void write_int128(__int128_t n) {
    if (n == 0) { write_char('0'); return; }
    if (n < 0) { write_char('-'); n = -n; }
    char tmp[40]; int t = 0;
    while (n > 0) { tmp[t++] = (char)((n % 10) + '0'); n /= 10; }
    for (int i = t-1; i >= 0; i--) write_char(tmp[i]);
  }
  void write_double(double x) {
    if (std::isnan(x)) { write_char('0'); return; }
    if (std::isinf(x)) { if (x < 0) write_char('-'); write_char('i'); write_char('n'); write_char('f'); return; }
    if (x < 0) { write_char('-'); x = -x; }
    if (x >= 9.2e18) {
      write_uint64((uint64_t)x); write_char('.');
      for (int i = 0; i < 15; i++) write_char('0');
      return;
    }
    double offset = 0.5;
    for (int i = 0; i < 15; i++) offset /= 10.0;
    x += offset;
    long long int_part = (long long)x;
    write_int64(int_part); write_char('.');
    double fraction = x - (double)int_part;
    for (int i = 0; i < 15; i++) {
      fraction *= 10; int d = (int)fraction;
      write_char('0' + d); fraction -= d;
    }
  }
  // const char* と char[] 用（セパレータなしで文字列として出力）
  void write_recursive(const char *x) { while (*x) write_char(*x++); }
  template <size_t N>
  void write_recursive(const char (&x)[N]) { for (size_t i = 0; i+1 < N && x[i]; i++) write_char(x[i]); }
  template <typename T>
  void write_recursive(const T &x) {
    if constexpr (is_same_v<T, bool>) {
      if (x) { write_char('Y'); write_char('e'); write_char('s'); }
      else   { write_char('N'); write_char('o'); }
    } else if constexpr (
    #if HAS_ACL
      is_same_v<T, minta> || is_same_v<T, mintb>
    #else
      false
    #endif
    ) {
      write_int64((long long)x.val());
    } else if constexpr (is_same_v<T, __int128_t>) {
      write_int128(x);
    } else if constexpr (is_same_v<T, uint64_t>) {
      write_uint64(x);
    } else if constexpr (is_same_v<T, char>) {
      write_char(x);
    } else if constexpr (is_floating_point_v<T>) {
      write_double((double)x);
    } else if constexpr (is_integral_v<T>) {
      write_int64((long long)x);
    } else if constexpr (is_same_v<T, string> || is_same_v<T, vector<char>>) {
      // vector<char> も string と同様セパレータなしで出力
      for (char c : x) write_char(c);
    } else if constexpr (is_pair<T>::value) {
      write_char('('); write_recursive(x.first);
      write_char(','); write_char(' '); write_recursive(x.second);
      write_char(')');
    } else if constexpr (is_ob<T>::value) {
      write_char('(');
      if constexpr (requires { x.a; }) { write_recursive(x.a); }
      if constexpr (requires { x.b; }) { write_char(','); write_char(' '); write_recursive(x.b); }
      if constexpr (requires { x.c; }) { write_char(','); write_char(' '); write_recursive(x.c); }
      if constexpr (requires { x.d; }) { write_char(','); write_char(' '); write_recursive(x.d); }
      if constexpr (requires { x.e; }) { write_char(','); write_char(' '); write_recursive(x.e); }
      if constexpr (requires { x.f; }) { write_char(','); write_char(' '); write_recursive(x.f); }
      write_char(')');
    } else {
      for (int i = 0; i < (int)x.size(); i++) {
        write_recursive(x[i]);
        if (i+1 != (int)x.size()) write_char(' ');
      }
    }
  }
} io;
template <typename... Args> void in(Args &...args) { (io.read_recursive(args), ...); }
template <typename... Args> void out(const Args &...args) {
  int n = sizeof...(Args), i = 0;
  ( (io.write_recursive(args), io.write_char(++i == n ? '\n' : ' ')), ... );
}
namespace for_debugging{
    struct subscript_and_location{
        int sub;
        std::source_location loc;
        template<class T> subscript_and_location(T sub_,std::source_location loc_=std::source_location::current()){
            if(!std::is_integral<T>::value){
                std::clog << loc_.file_name() << ":(" << loc_.line() << ":" << loc_.column() << "):" << loc_.function_name() << std::endl;
                std::clog << "subscript is not integer: subscript = " << sub_ << std::endl;
                exit(EXIT_FAILURE);
            }
            sub=sub_;
            loc=loc_;
        }
        void check_out_of_range(size_t sz){
            if(sub<0||(int)sz<=sub){
                std::clog << loc.file_name() << ":(" << loc.line() << ":" << loc.column() << "):" << loc.function_name() << std::endl;
                std::clog << "out of range: subscript = " << sub << ", vector_size = " << sz << std::endl;
                exit(EXIT_FAILURE);
            }
        }
    };
}
namespace std{
    template<class T,class Allocator=std::allocator<T>> class vector_for_debugging:public std::vector<T,Allocator>{
        using std::vector<T,Allocator>::vector;
        public:
            [[nodiscard]] constexpr std::vector<T,Allocator>::reference operator[](for_debugging::subscript_and_location n) noexcept(!std::is_same<T,bool>::value){
                n.check_out_of_range(this->size());
                return std::vector<T,Allocator>::operator[](n.sub);
            }
            [[nodiscard]] constexpr std::vector<T,Allocator>::const_reference operator[](for_debugging::subscript_and_location n) const noexcept(!std::is_same<T,bool>::value){
                n.check_out_of_range(this->size());
                return std::vector<T,Allocator>::operator[](n.sub);
            }
    };
    namespace pmr{
        template<class T> using vector_for_debugging=std::vector_for_debugging<T,std::pmr::polymorphic_allocator<T>>;
    }
}
#define vfd vector_for_debugging
/*//多倍長整数
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
namespace mp = boost::multiprecision;
// 任意長整数型
using Bint = mp::cpp_int;
 //仮数部が10進数で1024桁の浮動小数点数型(TLEしたら小さくする)
using Real = mp::number<mp::cpp_dec_float<1024>>;
*/
#define rep(i,n) for(long long i=0;i<(long long)n;i++)
#define reps(i,n) for(long long i=1;i<=(long long)n;i++)
#define repi(i,n) for(int i=0;i<(int)n;i++)
#define loop(i,l,r) for(long long i=(long long)l;i<=(long long)r;i++)
#define loopi(i,l,r) for(int i=(int)l;i<=(int)r;i++)
#define drep(i,n) for(long long i=(long long)n-1;i>=0;i--)
#define drepi(i,n) for(int i=(int)n-1;i>=0;i--)
#define dreps(i,n) for(int i=(int)n;i>=1;i--)
#define dloop(i,l,r) for(long long i=(long long)l;i>=(long long)r;i--)
#define dloopi(i,l,r) for(int i=(int)l;i>=(int)r;i--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define yna(x) cout << (x? "Yes":"No") << endl;
#define yn(x) out(bool(x));
#define cou(x) cout << x << endl;
#define emp emplace_back
#define mp make_pair
const long long moda=998244353LL;
const long long modb=1000000007LL;
const int kaz=1000000005;
long long yab=2500000000000000000LL;
const long long aho =-yab;
const long double eps=1.0e-14L;
const long double pi=acosl(-1.0L);
using st=string;
using P=pair<ll,ll>;
using tup=tuple<ll,ll,ll>;
using vi=vector<ll>;
using vin=vector<int>;
using vc=vector<char>;
using vb=vector<bool>;
using vd=vector<double>;
using vs=vector<string>;
using vp=vector<P>;
using sp=set<P>;
using si=set<ll>;
using vvi=vector<vector<ll>>;
using vvin=vector<vin>;
using vvc=vector<vc>;
using vvb=vector<vb>;
using vvvi=vector<vvi>;
using vvvin=vector<vvin>;
const int dx[4]={0,1,0,-1};
const int dy[4]={1,0,-1,0};
const vector<int> ex = {-1, -1, -1, 0, 0, 1, 1, 1};
const vector<int> ey = {-1, 0, 1, -1, 1, -1, 0, 1};
template<typename T1,typename T2>
void co(bool x,T1 y,T2 z){
  if(x)cout << y << endl;
  else cout << z << endl;
}
long long isqrt(long long n){
  long long ok=0,ng=1000000000;//1e9
  while(ng-ok>1){
    long long mid=(ng+ok)/2;
    if(mid*mid<=n)ok=mid;
    else ng=mid;
  }
  return ok;
}
template<typename T>
bool chmax(T &a, T b){
	if(a<b){
		a=b;
		return true;
	}
	return false;
}
template <typename T, typename U>
T ceil(T x, U y) {
  return (x > 0 ? (x + y - 1) / y : x / y);
}

template <typename T, typename U>
T floor(T x, U y) {
  return (x > 0 ? x / y : (x - y + 1) / y);
}
template<typename T,typename U>
pair<pair<T,T>,T> unit(T x, T y,U k){
	T s=floor(x-1,k);
	T t=floor(y,k);
  if(s==t)return make_pair(make_pair(0,0),-1);
	return make_pair(make_pair(s+1,t),1);
}
pair<pair<ll,ll>,int> jufuku(ll a,ll b,ll c,ll d){
	//a<=b,c<=dが保証されているとする
	if(a>c){
		swap(a,c);
		swap(b,d);
	}
	if(c>b)return make_pair(make_pair(0,0),-1);
	return make_pair(make_pair(c,min(b,d)),1);
}
template<typename T>
bool chmin(T &a, T b){
	if(a>b){
		a=b;
		return true;
	}
	return false;
}
template<typename T>
void her(vector<T> &a){
  for(auto &g:a)g--;
}
template <typename T>
void dec(vector<T> &t,T k=1){
  for(auto &i:t)i-=k;
}
template <typename T>
void inc(vector<T> &t,T k=1){
  for(auto &i:t)i+=k;
}
ll mypow(ll x,ll y,ll MOD){
	if(MOD==-1){
		MOD=9223372036854775807LL;
	}
	ll ret=1;
	while(y>0){
		if(y&1)ret=ret*x%MOD;
		x=x*x%MOD;
		y>>=1;
	}
	return ret;
}
struct UnionFind {
    vector<int> par,siz,mi,ma;
    UnionFind(int n) : par(n,-1), siz(n,1) {mi.resize(n);ma.resize(n);iota(mi.begin(),mi.end(),0);iota(ma.begin(),ma.end(),0); }
    int root(int x) {
      if(par[x]==-1)return x; 
      else return par[x]=root(par[x]); 
    }
    bool same(int x, int y) {
      return root(x)==root(y);
    }
    bool marge(int x, int y) {
      int rx = root(x), ry = root(y); 
      if (rx==ry) return false; 
			if(siz[rx]<siz[ry])swap(rx,ry);
      par[ry] = rx;
      siz[rx] += siz[ry];
			mi[rx]=min(mi[rx],mi[ry]);
			ma[rx]=max(ma[rx],ma[ry]);
      return true;
    }
    int size(int x) {
      return siz[root(x)];
    }
		int mini(int x){
			return mi[root(x)];
		}
		int maxi(int x){
			return ma[root(x)];
		}
};
ll nckmod;
vector<long long> fac,finv,invs;
// テーブルを作る前処理
void COMinit(int MAX,ll MOD) {
  nckmod=MOD;
	fac.resize(MAX);
	finv.resize(MAX);
	invs.resize(MAX);
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    invs[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        invs[i] = MOD - invs[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * invs[i] % MOD;
    }
}
// 二項係数計算
long long binom(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % nckmod) % nckmod;
}
template<typename T>
vector<ob3<int,int,T>> assyuku(vector<T> &v){
	vector<ob3<int,int,T>> ans;
	int sum=0;
	T pos=v[0];
	int n=v.size();
	for(int i=0;i<n;i++){
		if(v[i]==pos)sum++;
		else {
			ans.emplace_back(ob3(i-sum,i-1,pos));
			sum=1;
			pos=v[i];
		}
	}
	ans.emplace_back(ob3(n-sum,n-1,pos));
	return ans;
};
template<typename T,typename F>
vector<ob3<int,int,bool>> assyuku2(vector<T> &v,F f){
	vector<ob3<int,int,bool>> ans;
	int sum=0;
	bool pos=f(v[0]);
	int n=v.size();
	for(int i=0;i<n;i++){
		if(f(v[i])==pos)sum++;
		else {
		    ans.emplace_back(ob3(i-sum,i-1,pos));
			sum=1;
			pos=f(v[i]);
		}
	}
	ans.emplace_back(ob3(n-sum,n-1,pos));
	return ans;
};
#endif
int main(){
  cin.tie(nullptr);
  double a,b;in(a,b);
  a+=b;
  if(round(a)==a)out(round(a));
  else cout << fixed<<setprecision(20) << a << "\n";
}