#include <iostream>
#include <set>
#include <queue>
#include <vector>
#include <algorithm>
#include <math.h>
#include <cmath>
#include <string>
#include <cstring>
#include <climits>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
#include <tuple>
#include <numeric>
#include <assert.h>
#include <functional>
#include <unordered_map>
#include <cstdint>
#include <complex>

using namespace std;

/*-----------------------------------------------------------------------------
　定義
 -------------------------------------------------------------------------------*/
#define REP(i, n)				for (int (i) = 0 ; (i) < (int)(n) ; ++(i))
#define REPN(i, m, n)			for (int (i) = m ; (i) < (int)(n) ; ++(i))
#define INF						2e9
#define MOD						(1000 * 1000 * 1000 + 7)
#define Ceil(x, n)				(((((x))+((n)-1))/n))		/* Nの倍数に切り上げ割り算 */
#define CeilN(x, n)				(((((x))+((n)-1))/n)*n)		/* Nの倍数に切り上げ */
#define FloorN(x, n)			((x)-(x)%(n))				/* Nの倍数に切り下げ */
#define IsOdd(x)				(((x)&0x01UL) == 0x01UL)			
#define IsEven(x)				(!IsOdd((x)))						
#define ArrayLength(x)			(sizeof( x ) / sizeof( x[ 0 ]))
#define	MAX_QWORD				((QWORD)0xFFFFFFFFFFFFFFFF)
#define M_PI					3.14159265358979323846
typedef long long				ll;
typedef unsigned long long int	QWORD;
typedef unsigned long long		SQWORD;

/*-----------------------------------------------------------------------------
　幾何学ライブラリ
 -------------------------------------------------------------------------------*/
/* 基本要素 */
typedef double D;      // 座標値の型。doubleかlong doubleを想定
typedef complex<D> P;  // Point
typedef pair<P, P> L;  // Line
typedef vector<P> VP;
const D EPS = 1e-9;    // 許容誤差。問題によって変える
#define X real()
#define Y imag()
#define LE(n,m) ((n) < (m) + EPS)
#define GE(n,m) ((n) + EPS > (m))
#define EQ(n,m) (abs((n)-(m)) < EPS)
namespace std {
  bool operator<(const P a, const P b) {
    return a.X != b.X ? a.X < b.X : a.Y < b.Y;
  }
}

/*-----------------------------------------------------------------------------
　メイン
 -------------------------------------------------------------------------------*/
template<class T>
int getDivNum(T N, int div)
{
	int res = 0;
	while (N) {
		N /= div;
		if (N != 0)	res++;
	}
	return res;
}

/* 階乗 */
template<class T>
T power(int base, int powNum)
{
	T ans = 1;
	for (int i = 0; i < powNum; i++) {
		ans *= base;
	}
	return ans;
}

/* お金をおろす回数を取得 */
int getOrosuCnt(int okane, int bairitsu)
{
	int orosuCnt = 0;

	while (0 < okane) {
		// 一番大きい階乗でおろす、ここは貪欲
		int divNum = getDivNum<int>(okane, bairitsu);
		int powVal = power<int>(bairitsu, divNum);
		okane -= powVal;
		orosuCnt++;

		// 1乗未満になったら、1円でおろしておしまい
		if (okane < bairitsu) {
			orosuCnt+= okane;
			break;
		}
	}

	return orosuCnt;
}

int main()
{
/*
	一見、6 or 9の階乗の中で最も大きい金額で卸していけばいいようにみえるが、それじゃ合わない。
	例えば、14円を上記の方法で解くと、
		14 = 9の1乗×1回 ＋ 1円×5回
	となり、6回になる。ところが、
		14 = 6の1乗×2回 ＋ 1円×2回
	の、4回が正解。

	よって、6円で卸す金額と、9円で卸す金額のパターン全部試すしかない。
	上記だと、
		9円		6円		回数
		0		14		4
		1		13		4
				:
		9		5		6
		10		4		6
				：
	トータルの金額上限が100000なので、間に合う。
*/
	int ans = INF;
	int okaneTotal;
	cin >> okaneTotal;
	
	// 9 と 6の金額の引き出すパターンを全部試す
	for (int okaneNine = 0; okaneNine <= okaneTotal; okaneNine++) {
		int cnt = 0;
		int okaneSix = okaneTotal - okaneNine;
		cnt += getOrosuCnt(okaneNine, 9);
		cnt += getOrosuCnt(okaneSix, 6);
		ans = min(ans, cnt);
	}

	cout << ans << endl;
	return 0;
}


Measured memory_bytes: 256