Gerald has been selling state secrets at leisure. All the secrets cost the same: n marks. The state which secrets Gerald is selling, has no paper money, only coins. But there are coins of all positive integer denominations that are powers of three: 1 mark, 3 marks, 9 marks, 27 marks and so on. There are no coins of other denominations. Of course, Gerald likes it when he gets money without the change. And all buyers respect him and try to give the desired sum without change, if possible. But this does not always happen.

One day an unlucky buyer came. He did not have the desired sum without change. Then he took out all his coins and tried to give Gerald a larger than necessary sum with as few coins as possible. What is the maximum number of coins he could get?

The formal explanation of the previous paragraph: we consider all the possible combinations of coins for which the buyer can not give Gerald the sum of n marks without change. For each such combination calculate the minimum number of coins that can bring the buyer at least n marks. Among all combinations choose the maximum of the minimum number of coins. This is the number we want.


-----Input-----

The single line contains a single integer n (1 ≤ n ≤ 10^17).

Please, do not use the %lld specifier to read or write 64 bit integers in С++. It is preferred to use the cin, cout streams or the %I64d specifier.


-----Output-----

In a single line print an integer: the maximum number of coins the unlucky buyer could have paid with.


-----Examples-----
Input
1

Output
1

Input
4

Output
2



-----Note-----

In the first test case, if a buyer has exactly one coin of at least 3 marks, then, to give Gerald one mark, he will have to give this coin. In this sample, the customer can not have a coin of one mark, as in this case, he will be able to give the money to Gerald without any change.

In the second test case, if the buyer had exactly three coins of 3 marks, then, to give Gerald 4 marks, he will have to give two of these coins. The buyer cannot give three coins as he wants to minimize the number of coins that he gives.

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Greedy algorithms


Solutions:
n = int(input())
while not n % 3:
	n //= 3
print(n // 3 + 1)


n = int(input())
a = 1
while n % a == 0:
	a *= 3
print((n - 1) // a + 1)


from fractions import Decimal
import math
n = Decimal(input())
d = Decimal('1')
while n % d == 0:
	d *= 3
if d > n:
	print(1)
else:
	print(math.ceil(n / d))


n = int(input())
x = 1
while True:
	l = 0
	r = 10 ** 18
	while r > l + 1:
		m = (l + r) // 2
		if x * m < n:
			l = m
		else:
			r = m
	if r * x > n:
		print(r)
		return
	x *= 3


def main():
	(n, p) = (int(input()), 3)
	while not n % p:
		p *= 3
	print(n // p + 1)

def __starting_point():
	main()
__starting_point()


n = int(input())
c = 0
while not n % 3:
	n //= 3
print((n + 2) // 3)


import math
n = int(input())
k = 1
while n % k == 0:
	k *= 3
print(n // k + 1)


import sys
from math import *
from fractions import gcd
readints = lambda : map(int, input().strip('\n').split())
n = int(input())
b = 1
ans = 1
while b < n:
	if n % b != 0:
		ans = max(ans, n // b + 1)
	b *= 3
print(ans)


def main():
	n = int(input())
	while n % 3 == 0:
		n //= 3
	print(n // 3 + 1)
main()


def f(n):

	def toTri(x):
		if x <= 2:
			return [x]
		l = toTri(x // 3)
		l.append(x % 3)
		return l
	digits = toTri(n)
	for i in range(len(digits) - 1, -1, -1):
		if digits[i] != 0:
			break
	coins = 1
	mul = 1
	for j in range(i - 1, -1, -1):
		coins += mul * digits[j]
		mul *= 3
	return coins
n = int(input())
print(f(n))


n = int(input())
t = 1
while n % t == 0:
	t *= 3
print(n // t + 1)


(n, f) = (int(input()), 3)
while n % f == 0:
	f *= 3
print(n // f + 1)


from math import ceil

def seal(a, b):
	return (a + b - 1) // b
n = int(input())
i = 0
while n % pow(3, i) == 0:
	i += 1
print(seal(n, pow(3, i)))


(n, k) = (int(input()), 3)
while n % k == 0:
	k *= 3
print(n // k + 1)


from math import ceil
n = int(input())
i = 0
while True:
	if n % 3 ** i != 0:
		print(n // 3 ** i + 1)
		exit()
	i += 1


n = int(input())
r = 3
while 1:
	if n % r:
		print((n - 1) // r + 1)
		break
	else:
		r *= 3


def secrets(n):
	count = 1
	while n % count == 0:
		count *= 3
	return n // count + 1
print(secrets(int(input())))


n = int(input())
if n % 3 == 0:
	x = 9
	while n % x == 0:
		x *= 3
	print(n // x + 1)
else:
	print(n // 3 + 1)


def readln():
	return tuple(map(int, input().split()))
(n,) = readln()
p3 = []
t = n
while t:
	p3.append(t % 3)
	t //= 3
for i in range(len(p3)):
	if p3[i]:
		p3[i] -= 1
		tmp = 1 + sum([v * 3 ** j for (j, v) in enumerate(p3[i + 1:])])
		while p3[i] and 3 ** i * (p3[i] - 1) + 3 ** (i + 1) * tmp > n:
			p3[i] -= 1
		print(max(1, p3[i] + tmp))
		break


n = int(input())
m = 3
while n % m == 0:
	m *= 3
print(int(n // m + 1))


n = int(input())
p = 1
while n % p == 0:
	p *= 3
print(n // p + 1)


def base10to3(num):
	ret = ''
	while num > 0:
		ret = ret + str(num % 3)
		num = num // 3
	return ret[::-1]
inp = input()
N = int(inp)
s3 = base10to3(N)[::-1]
for i in range(len(s3)):
	if s3[i] != '0':
		break
p = 3 ** (i + 1)
ans = N // p
if N % p != 0:
	ans += 1
print(ans)


(base, n) = (1, int(input()))
while n % base == 0:
	base *= 3
print(n // base + 1)


i = int(input())
k = 1
while i % k == 0:
	k = k * 3
print(i // k + 1)


import math, decimal
n = int(input())
k = 0
while n % 3 ** k == 0:
	k += 1
D = decimal.Decimal
print(math.ceil(D(n) / D(3 ** k)))


from math import ceil
from decimal import Decimal
n = Decimal(input())
a = Decimal(1)
while n % a == 0:
	a *= 3
print(ceil(n / a))


import sys
from math import *

def solve():
	n = int(input())
	p = 1
	while n % p == 0:
		p *= 3
	print(n // p + 1)
solve()


import math
n = int(input())
a = 1
while n % a == 0:
	a *= 3
print(n // a + 1)