#pragma region Macros
#pragma GCC target("avx", "avx2")
#pragma GCC optimize("-O3", "unroll-loops")
#include <bits/stdc++.h>
using namespace std;
// #include <atcoder/all>
// using namespace atcoder;
using ll= long long;
using ld= long double;
using i128= __int128;
using pll= pair<ll, ll>;
using vi= vector<int>;
using vl= vector<ll>;
using vd= vector<ld>;
using vs= vector<string>;
using vi128= vector<i128>;
using vb= vector<bool>;
using vpll= vector<pll>;
using vvi= vector<vi>;
using vvl= vector<vl>;
using vvd= vector<vd>;
using vvs= vector<vs>;
using vvi128= vector<vi128>;
using vvb= vector<vb>;
using vvpll= vector<vpll>;
// using mint= modint1000000007;
// using mint = modint998244353;
constexpr ll mod= 1e9 + 7;
// constexpr ll mod= 998244353;
#define ALL(x) (x).begin(), (x).end()
#define _overload(_1, _2, _3, name, ...) name
#define REPBASE(i, a, b) for(ll(i)= (a), (i##_b)= (b); (i) < (i##_b); (i)++)
#define RREPBASE(i, a, b) for(ll(i)= (a), (i##_b)= (b); (i) >= (i##_b); (i)--)
#define REPB(i, n) REPBASE(i, 0, n)
#define REPS(i, n) REPBASE(i, 1, n + 1)
#define RREP(i, n) RREPBASE(i, n - 1, 0)
#define RREPS(i, n) RREPBASE(i, n, 1)
#define REP(...) _overload(__VA_ARGS__, REPBASE, REPB)(__VA_ARGS__)
#define EACH(x, c) for(auto &x : c)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define SZ(x) ((ll)(x).size())
#define PERM(p)   \
    sort(ALL(p)); \
    for(bool(p##c)= 1; (p##c); (p##c)= next_permutation(ALL(p)))
#define VEC(name, size, ...)        \
    vector<__VA_ARGS__> name(size); \
    IN(name)
#define VV(name, h, w, ...)                                        \
    vector<vector<__VA_ARGS__>> name((h), vector<__VA_ARGS__>(w)); \
    IN(name)
#define LL(...)     \
    ll __VA_ARGS__; \
    IN(__VA_ARGS__)
#define STR(...)        \
    string __VA_ARGS__; \
    IN(__VA_ARGS__)
#define LD(...)     \
    ld __VA_ARGS__; \
    IN(__VA_ARGS__)
#define I128(...)     \
    i128 __VA_ARGS__; \
    IN(__VA_ARGS__)
void _scan() {}
template <class T, class S>
void _scan(pair<T, S> &p) {
    _scan(p.fi), _scan(p.se);
}
template <class T>
void _scan(T &a) {
    cin >> a;
}
void IN() {}
template <class Head, class... Tail>
void IN(Head &head, Tail &... tail) {
    _scan(head);
    IN(tail...);
}
ll BIT(const ll &n) { return (1LL << (n)); }
template <class T>
inline string YES(const T &n) {
    return ((n) ? "YES" : "NO");
}
template <class T>
inline string Yes(const T &n) {
    return ((n) ? "Yes" : "No");
}
template <class T>
inline string yes(const T &n) {
    return ((n) ? "yes" : "no");
}
template <class T>
inline void UNIQUE(vector<T> &v) {
    v.erase(unique(ALL(v)), v.end());
}
template <class T>
inline ll LB(const T &v, const ll x) {
    return distance((v).begin(), lower_bound(ALL(v), (x)));
}
template <class T>
inline ll UB(const T &v, const ll x) {
    return distance((v).begin(), upper_bound(ALL(v), (x)));
}
template <class T>
inline istream &operator>>(istream &stream, vector<T> &v) {
    EACH(x, v) stream >> x;
    return stream;
}
template <class T>
inline ostream &operator<<(ostream &stream, const vector<T> &v) {
    REP(i, SZ(v)) { stream << v[i] << (i == SZ(v) - 1 ? "" : " "); }
    return stream;
}
template <class T>
inline ostream &operator<<(ostream &stream, const vector<vector<T>> &v) {
    REP(i, SZ(v)) { stream << v[i] << (i == SZ(v) - 1 ? "" : "\n"); }
    return stream;
}
template <class T, class U>
inline istream &operator>>(istream &stream, pair<T, U> &p) {
    stream >> p.fi >> p.se;
    return stream;
}
template <class T, class U>
inline ostream &operator<<(ostream &stream, const pair<T, U> &p) {
    stream << p.fi << " " << p.se;
    return stream;
}
inline i128 parse(string &s) {
    reverse(ALL(s));
    i128 ret= 0;
    bool minus= 0;
    if(*(s.rbegin()) == '-') {
        minus= 1;
        s.pop_back();
    }
    while(!s.empty()) {
        if('0' <= *(s.rbegin()) && *(s.rbegin()) <= '9') {
            ret= ret * 10 + *(s.rbegin()) - '0';
            s.pop_back();
        } else {
            break;
        }
    }
    reverse(ALL(s));
    if(minus) ret*= -1;
    return ret;
}
inline string to_string(i128 val) {
    string ret= "";
    bool minus= 0;
    if(val < 0) {
        minus= 1;
        val*= -1;
    }
    do {
        int digit= val % 10;
        ret+= to_string(digit);
        val/= 10;
    } while(val != 0);
    if(minus) ret+= "-";
    reverse(ALL(ret));
    return ret;
}
inline istream &operator>>(istream &stream, i128 &val) {
    string str;
    stream >> str;
    val= parse(str);
    while(!str.empty()) {
        stream.putback(*(str.rbegin()));
        str.pop_back();
    }
    return stream;
}
inline ostream &operator<<(ostream &stream, const i128 &val) {
    stream << to_string(val);
    return stream;
}
template <class T>
inline bool chmax(T &a, const T &b) {
    if(a < b) {
        a= b;
        return 1;
    }
    return 0;
}
template <class T>
inline bool chmin(T &a, const T &b) {
    if(b < a) {
        a= b;
        return 1;
    }
    return 0;
}
ll TOPBIT(ll t) { return (t == 0 ? -1 : 63 - __builtin_clzll(t)); }
void debug_out() { cout << endl; }
template <class Head, class... Tail>
inline void debug_out(const Head &H, const Tail &... T) {
    cout << H << " ";
    debug_out(T...);
}
#ifdef _DEBUG
#define debug(...) debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
#pragma endregion

signed main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(12);
    cout << "Hello World!" << "\n";
}