




"""simple docstring"""




from __future__ import annotations

import numpy as np
from numpy import floataa
from numpy.typing import NDArray



def     a__ (				snake_case__       , snake_case__       , snake_case__       , snake_case__       , )						->					list[float]:
			lowerCamelCase      ,   lowerCamelCase			      =					coefficient_matrix.shape
			lowerCamelCase      ,   lowerCamelCase			      =					constant_matrix.shape

			if rowsa != colsa:
						lowerCamelCase			      =					F'Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}'
						raise ValueError(snake_case__				)

			if colsa != 1:
						lowerCamelCase			      =					F'Constant matrix must be nx1 but received {rowsa}x{colsa}'
						raise ValueError(snake_case__				)

			if rowsa != rowsa:
						lowerCamelCase			      =					(
						    """Coefficient and constant matrices dimensions must be nxn and nx1 but """
						    F'received {rowsa}x{colsa} and {rowsa}x{colsa}'
						)
						raise ValueError(snake_case__				)

			if len(snake_case__				) != rowsa:
						lowerCamelCase			      =					(
						    """Number of initial values must be equal to number of rows in coefficient """
						    F'matrix but received {len(snake_case__				)} and {rowsa}'
						)
						raise ValueError(snake_case__				)

			if iterations <= 0:
						raise ValueError("""Iterations must be at least 1"""				)

			lowerCamelCase			      =					np.concatenate(
			    (coefficient_matrix, constant_matrix)       , axis=1				)

			lowerCamelCase      ,   lowerCamelCase			      =					table.shape

			strictly_diagonally_dominant(snake_case__				)

			# Iterates the whole matrix for given number of times
			for _ in range(snake_case__				):
						lowerCamelCase			      =					[]
						for row in range(snake_case__				):
									lowerCamelCase			      =					0
									for col in range(snake_case__				):
												if col == row:
															lowerCamelCase			      =					table[row][col]
												elif col == cols - 1:
															lowerCamelCase			      =					table[row][col]
												else:
															temp += (-1) * table[row][col] * init_val[col]
									lowerCamelCase			      =					(temp + val) / denom
									new_val.append(snake_case__				)
						lowerCamelCase			      =					new_val

			return [float(snake_case__				) for i in new_val]



def     a__ (				snake_case__				)						->					bool:
			lowerCamelCase      ,   lowerCamelCase			      =					table.shape

			lowerCamelCase			      =					True

			for i in range(0       , snake_case__				):
						lowerCamelCase			      =					0
						for j in range(0       , cols - 1				):
									if i == j:
												continue
									else:
												total += table[i][j]

						if table[i][i] <= total:
									raise ValueError("""Coefficient matrix is not strictly diagonally dominant"""				)

			return is_diagonally_dominant


# Test Cases
if __name__ == "__main__":
					import doctest

					doctest.testmod()









"""simple docstring"""




from collections.abc import Generator



def     a__ (				)						->					Generator[int, None, None]:
			lowerCamelCase      ,   lowerCamelCase			      =					0, 1
			while True:
						lowerCamelCase      ,   lowerCamelCase			      =					b, a + b
						yield b



def     a__ (				snake_case__ = 10_00				)						->					int:
			lowerCamelCase			      =					1
			lowerCamelCase			      =					fibonacci_generator()
			while len(str(next(snake_case__				)				)				) < n:
						answer += 1
			return answer + 1


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



