


'''simple docstring'''






from __future__ import annotations

from collections.abc import Sequence
from typing import Literal


def    _snake_case  (	A					,       A			)		->       str | Literal[False]:
							lowerCAmelCase__			  =      list(A			)
							lowerCAmelCase__			  =      list(A			)
							lowerCAmelCase__			  =      0
							for i in range(len(A			)			):
														if lista[i] != lista[i]:
																					count += 1
																					lowerCAmelCase__			  =      '''_'''
							if count > 1:
														return False
							else:
														return "".join(A			)


def    _snake_case  (	A			)		->       list[str]:
							lowerCAmelCase__			  =      []
							while True:
														lowerCAmelCase__			  =      ['''$'''] * len(A			)
														lowerCAmelCase__			  =      []
														for i in range(len(A			)			):
																					for j in range(i + 1					,       len(A			)			):
																												lowerCAmelCase__			  =      compare_string(binary[i]					,       binary[j]			)
																												if k is False:
																																			lowerCAmelCase__			  =      '''*'''
																																			lowerCAmelCase__			  =      '''*'''
																																			temp.append('''X'''			)
														for i in range(len(A			)			):
																					if checka[i] == "$":
																												pi.append(binary[i]			)
														if len(A			) == 0:
																					return pi
														lowerCAmelCase__			  =      list(set(A			)			)


def    _snake_case  (	A					,       A			)		->       list[str]:
							lowerCAmelCase__			  =      []
							for minterm in minterms:
														lowerCAmelCase__			  =      ''''''
														for _ in range(A			):
																					lowerCAmelCase__			  =      str(minterm % 2			) + string
																					minterm //= 2
														temp.append(A			)
							return temp


def    _snake_case  (	A					,       A					,       A			)		->       bool:
							lowerCAmelCase__			  =      list(A			)
							lowerCAmelCase__			  =      list(A			)
							lowerCAmelCase__			  =      0
							for i in range(len(A			)			):
														if lista[i] != lista[i]:
																					count_n += 1
							return count_n == count


def    _snake_case  (	A					,       A			)		->       list[str]:
							lowerCAmelCase__			  =      []
							lowerCAmelCase__			  =      [0] * len(A			)
							for i in range(len(chart[0]			)			):
														lowerCAmelCase__			  =      0
														lowerCAmelCase__			  =      -1
														for j in range(len(A			)			):
																					if chart[j][i] == 1:
																												count += 1
																												lowerCAmelCase__			  =      j
														if count == 1:
																					lowerCAmelCase__			  =      1
							for i in range(len(A			)			):
														if select[i] == 1:
																					for j in range(len(chart[0]			)			):
																												if chart[i][j] == 1:
																																			for k in range(len(A			)			):
																																										lowerCAmelCase__			  =      0
																					temp.append(prime_implicants[i]			)
							while True:
														lowerCAmelCase__			  =      0
														lowerCAmelCase__			  =      -1
														lowerCAmelCase__			  =      0
														for i in range(len(A			)			):
																					lowerCAmelCase__			  =      chart[i].count(1			)
																					if count_n > max_n:
																												lowerCAmelCase__			  =      count_n
																												lowerCAmelCase__			  =      i

														if max_n == 0:
																					return temp

														temp.append(prime_implicants[rem]			)

														for i in range(len(chart[0]			)			):
																					if chart[rem][i] == 1:
																												for j in range(len(A			)			):
																																			lowerCAmelCase__			  =      0


def    _snake_case  (	A					,       A			)		->       list[list[int]]:
							lowerCAmelCase__			  =      [[0 for x in range(len(A			)			)] for x in range(len(A			)			)]
							for i in range(len(A			)			):
														lowerCAmelCase__			  =      prime_implicants[i].count('''_'''			)
														for j in range(len(A			)			):
																					if is_for_table(prime_implicants[i]					,       binary[j]					,       A			):
																												lowerCAmelCase__			  =      1

							return chart


def    _snake_case  (	)		->       None:
							lowerCAmelCase__			  =      int(input('''Enter the no. of variables\n'''			)			)
							lowerCAmelCase__			  =      [
							    float(A			)
							    for x in input(
							        '''Enter the decimal representation of Minterms \'Spaces Separated\'\n'''			).split()
							]
							lowerCAmelCase__			  =      decimal_to_binary(A					,       A			)

							lowerCAmelCase__			  =      check(A			)
							print('''Prime Implicants are:'''			)
							print(A			)
							lowerCAmelCase__			  =      prime_implicant_chart(A					,       A			)

							lowerCAmelCase__			  =      selection(A					,       A			)
							print('''Essential Prime Implicants are:'''			)
							print(A			)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()



'''simple docstring'''






def    _snake_case  (	A			)		->       int:
							if n == 1 or not isinstance(A					,       A			):
														return 0
							elif n == 2:
														return 1
							else:
														lowerCAmelCase__			  =      [0, 1]
														for i in range(2					,       n + 1			):
																					sequence.append(sequence[i - 1] + sequence[i - 2]			)

														return sequence[n]


def    _snake_case  (	A			)		->       int:
							lowerCAmelCase__			  =      0
							lowerCAmelCase__			  =      2

							while digits < n:
														index += 1
														lowerCAmelCase__			  =      len(str(fibonacci(A			)			)			)

							return index


def    _snake_case  (	A = 1000			)		->       int:
							return fibonacci_digits_index(A			)


if __name__ == "__main__":
		print(solution(int(str(input()).strip())))