#define MOD_IS_998 1 #if ! defined(ONLINE_JUDGE) && __has_include("template.hpp") #include "template.hpp" #else // template start #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; using ll = long long; using pall = pair; template using vec = vector; template using veve = vec>; using vell = vec; using vest = vec; using vebo = basic_string; using vevell = veve; template using mset = multiset; template using priority_queue_ascend = priority_queue, greater>; constexpr ll inf = numeric_limits::max(); const string sp = " "; const string lf = "\n"; inline const auto &npos = string::npos; const vec grid_move4 = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}}; const vec grid_move8 = [] { auto ret = grid_move4; ret.insert(ret.end(), {{-1, 1}, {-1, -1}, {1, -1}, {1, 1}}); return ret; }(); #define cont continue #define br break #define whlie while #define foR for #define reutnr return #define retunr return #define reutrn return #define auot auto #define uato auto #define cosnt const #define conts const #define ocnst const inline auto &ciN = cin; inline auto &icn = cin; inline auto &icN = cin; constexpr bool ture = true; constexpr bool flase = false; namespace rnages = ranges; namespace ra = ranges; using namespace atcoder; #define times(N) \ static_assert(is_integral_v, \ "times(): N must be integral"); \ assert((N) >= 0); \ for(typedef remove_cvref_t _int; \ [[maybe_unused]] const _int ii : views::iota((_int)0, (N))) #define tiems times #define itmes times template istream &operator>>(istream &in, static_modint &i) { ll tmp; in >> tmp; i = tmp; return in; } template ostream &operator<<(ostream &out, const static_modint &i) { return out << i.val(); } template istream &operator>>(istream &in, pair &p) { return in >> p.first >> p.second; } template ostream &operator<<(ostream &out, const pair &p) { return out << p.first << sp << p.second; } template istream &operator>>(istream &in, vec &v) { for(auto &&e : v) { in >> e; } return in; } struct debug_stream { template debug_stream &operator<<([[maybe_unused]] const T &x) { #ifndef ONLINE_JUDGE clog << x; #endif return *this; } debug_stream &operator<<([[maybe_unused]] ostream &(*f)(ostream &)) { #ifndef ONLINE_JUDGE clog << f; #endif return *this; } }; template concept out_stream = same_as || same_as; inline debug_stream clog_; #define clog clog_ template istream &in(Ts &...vecs) { static_assert(sizeof...(vecs) != 0, "myfunc::in(): At least one vector must be provided"); const set sizes = {vecs.size()...}; if(sizes.size() > 1) { throw invalid_argument("myfunc::in(): All vectors must have the same size"); } times(*sizes.begin()) { ((cin >> vecs[ii]), ...); } return cin; } void out(ranges::range auto v, const string delim, out_stream auto &out) { ranges::for_each(v, [&](const auto &e) { out << e << delim; }); } void out(ranges::range auto v, const string delim) { out(v, delim, cout); } inline void yes() noexcept { cout << "Yes" << lf; } inline void no() noexcept { cout << "No" << lf; } inline void yesu() noexcept { cout << "YES" << lf; } inline void nou() noexcept { cout << "NO" << lf; } // [mi, ma) [[nodiscard]] inline uint64_t randint(const uint64_t mi, const uint64_t ma) noexcept { static random_device seed; static mt19937_64 mt(seed()); if(mi > ma) [[unlikely]] return randint(ma, mi); if(mi == ma) [[unlikely]] return mi; const uint64_t w = ma - mi; uint64_t r; do { r = mt(); } while(mt.max() - mt.max() % w <= r); return r % w + mi; } template requires common_with [[nodiscard]] constexpr auto min(T &&a, U &&b) noexcept { return std::min>(std::forward(a), std::forward(b)); } template requires common_with [[nodiscard]] constexpr auto max(T &&a, U &&b) noexcept { return std::max>(std::forward(a), std::forward(b)); } template [[nodiscard]] auto reduce(const ranges::range auto &r, Args &&...args) { return reduce(ranges::cbegin(r), ranges::cend(r), forward(args)...); } [[nodiscard]] constexpr ll powll(ll a, ll b, const ll m = inf) { if(b < 0) [[unlikely]] throw invalid_argument("powll(): exponent less than zero"); if(m < 1) [[unlikely]] throw invalid_argument("powll(): modulo less than one"); a %= m; ll ret = 1; while(b) { if(b % 2) ret *= a, ret %= m; a *= a, a %= m; b /= 2; } return ret; } template requires assignable_from && totally_ordered_with bool mini(T &var, U &&val) noexcept { const bool cmp = var > val; if(cmp) var = val; return cmp; } template requires assignable_from && totally_ordered_with bool maxi(T &var, U &&val) noexcept { const bool cmp = var < val; if(cmp) var = val; return cmp; } class [[nodiscard]] grid_base { public: grid_base(const ll h, const ll w) noexcept : height(h), width(w) {} [[nodiscard]] ll operator()(const ll i, const ll j) const noexcept { if(! isvalid(i, j)) return -1; return i * width + j; } [[nodiscard]] ll operator()(const pall &p) const noexcept { return (*this)(p.first, p.second); } protected: bool isvalid(const ll i, const ll j) const noexcept { return 0 <= i && 0 <= j && i < height && j < width; } const ll height, width; }; class [[nodiscard]] grid_seen : public grid_base { public: grid_seen(const ll h, const ll w) : grid_base(h, w) { visited = vebo(h * w, false); } [[nodiscard]] bool &seen(const ll i, const ll j) & { if(! isvalid(i, j)) [[unlikely]] throw out_of_range("grid_seen::seen(): out of range"); return visited[i * width + j]; } [[nodiscard]] bool &sen(const ll i, const ll j) & { return seen(i, j); } [[nodiscard]] bool &seen(const pall &p) & { return seen(p.first, p.second); } [[nodiscard]] bool &sen(const pall &p) & { return seen(p); } private: vebo visited; }; using grid_lite = grid_base; template requires is_convertible_v::mapped_type> class default_map : public map { using Map = map; public: #ifdef __cpp_lib_associative_heterogeneous_insertion template U> requires requires(Map::key_compare c, Map::key_type t, U u) { c(t, u); c(u, t); } Map::mapped_type &operator[](const U &key) { Map::try_emplace(key, defval); return Map::operator[](key); } template U> requires requires(Map::key_compare c, Map::key_type t, U u) { c(t, u); c(u, t); } Map::mapped_type &operator[](const U &&key) { Map::try_emplace(key, defval); return Map::operator[](key); } #else Map::mapped_type &operator[](const Map::key_type &key) { Map::try_emplace(key, defval); return Map::operator[](key); } Map::mapped_type &operator[](const Map::key_type &&key) { Map::try_emplace(key, defval); return Map::operator[](key); } #endif }; template requires is_convertible_v::mapped_type> class default_unordered_map : public unordered_map { using Map = unordered_map; public: #ifdef __cpp_lib_associative_heterogeneous_insertion template requires requires(Map::hasher h, U u) { h(u); } Map::mapped_type &operator[](const U &key) { Map::try_emplace(key, defval); return Map::operator[](key); } template requires requires(Map::hasher h, U u) { h(u); } Map::mapped_type &operator[](const U &&key) { Map::try_emplace(key, defval); return Map::operator[](key); } #else Map::mapped_type &operator[](const Map::key_type &key) { Map::try_emplace(key, defval); return Map::operator[](key); } Map::mapped_type &operator[](const Map::key_type &&key) { Map::try_emplace(key, defval); return Map::operator[](key); } #endif }; template requires requires(mset::key_compare c, T t, U u) { c(t, u); } auto erase_single(mset &mset, U &&v) { const auto it = mset.find(v); if(it == mset.end()) [[unlikely]] throw invalid_argument("erase_single(): why v not in mset!?!?"); return mset.erase(it); } void solve(); // template end #endif #ifdef MOD_IS_998 constexpr ll MOD = 998244353; #else constexpr ll MOD = 1e9 + 7; #endif using mint = static_modint; int main(void) { cin.tie(nullptr); ios::sync_with_stdio(false); ll t = 1; // cin >> t; times(t) solve(); return 0; } void solve() { ll l, r; cin >> l >> r; cout << (l <= 295 && 296 <= r) + (l <= 416 && 417 <= r); }