#include <iostream>
#include <vector>
using namespace std;

class BigNum64 {
private:
	vector<unsigned long long> cyfry;
	long long mod;
	
public:
	BigNum64() {
		mod = 1e9;
	}
	
	BigNum64(unsigned long long liczba) {
		mod = 1e9;
		if (liczba == 0)
			cyfry.push_back(0);
		while (liczba > 0) {
			cyfry.push_back(liczba % mod);
			liczba /= mod;
		}
	}
	
	BigNum64& operator= (unsigned long long liczba) {
		cyfry.clear();
		if (liczba == 0)
			cyfry.push_back(0);
		while (liczba > 0) {
			cyfry.push_back(liczba % mod);
			liczba /= mod;
		}
		return *this;
	}
	
	unsigned long long wartosc() const {
		unsigned long long wynik = 0;
		for (int i = dlugosc() - 1; i >= 0; --i)
			wynik = wynik * mod + cyfry[i];
		return wynik;
	}
	
	unsigned long long& operator[](int pozycja) {
		return cyfry[pozycja];
	}
	
	int dlugosc() const {
		return cyfry.size();
	}
	
	BigNum64 operator+ (BigNum64 a) const {
		int i;
		BigNum64 c;
		c.cyfry.resize(max(dlugosc(), a.dlugosc()) + 1, 0);
		for (i = 0; i < max(dlugosc(), a.dlugosc()); ++i) {
			if (i < dlugosc())
				c[i] += cyfry[i];
			if (i < a.dlugosc())
				c[i] += a[i];
			if (c[i] >= mod) {
				c[i + 1]++;
				c[i] %= mod;
			}
		}
		c.usun_zera_wiodace();
		return c;
	}
	
	BigNum64 operator% (unsigned long long modulo) const {
		BigNum64 wyn;
		int i = 0;
		while (modulo >= mod && i < dlugosc()) {
			modulo /= mod;
			wyn.cyfry.push_back(cyfry[i]);
			i++;
		}
		if (i < dlugosc() && modulo > 1)
			wyn.cyfry.push_back(cyfry[i] % modulo);
		wyn.usun_zera_wiodace();
		return wyn;
	}
	
	BigNum64 operator* (BigNum64& a) const {
		int i, j;
		BigNum64 wyn;
		wyn.cyfry.resize(dlugosc() + a.dlugosc() + 1, 0);
		for (i = 0; i < dlugosc(); ++i)
			for (j = 0; j < a.dlugosc(); ++j) {
				wyn[i + j] += cyfry[i] * a.cyfry[j];
				unsigned long long pom = wyn[i + j];
				wyn[i + j] %= mod;
				pom /= mod;
				wyn[i + j + 1] += pom;
			}
		wyn.usun_zera_wiodace();
		return wyn;
	}
	
	void usun_zera_wiodace() {
		while (cyfry.size() > 1 && cyfry[cyfry.size() - 1] == 0)
			cyfry.pop_back();
	}
	
	friend ostream& operator <<(ostream& out, BigNum64& liczba) {
		if (liczba.dlugosc() > 0) {
			out << liczba[liczba.dlugosc() - 1];
			for (int i = liczba.dlugosc() - 2; i >= 0; --i) {
				int ile_zer = 9;
				unsigned long long pom = liczba[i];
				while (pom > 0) {
					ile_zer--;
					pom /= 10;
				}
				for (int j = 0; j < ile_zer; ++j)
					out << 0;
				if (liczba[i] > 0)
					out << liczba[i];
			}
		}
		return out;
	}
};

const unsigned long long MOD = 1e19;

void mnoz_macierze(BigNum64 a[2][2], BigNum64 b[2][2], BigNum64 c[2][2]) {
	for (int i = 0; i < 2; ++i)
		for (int j = 0; j < 2; ++j) {
			c[i][j] = 0;
			for (int k = 0; k < 2; ++k)
				c[i][j] = (c[i][j] + a[i][k] * b[k][j]) % MOD;
		}
}

void potega(BigNum64 a[2][2], unsigned long long wyk, BigNum64 wyn[2][2]) {
	if (wyk == 1) {
		for (int i = 0; i < 2; ++i)
			for (int j = 0; j < 2; ++j)
				wyn[i][j] = a[i][j];
		return;
	}
	BigNum64 pom[2][2], pom2[2][2];
	potega(a, wyk / 2, pom);
	if (wyk % 2 == 0)
		mnoz_macierze(pom, pom, wyn);
	else {
		mnoz_macierze(pom, pom, pom2);
		mnoz_macierze(a, pom2, wyn);
	}
}

BigNum64 domnozenie[2][2] = {{0, 1}, {1, 1}};

// Obliczenie n-tego wyrazu ciągu Fibonacciego mod MOD. Czas: O(log(n)).
unsigned long long ciag_fibonacciego(unsigned long long n) {
	if (n <= 1)
		return n;
	BigNum64 zpotegowana[2][2];
	potega(domnozenie, n - 1, zpotegowana);
	return (zpotegowana[1][1] % MOD).wartosc();
}

bool czy_wieksza(unsigned long long wynik, unsigned long long pot) {
	unsigned long long a = 0, b = 1, pom;
	if (wynik > 1000)
		return true;
	for (int i = 1; i <= wynik; ++i) {
		pom = a;
		a = a + b;
		b = pom;
		if (a >= pot)
			return true;
	}
	return false;
}

int main() {
	ios_base::sync_with_stdio(0);
	int i, j;
	unsigned long long okres[19];
	okres[0] = 1;
	string s;
	cin >> s;
	unsigned long long pot = 10, s_mod = 0;
	for (i = 1; i <= s.size(); ++i) {
		okres[i] = okres[i - 1];
		while (!(ciag_fibonacciego(okres[i]) % pot == 0 && ciag_fibonacciego(okres[i] + 1) % pot == 1))
			okres[i] += okres[i - 1];
		pot *= 10;
	}
	pot = 1;
	vector<unsigned long long> pozycje;
	pozycje.push_back(0);
	for (i = 1; i <= s.size(); ++i) {
		s_mod = pot * (s[s.size() - i] - '0') + s_mod;
		pot *= 10;
		unsigned long long poz = 0;
		vector<unsigned long long> nowe_pozycje;
		while (poz < okres[i]) {
			for (j = 0; j < pozycje.size(); ++j)
				if (ciag_fibonacciego(poz + pozycje[j]) % pot == s_mod)
					nowe_pozycje.push_back(poz + pozycje[j]);
			poz += okres[i - 1];
		}
		pozycje = nowe_pozycje;
		if (pozycje.size() == 0)
			break;
	}
	if (pozycje.size() == 0)
		cout << "NIE";
	else {
		unsigned long long wynik = pozycje[0];
		while (!czy_wieksza(wynik, pot / 10))
			wynik += okres[s.size()];
		cout << wynik;
	}
	return 0;
}