#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
from collections import deque, Counter
import heapq
from itertools import permutations
from math import sin, cos, tan, asin, acos, atan, gcd
from decimal import Decimal
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10**7)


class Data():
    def __init__(self):
        self.power = 1
        self.rev = 1


class Combi():
    def __init__(self, N, mod):
        self.lists = [Data() for _ in range(N + 1)]
        self.mod = mod
        for i in range(2, N + 1):
            self.lists[i].power = ((self.lists[i - 1].power) * i) % self.mod
        self.lists[N].rev = pow(self.lists[N].power, self.mod - 2, self.mod)
        for j in range(N, 0, -1):
            self.lists[j - 1].rev = ((self.lists[j].rev) * j) % self.mod

    def combi(self, K, R):
        if K < R:
            return 0
        else:
            return ((self.lists[K].power) * (self.lists[K - R].rev) * (self.lists[R].rev)) % self.mod


def warshall_floyd(d):
    n = len(d[0])
    for i in range(n + 1):
        for j in range(n + 1):
            d[i][j] = 0
    for k in range(1, n + 1):
        for i in range(1, n + 1):
            for j in range(1, n + 1):
                d[i][j] = min(d[i][j], d[i][k] + d[k][j])
    return d


def bellman_ford(s, graph):
    n = len(graph)
    dist = [10**20 for i in range(n + 1)]
    dist[s] = 0
    for i in range(1, n + 1):
        flag = False
        for some in graph:
            a, b, d = some[0], some[1], some[2]
            newlen = dist[a] + d
            if newlen < dist[b]:
                flag = True
                dist[b] = newlen
        if not flag:
            break
        if i == n:
            return False
    return dist


def dijkstra(s, graph):
    n = len(graph)
    dist = [10**20 for i in range(n + 1)]
    dist[s] = 0
    pq = []
    heapq.heapify(pq)
    heapq.heappush(pq, (0, s))
    while pq:
        x = heapq.heappop(pq)
        node, mini_dis = x[1], x[0]
        for point in graph[node].keys():
            w = graph[node][point]
            newlen = dist[node] + w
            if newlen < dist[point]:
                heapq.heappush(pq, (newlen, point))
                dist[point] = newlen
    return dist


def prime_list(N):
    prime = {i for i in range(2, N)}
    for i in range(2, N):
        if i in prime:
            for j in range(i * 2, N, i):
                if j in prime:
                    prime.remove(j)
    return prime


def xgcd(a, b):
    x0, y0, x1, y1 = 1, 0, 0, 1
    while b != 0:
        q, a, b = a // b, b, a % b
        x0, x1 = x1, x0 - q * x1
        y0, y1 = y1, y0 - q * y1
    return a, x0, y0


def modinv(a, m):
    g, x, y = xgcd(a, m)
    if g != 1:
        return False
    else:
        return x % m


def LIS(lists):
    N = len(lists)
    inf = 10**15
    dp = [inf for i in range(N + 1)]
    for i in range(N):
        index = bisect.bisect_left(dp, lists[i])
        dp[index] = lists[i]
    for i in range(N + 1):
        if dp[i] == inf:
            return i
            break


def super_factorization(N):
    spf = [i for i in range(N + 1)]
    prime = {i for i in range(2, N + 1)}
    for i in range(2, N + 1):
        if i in prime:
            for j in range(i * 2, N + 1, i):
                if j in prime:
                    spf[j] = i
                    prime.remove(j)
    result = [{} for _ in range(N + 1)]
    for i in range(2, N + 1):
        div = spf[i]
        if div == 1:
            result[i] = {i: 1}
        else:
            y = i // div
            result[i] = result[y].copy()
            if div in result[i].keys():
                result[i][div] += 1
            else:
                result[i][div] = 1
    return result


def trans(x, k):
    string = ""
    while x != 0:
        u, v = divmod(x, k)
        string = str(v) + string
        x = u
    return string


def union_lcm(lists):
    if len(lists) == 1:
        return lists[0]
    elif len(lists) > 1:
        num = lists[0]
        for i in range(1, len(lists)):
            num = num * lists[i] // fractions.gcd(num, lists[i])
        return num


def union_gcd(lists):
    if len(lists) == 1:
        return lists[0]
    elif len(lists) > 1:
        num = lists[0]
        for i in range(1, len(lists)):
            num = fractions.gcd(num, lists[i])
        return num


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * (n + 1)

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return ''.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

class UnionFindLabel(UnionFind):
    def __init__(self, labels):
        assert len(labels) == len(set(labels))

        self.n = len(labels)
        self.parents = [-1] * self.n
        self.d = {x: i for i, x in enumerate(labels)}
        self.d_inv = {i: x for i, x in enumerate(labels)}

    def find_label(self, x):
        return self.d_inv[super().find(self.d[x])]

    def union(self, x, y):
        super().union(self.d[x], self.d[y])

    def size(self, x):
        return super().size(self.d[x])

    def same(self, x, y):
        return super().same(self.d[x], self.d[y])

    def members(self, x):
        root = self.find(self.d[x])
        return [self.d_inv[i] for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [self.d_inv[i] for i, x in enumerate(self.parents) if x < 0]


class BIT:
    def __init__(self, n):
        self.n = n
        self.data = [0] * (n + 1)

    def to_sum(self, i):
        s = 0
        while i > 0:
            s += self.data[i]
            i -= (i & -i)
        return s

    def add(self, i, x):
        while i <= self.n:
            self.data[i] += x
            i += (i & -i)

    def get(self, i, j):
        return self.to_sum(j) - self.to_sum(i - 1)

#start coding here...


N=int(input())
N=N%10
if N in [2,4,5,7,9]:
    print("hon")
elif N in [0,1,6,8]:
    print("pon")
elif N in [3]:
    print("bon")



Measured memory_bytes: 9972