#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
using namespace std;
const int64_t logn = 22;
const int64_t maxn = 1 << logn;
const double pi = acos(-1);
complex<double> w[maxn];
template <typename T>
void fft(T *in, T *out, int64_t n, int64_t k) {
  if (n == 1) {
    *out = *in;
    return;
  }
  n /= 2;
  fft(in, out, n, 2 * k);
  fft(in + k, out + n, n, 2 * k);
  for (int64_t i = 0; i < n; i++) {
    complex<double> t = w[i + n] * out[i + n];
    out[i + n] = out[i] - t;
    out[i] = out[i] + t;
  }
}
const int64_t mod = 1e4, len = 4;
void normalize(vector<int64_t> &ans) {
  int64_t carry = 0;
  for (int64_t i = 0; i < (int64_t)ans.size(); i++) {
    ans[i] += carry;
    carry = ans[i] / mod;
    ans[i] -= carry * mod;
  }
  if (carry) {
    ans.push_back(carry);
  }
  while (ans.back() == 0 && ans.size() > 1) {
    ans.pop_back();
  }
}
complex<double> sqr(complex<double> x) { return x * x; }
vector<int64_t> mul(vector<int64_t> a, vector<int64_t> b) {
  int64_t n = a.size() + b.size();
  if (n <= 500) {
    vector<int64_t> c(n - 1);
    for (int64_t i = 0; i < a.size(); i++) {
      for (int64_t j = 0; j < b.size(); j++) {
        c[i + j] += a[i] * b[j];
      }
    }
    normalize(c);
    return c;
  }
  while (__builtin_popcount(n) != 1) n++;
  while ((int64_t)a.size() < n) a.push_back(0);
  while ((int64_t)b.size() < n) b.push_back(0);
  vector<complex<double> > A(n);
  for (int64_t i = 0; i < n; i++) {
    A[i] = complex<double>(a[i], b[i]);
  }
  vector<complex<double> > nA(n);
  fft(A.data(), nA.data(), n, 1);
  for (int64_t i = 0; i < n; i++) {
    A[i] = (sqr(nA[i]) - sqr(conj(nA[(n - i) % n]))) / complex<double>(0, 4);
  }
  fft(A.data(), nA.data(), n, 1);
  reverse(begin(nA) + 1, end(nA));
  vector<int64_t> ans(n);
  for (int64_t i = 0; i < n; i++) {
    ans[i] = llround(real(nA[i]) / n);
  }
  normalize(ans);
  return ans;
}
vector<int64_t> ppow(vector<int64_t> x, int64_t n) {
  return n ? n % 2 ? mul(x, ppow(x, n - 1)) : ppow(mul(x, x), n / 2)
           : vector<int64_t>{1};
}
const int64_t loggn = 22;
vector<int64_t> pows[loggn];
string to_string(vector<int64_t> x) {
  stringstream ss;
  reverse(begin(x), end(x));
  ss << x[0];
  for (int64_t i = 1; i < (int64_t)x.size(); i++) {
    ss << setfill('0') << setw(len) << x[i];
  }
  return ss.str();
}
void print(vector<int64_t> x) { cout << to_string(x) << endl; }
bool les(const string &a, const string &b) {
  if (a.size() != b.size()) {
    return a.size() < b.size();
  } else {
    return a < b;
  }
}
vector<int64_t> mul(vector<int64_t> a, int64_t c) {
  for (auto &it : a) {
    it *= c;
  }
  normalize(a);
  return a;
}
signed main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  for (int64_t z = 1; z < maxn; z *= 2) {
    for (int64_t i = 0; i < z; i++) {
      w[z + i] = polar(1., pi * i / z);
      assert(z + i < maxn);
    }
  }
  pows[0] = {3};
  for (int64_t i = 1; i < loggn; i++) {
    pows[i] = mul(pows[i - 1], pows[i - 1]);
  }
  string control;
  cin >> control;
  if (control == "1") {
    cout << 1 << endl;
    return 0;
  } else if (control == "2") {
    cout << 2 << endl;
    return 0;
  }
  int64_t ans = 1e9;
  int64_t k =
      max<int64_t>(0, (int64_t)round(control.size() * log(10) / log(3)) - 3);
  vector<int64_t> cur = {1};
  assert(k >> loggn == 0);
  for (int64_t i = 0; i < loggn; i++) {
    if ((k >> i) & 1) {
      cur = mul(cur, pows[i]);
    }
  }
  while (!les(control, to_string(mul(cur, 9)))) {
    cur = mul(cur, 3);
    k++;
  }
  if (!les(to_string(mul(cur, 3)), control)) {
    ans = min(ans, 3 * k + 3);
  }
  if (!les(to_string(mul(cur, 2 * 2)), control)) {
    ans = min(ans, 3 * k + 2 + 2);
  }
  if (!les(to_string(mul(cur, 3 * 2)), control)) {
    ans = min(ans, 3 * k + 3 + 2);
  }
  if (!les(to_string(mul(cur, 3 * 3)), control)) {
    ans = min(ans, 3 * k + 3 + 3);
  }
  cout << ans << endl;
  return 0;
}
