#include <algorithm>
#include <array>
#include <bit>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <optional>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <vector>

#pragma region helpers

#pragma region math
static constexpr std::int32_t MODULO = 1000000007;

long pow(long base, long exp) {
  if (exp == 0) return 1;
  long half = pow(base, exp / 2);
  if (exp % 2 == 0) return half * half;
  return half * half * base;
}
#pragma endregion /* math */

#pragma region output
template <typename T, typename U>
std::ostream &operator<<(std::ostream &os, std::pair<T, U> const &p) {
  return os << p.first << " " << p.second;
}

template <typename C, typename T = typename std::enable_if<
                          !std::is_same<C, std::string>::value,
                          typename C::value_type>::type>
std::ostream &operator<<(std::ostream &os, const C &v) {
  std::string sep;
  for (const T &x : v) {
    os << sep << x, sep = " ";
  }

  return os;
}

template <typename T>
inline void answer(const T &ans) {
  std::cout << ans << "\n";
}

inline void yes() { std::cout << "YES\n"; }
inline void no() { std::cout << "NO\n"; }
inline void yesno(bool ans) { std::cout << (ans ? "YES" : "NO") << "\n"; }

#pragma region input
template <typename T>
std::vector<T> load_vector(std::size_t size) {
  std::vector<T> result{};

  for (auto i = 0u; i < size; ++i) {
    T x;
    std::cin >> x;
    result.push_back(std::move(x));
  }

  return result;
}
#pragma endregion /* input */


#define LOOP(var, n) for (auto var = 0; var < n; ++var)

#pragma endregion /* helpers */

// for ‹N› test cases, uncomment for single test case
// #define SINGLE

namespace solution {

using namespace std;

void solve() {
  // TODO
  dbg("Hello from debug");
  answer("Hello");
}

void tests() {
  // TODO
}

}  // namespace solution

using namespace solution;

#ifdef TEST

int main(void) {
  tests();
  return 0;
}

#else

int main(void) {
  int N = 1;

#ifndef SINGLE

  std::cin >> N;

#endif

  while (N-- > 0) {
    solve();
  }

  return 0;
}

#endif