Submission #65852240

---

Source Code Expand

// clang-format off

#ifdef LOCAL
#include"/home/aoriika/kyopro/atcoder/all.h"
#else
#include<bits/stdc++.h>
#ifdef ATCODER
#include<atcoder/all>
#endif  // ATCODER
#endif  // LOCAL

/* accelration */
#ifdef ONLINE_JUDGE
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
// struct Fast {Fast() {cin.tie(nullptr); ios::sync_with_stdio(false); cout<<fixed<<setprecision(20);}} fast;

/* alias */
// type
using ull = unsigned long long;
using ll = long long;
using ld = long double;
// pair
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
// vector
using vi = std::vector<int>;
using vll = std::vector<ll>;
using vs = std::vector<std::string>;
using vpii = std::vector<pii>;
using vpll = std::vector<pll>;
template<class T> using vv = std::vector<std::vector<T>>;
// unordered set
using usi = std::unordered_set<int>;
using usll = std::unordered_set<ll>;
using uss = std::unordered_set<std::string>;
template<class T, class U> using um = std::unordered_map<T, U>;

/* define short */
#define pb push_back
#define mp make_pair
#define all(...) std::begin(__VA_ARGS__), std::end(__VA_ARGS__)
#define rall(...) std::rbegin(__VA_ARGS__), std::rend(__VA_ARGS__)

/* REP macro */
#define OVERLOAD_REP(_1, _2, _3, name, ...) name
#define REP1(i, n) for (auto i = std::decay_t<decltype(n)>{}; (i) != (n); ++(i))
#define REP2(i, l, r) for (auto i = (l); (i) != (r); ++(i))
#define rep(...) OVERLOAD_REP(__VA_ARGS__, REP2, REP1)(__VA_ARGS__)
#define repd(i,n) for(ll i=n-1;i>=0;i--)
#define rrepd(i,n) for(ll i=n;i>=1;i--)

/* debug */
#ifdef LOCAL
#define debug(x) std::cerr << "\033[33m(line:" << __LINE__ << ") " << #x << ": " << x << "\033[m" << std::endl;
#else
#define debug(x)
#endif

/* func */
inline int in_int() {
    int ret = 0, sgn = 1;
    int ch = getchar_unlocked();
    while (std::isspace(ch)) { ch = getchar_unlocked(); }
    if (ch == '-') { sgn = -1; ch = getchar_unlocked(); }
    for (; std::isdigit(ch); ch = getchar_unlocked())
        ret = (ret * 10) + (ch - '0');
    std::ungetc(ch, stdin);
    return sgn * ret;
}
inline ll in_ll() {    
    ll ret = 0;
    int ch = getchar_unlocked(), sgn = 1;
    while (std::isspace(ch)) { ch = getchar_unlocked(); }
    if (ch == '-') { sgn = -1; ch = getchar_unlocked(); }
    for (; std::isdigit(ch); ch = getchar_unlocked())
        ret = (ret * 10) + (ch - '0');
    std::ungetc(ch, stdin);
    return sgn * ret;
}
inline std::string in_str(size_t buf = 64) {
    std::string x;
    int ch = getchar_unlocked();
    x.reserve(buf);
    while (std::isspace(ch)) { ch = getchar_unlocked(); }
    for(; !std::isspace(ch); ch = getchar_unlocked())
        x.push_back((char)ch);
    return x;
}
inline double in_double() {return std::stod(in_str());}
constexpr inline int ctoi(const char c) {return c - '0';}
constexpr vi Eratosthenes(const int N){
    std::vector<bool> is_prime(N + 1, true); vi P;
    rep(i,2,N+1){
        if( is_prime[i] ){
            for( int j = 2 * i; j <= N; j += i ){ is_prime[j] = false; } P.emplace_back(i);
        }
    } return P;
}
constexpr vpll prime_factorize(const ll N) {
    vpll res;
    ll n = N;
    for (ll a = 2; a * a <= N; ++a) {
        if (N % a != 0) continue;
        ll ex = 0; while (N % a == 0) { ++ex; n/=a; }
        res.push_back({a, ex});
    }
    if (N != 1) res.push_back({N,1});
    return res;
}
// !!! DEPEND ON NULL TERMINATION !!!
inline void print(const char *ptr, const std::string &end = "\n") {
    for(int i=0;ptr[i]!='\0';i++) putchar_unlocked((int)ptr[i]);
    for(auto c:end) putchar_unlocked((int)c);
}
inline void print(const std::string &x, const std::string &end = "\n") {print(x.data(), end);}
template <std::integral T> inline void print(const T x, const std::string &end = "\n")
{
    char buf[32];
    std::to_chars_result result = std::to_chars(&(buf[0]), &(buf[31]), x);
    if(result.ec != std::errc{}) exit(1);
    *result.ptr = '\0';
    print(buf, end);
}
template <std::floating_point T> inline void print(const T x, const std::string &end = "\n")
{
    char buf[32];
    std::to_chars_result result = std::to_chars(&(buf[0]), &(buf[31]), x, std::chars_format::fixed, 20);
    if(result.ec != std::errc{}) exit(1);
    *result.ptr = '\0';
    print(buf, end);
}
template <typename T> inline void print(const std::vector<T>& v, const std::string &s = " ")
    {for(int i=0;i<ssize(v);i++) print(v[i], (i==ssize(v)-1 ? "\n" : s));}
template <typename T> inline void print(const vv<T>& v, const std::string &s = " ")
    {for(auto e:v) print(e, s);}
template <typename T, typename S> inline void print(const std::pair<T, S>& p)
    {print(p.first, " "); print(p.second);}
template <typename T, typename S> inline void print(const std::vector<std::pair<T, S>>& v)
    {for (auto&& p : v) print(p);}
template <typename T, typename S> inline void print(const std::map<T, S>& m)
    {for (auto&& p : m) print(p);}
template <typename T> inline bool chmin(T& a, const T& b) {bool compare = a > b; if (a > b) a = b; return compare;}
template <typename T> inline bool chmax(T& a, const T& b) {bool compare = a < b; if (a < b) a = b; return compare;}

// clang-format on
using namespace std;

int main()
{
    int A = in_int(), B = in_int(), C = in_int(), D = in_int();
    if (A < C)
        print("No\0");
    else if (A == C && B < D)
        print("No\0");
    else
        print("Yes\0");
    return 0;
}

Submission Info

Judge Result