/**
#pragma GCC optimize("O3")
/* */

#include <bits/stdc++.h>

/**/ // ACL
#include <atcoder/all>
using namespace atcoder;
// ACL END */

/** // Boost BigInteger
#include <boost/multiprecision/cpp_int.hpp>
using bint = boost::multiprecision::cpp_int;
// Boost BigInteger END*/

#define int LL

#define override_rep(i, l, r, mes, ...) mes
#define rep1(i, n) for (int i = 0; i < n; i++)
#define rep2(i, l, r) for (int i = l; i < r; i++)
#define rep(...) override_rep(__VA_ARGS__, rep2, rep1)(__VA_ARGS__)

using namespace std;

using LL = long long;
using LD = double;
using P = std::pair<int, int>;
constexpr int MOD = 1e9 + 7;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};

template<typename T, typename U>
inline bool chmin(T& a, U b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}
template<typename T, typename U>
inline bool chmax(T& a, U b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}
template<typename T, typename U>
inline std::istream& operator>>(std::istream& in, std::pair<T, U>& p) {
    in >> p.first >> p.second;
    return in;
}
template<typename T>
int binarySearch(int ng, int ok, T isOK) {
    while (std::abs(ok - ng) > 1) {
        int mid = (ok + ng) / 2;
        if (isOK(mid))
            ok = mid;
        else
            ng = mid;
    }
    return ok;
}
template<typename T>
std::map<T, int> compress(std::vector<T>& base_list) {
    std::sort(base_list.begin(), base_list.end());
    base_list.erase(std::unique(base_list.begin(), base_list.end()), base_list.end());
    std::map<T, int> ret;
    rep(i, base_list.size()) {
        ret[base_list[i]] = i;
    }
    return ret;
}
std::vector<int> topologicalSort(const std::vector<std::vector<int>>& graph, bool& flag) {
    std::vector<int> memo(graph.size(), 0);
    for (const auto& vec : graph) {
        for (auto it : vec) {
            memo[it]++;
        }
    }
    std::vector<int> ret(graph.size());
    int cnt = 0, bcnt = 0;
    for (int i = 0; i < graph.size(); i++) {
        if (memo[i] == 0) ret[cnt++] = i;
    }
    if (bcnt + 1 < cnt) flag = true;
    bcnt = cnt;
    for (int i = 0; i < graph.size(); i++) {
        for (auto it : graph[ret[i]]) {
            memo[it]--;
            if (memo[it] == 0) ret[cnt++] = it;
        }
        if (bcnt + 1 < cnt) flag = true;
        bcnt = cnt;
    }
    return ret;
}

class HeavyLightDecomposition {
  public:
    std::vector<std::vector<int>> g;
    int n, t;
    std::vector<int> sz, in, nxt, out, parent, depth;
    void dfs_sz(int v, int par) {
        sz[v] = 1;
        for (auto& u : g[v])
            if (u != par) {
                dfs_sz(u, v);
                sz[v] += sz[u];
                if (g[v][0] == par || sz[u] > sz[g[v][0]]) {
                    std::swap(u, g[v][0]);
                }
            }
    }

    void dfs_hld(int v, int par) {
        in[v] = t++;
        for (auto u : g[v])
            if (u != par) {
                nxt[u] = (u == g[v][0] ? nxt[v] : u);
                parent[u] = (u == g[v][0] ? parent[v] : v);
                depth[u] = (u == g[v][0] ? depth[v] : depth[v] + 1);
                dfs_hld(u, v);
            }
        out[v] = t;
    }

  public:
    HeavyLightDecomposition(const std::vector<std::vector<int>>& g) : g(g), n(g.size()), t(0), sz(n), in(n), nxt(n), out(n), parent(n), depth(n) {
        depth[0] = 0;
        dfs_sz(0, -1);
        dfs_hld(0, -1);
    }
};
class BIT {
    std::vector<int> dat;
    int siz;

  public:
    BIT() = default;
    BIT(int siz) : siz(siz), dat(siz + 1, 0) {}
    int sum(int i) {
        int s = 0;
        while (i > 0) {
            s += dat[i];
            i -= i & -i;
        }
        return s;
    }
    void add(int i, int x) {
        while (i <= siz) {
            dat[i] += x;
            i += i & -i;
        }
    }
};
struct IoInit {
    IoInit() {
        std::cin.tie(nullptr);
        std::cout.tie(nullptr);
        std::ios::sync_with_stdio(false);
        std::cout << std::fixed << std::setprecision(16);
    }
} io_init;

std::vector<unsigned long long> makeDivisors(unsigned long long n) {
    std::vector<unsigned long long> re;
    for (int i = 1; i < std::sqrt(n) + 1; ++i) {
        if (n % i == 0) {
            re.push_back(i);
            if (i != n / i) re.push_back(n / i);
        }
    }
    return re;
}

signed main() {
    // https://twitter.com/vane11ope ←フォローしましょう
    // (ノ)>◡<(ヾ)ﾓﾁﾓﾁ

    int n;
    cin>>n;
    rep(i,n)cout<<"Hello! You're new here, right? It's nice to meet you.\n";
}