#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using Graph = vector<vector<ll>>;
template <class T>
bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
  if (b < a) {
    a = b;
    return 1;
  }
  return 0;
}
vector<ll> dy = {0, 0, -1, 1, 0};
vector<ll> dx = {-1, 1, 0, 0, 0};
vector<ll> factorial = {};
vector<ll> factorialInverse = {};
vector<ll> INV(ll n) {
  vector<ll> v(n);
  for (ll i = 0; i < n; i++) cin >> v[i];
  return v;
}
vector<vector<ll>> INV2(ll n, ll map<ll, ll>) {
  vector<vector<ll>> v(n, vector<ll>(map<ll, ll>));
  for (ll i = 0; i < n; i++) {
    for (ll j = 0; j < map<ll, ll>; j++) {
      cin >> v[i][j];
    }
  }
  return v;
}
bool isOK(vector<ll> &v, int index, int key) {
  if (v[index] >= key)
    return true;
  else
    return false;
}
ll bs(vector<ll> &v, ll key) {
  int ng = -1;
  int ok = ((int)(v).size());
  while (abs(ok - ng) > 1) {
    int mid = (ok + ng) / 2;
    if (isOK(v, mid, key))
      ok = mid;
    else
      ng = mid;
  }
  return ok;
}
ll gcd(ll a, ll b) {
  if (a < b) swap(a, b);
  ll r = a % b;
  while (r != 0) {
    a = b;
    b = r;
    r = a % b;
  }
  return b;
}
void lcm(ll a, ll b) {}
bool is_prime(ll n) {
  bool flg = true;
  if (n <= 1)
    flg = false;
  else if (n == 2)
    flg = true;
  else if (n % 2 == 0)
    flg = false;
  else {
    for (ll i = 3; i * i <= n; i += 2) {
      if (n % i == 0) flg = false;
    }
  }
  return flg;
}
vector<ll> prime_factorization(ll n) {
  vector<ll> cnt_pf(sqrt(n), 0);
  for (ll i = 1; i < ((int)(cnt_pf).size()); i++) {
    while (n % (i + 1) == 0) {
      cnt_pf[i]++;
      n /= (i + 1);
    }
    if (n == 1) break;
  }
  if (n != 1) {
    cnt_pf[0] = n;
  }
  return cnt_pf;
}
vector<vector<ll>> map_vec(vector<string> &str) {
  vector<vector<ll>> v(
      ((int)(str).size()),
      vector<ll>(((int)(str[distance(str.begin(),
                                     max_element(str.begin(), str.end()))])
                      .size()),
                 (int)(1e9)));
  for (ll i = 0; i < ((int)(str).size()); i++) {
    for (ll j = 0; j < ((int)(str[i]).size()); j++) {
      if (str[i][j] == '#') v[i][j] = -1;
    }
  }
  return v;
}
ll cnt_wall(vector<string> str) {
  ll cnt = 0;
  for (ll i = 0; i < ((int)(str).size()); i++) {
    for (ll j = 0; j < ((int)(str[i]).size()); j++) {
      if (str[i][j] == '#') cnt++;
    }
  }
  return cnt;
}
ll bfs_maze(vector<string> &str, ll s_y, ll s_x, ll g_y, ll g_x) {
  struct Corr {
    ll y;
    ll x;
    ll depth;
  };
  queue<Corr> que;
  vector<vector<ll>> v(
      ((int)(str).size()),
      vector<ll>((
          (int)(str[distance(str.begin(), max_element(str.begin(), str.end()))])
              .size())));
  v = map_vec(str);
  que.push({s_y, s_x, 0});
  while (!que.empty()) {
    Corr now = que.front();
    que.pop();
    if (now.y == g_y && now.x == g_x) break;
    for (ll i = 0; i < 4; i++) {
      Corr next = {now.y + dy[i], now.x + dx[i], now.depth + 1};
      if (0 <= (int)next.y && (int)next.y < ((int)(v).size()) &&
          0 <= (int)next.x &&
          (int)next.x <
              ((int)(v[distance(v.begin(), max_element(v.begin(), v.end()))])
                   .size()) &&
          v[(int)next.y][(int)next.x] == (1e9)) {
        v[(int)next.y][(int)next.x] = next.depth;
        que.push(next);
      }
    }
  }
  return v[(int)g_y][(int)g_x];
}
vector<ll> cumulative_sum(vector<ll> a) {
  vector<ll> v(((int)(a).size()) + 1);
  v[0] = 0;
  for (ll i = 0; i < ((int)(a).size()); i++) {
    v[i + 1] = v[i] + a[i];
  }
  return v;
}
ll iterativePower(ll a, ll n) {
  ll res = 1;
  while (n > 0) {
    if (n & 1) res = (res * a) % 1000000007LL;
    a = a * a % 1000000007LL;
    n >>= 1;
  }
  return res;
}
vector<ll> MODInverse(ll n, ll factN) {
  vector<ll> res(n + 1);
  res[n] = iterativePower(factN, 1000000007LL - 2);
  for (ll i = n - 1; i >= 0; i--) {
    res[i] = res[i + 1] * (i + 1) % 1000000007LL;
  }
  return res;
}
void factorialFunc(ll n) {
  factorial.push_back(1);
  for (ll i = 1; i < n + 1; i++) {
    factorial.push_back(factorial[i - 1] * i % 1000000007LL);
  }
  vector<ll> fact;
  fact = MODInverse(n, factorial[n]);
  for (ll i = 0; i < n + 1; i++) {
    factorialInverse.push_back(fact[i]);
  }
}
ll comb(ll n, ll r) {
  if (n < r) return 0;
  return (factorial[n] * factorialInverse[r]) % 1000000007LL *
         factorialInverse[n - r] % 1000000007LL;
}
vector<pair<char, ll>> decompose_str(string set<ll>) {
  vector<pair<char, ll>> moji_cnt;
  moji_cnt.push_back(make_pair(set<ll>[0], 0));
  for (ll i = 0; i < ((int)(set<ll>).size()); i++) {
    if (moji_cnt.back().first == set<ll>[i]) {
      moji_cnt.back().second++;
    } else {
      moji_cnt.push_back(make_pair(set<ll>[i], 1));
    }
  }
  return moji_cnt;
}
void ans_vec(vector<ll> ans) {
  for (ll i = 0; i < ((int)(ans).size()); i++) {
    cout << ans[i] << " ";
  }
  cout << endl;
}
void dinamic_programming(void) {}
ll totalSumFirst(ll x, ll y) {
  x = x - 1;
  return (y * (y + 1) - x * (x + 1)) / 2;
}
ll totalSumSecond(ll x, ll y) {
  x = x - 1;
  return (y * (y + 1) * (2 * y + 1) - x * (x + 1) * (2 * x + 1)) / 6;
}
ll totalSumThird(ll x, ll y) { return pow(totalSumFirst(x, y), 2); }
vector<ll> makeDivisors(ll n) {
  vector<ll> divisors;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      divisors.push_back(i);
      if (i != n / i) {
        divisors.push_back(n / i);
      }
    }
  }
  sort(divisors.begin(), divisors.end());
  return divisors;
}
ll shakutori(vector<ll> &v, ll x) {
  ll res = 0;
  ll n = ((int)(v).size());
  ll sum = 0;
  ll right = 0;
  for (ll left = 0; left < n; left++) {
    while (right < n && sum + v[right] <= x) {
      sum += v[right];
      right++;
    }
    res += (right - left);
    if (right == left)
      right++;
    else
      sum -= v[left];
  }
  return res;
}
void dfs(const Graph &g, ll x) {}
void bfs() {}
void bitFullSearch(ll n) {
  for (ll bit = 0; bit < 1 << n; bit++) {
    vector<ll> vec;
    for (ll i = 0; i < n; i++) {
      if (bit >> i & 1) {
        vec.push_back(i);
      }
    }
  }
}
vector<ll> duplicateDeletion(vector<ll> vec) {
  sort(vec.begin(), vec.end());
  vec.erase(unique(vec.begin(), vec.end()), vec.end());
  return vec;
}
vector<string> split(string set<ll>, string delim) {
  if (set<ll>.empty()) return {};
  if (delim.empty()) return {set<ll>};
  int start = 0;
  auto delim_pos = set<ll>.find(delim);
  vector<string> ret_v;
  while (delim_pos != string::npos) {
    if (start != delim_pos)
      ret_v.push_back(set<ll>.substr(start, delim_pos - start));
    start = delim_pos + delim.size();
    delim_pos = set<ll>.find(delim, start);
  }
  if (start < set<ll>.size()) ret_v.push_back(set<ll>.substr(start));
  return ret_v;
}
signed main() {
  ll n;
  cin >> n;
  string ans;
  if (n < 10) {
    if (n == 2 || n == 4 || n == 5 || n == 7 || n == 9) {
      ans = "hon";
    } else if (n == 0 || n == 1 || n == 6 || n == 8) {
      ans = "pon";
    } else {
      ans = "bon";
    }
  } else if (n < 100) {
    n /= 10;
    if (n == 2 || n == 4 || n == 5 || n == 7 || n == 9) {
      ans = "hon";
    } else if (n == 0 || n == 1 || n == 6 || n == 8) {
      ans = "pon";
    } else {
      ans = "bon";
    }
  } else {
    n /= 100;
    if (n == 2 || n == 4 || n == 5 || n == 7 || n == 9) {
      ans = "hon";
    } else if (n == 0 || n == 1 || n == 6 || n == 8) {
      ans = "pon";
    } else {
      ans = "bon";
    }
  }
  cout << ans << "\n";
  ;
  return 0;
}
