
"""simple docstring"""

def 		UpperCAmelCase (		a_ = 100      ):





		'''simple docstring'''


		lowerCamelCase					:      List[Any]          =   set()

		lowerCamelCase					:      Optional[Any]          =   0

		lowerCamelCase					:      Dict          =   n + 1  # maximum limit

		for a in range(2,						a_      ):
				for b in range(2,						a_      ):
						lowerCamelCase					:      List[Any]          =   a**b  # calculates the current power
						collect_powers.add(a_      )  # adds the result to the set
		return len(a_      )


if __name__ == "__main__":
					print('Number of terms ', solution(int(str(input()).strip())))








"""simple docstring"""

import os
import tempfile
from functools import partial
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pytest

from datasets.arrow_dataset import Dataset
from datasets.search import ElasticSearchIndex, FaissIndex, MissingIndex

from .utils import require_elasticsearch, require_faiss


_A						=			pytest.mark.integration






@require_faiss
class 	_lowercase       (    __UpperCAmelCase		):




	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			lowerCamelCase					:      Any          =   Dataset.from_dict({'filename': ['my_name-train' + '_' + str(UpperCAmelCase_ ) for x in np.arange(30 ).tolist()]} )
			return dset




	def       _UpperCamelCase   (			self )		->							List[Any]:
			import faiss

			lowerCamelCase					:      Dataset          =   self._create_dummy_dataset()
			lowerCamelCase					:      Optional[int]          =   dset.map(
			    lambda UpperCAmelCase_		,			UpperCAmelCase_ : {"vecs": i * np.ones(5		,			dtype=np.floataa )}		,			with_indices=UpperCAmelCase_		,			keep_in_memory=UpperCAmelCase_ )
			lowerCamelCase					:      Dict          =   dset.add_faiss_index('vecs'		,			batch_size=100		,			metric_type=faiss.METRIC_INNER_PRODUCT )
			lowerCamelCase     ,   lowerCamelCase					:      List[str]          =   dset.get_nearest_examples('vecs'		,			np.ones(5		,			dtype=np.floataa ) )
			self.assertEqual(examples['filename'][0]		,			'my_name-train_29' )
			dset.drop_index('vecs' )




	def       _UpperCamelCase   (			self )		->							Tuple:
			import faiss

			lowerCamelCase					:      Dataset          =   self._create_dummy_dataset()
			dset.add_faiss_index_from_external_arrays(
			    external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1		,			1 )		,			index_name='vecs'		,			batch_size=100		,			metric_type=faiss.METRIC_INNER_PRODUCT		,			)
			lowerCamelCase     ,   lowerCamelCase					:      str          =   dset.get_nearest_examples('vecs'		,			np.ones(5		,			dtype=np.floataa ) )
			self.assertEqual(examples['filename'][0]		,			'my_name-train_29' )




	def       _UpperCamelCase   (			self )		->							int:
			import faiss

			lowerCamelCase					:      Dataset          =   self._create_dummy_dataset()
			dset.add_faiss_index_from_external_arrays(
			    external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1		,			1 )		,			index_name='vecs'		,			metric_type=faiss.METRIC_INNER_PRODUCT		,			)

			# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
			# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
			# see https://bugs.python.org/issue14243 and
			# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
			with tempfile.NamedTemporaryFile(delete=UpperCAmelCase_ ) as tmp_file:
					dset.save_faiss_index('vecs'		,			tmp_file.name )
					dset.load_faiss_index('vecs2'		,			tmp_file.name )
			os.unlink(tmp_file.name )

			lowerCamelCase     ,   lowerCamelCase					:      List[str]          =   dset.get_nearest_examples('vecs2'		,			np.ones(5		,			dtype=np.floataa ) )
			self.assertEqual(examples['filename'][0]		,			'my_name-train_29' )




	def       _UpperCamelCase   (			self )		->							Any:
			lowerCamelCase					:      Dataset          =   self._create_dummy_dataset()
			dset.add_faiss_index_from_external_arrays(
			    external_arrays=np.ones((30, 5) ) * np.arange(30 ).reshape(-1		,			1 )		,			index_name='vecs' )
			dset.drop_index('vecs' )
			self.assertRaises(UpperCAmelCase_		,			partial(dset.get_nearest_examples		,			'vecs2'		,			np.ones(5		,			dtype=np.floataa ) ) )




	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			from elasticsearch import Elasticsearch

			lowerCamelCase					:      Dataset          =   self._create_dummy_dataset()
			with patch('elasticsearch.Elasticsearch.search' ) as mocked_search, patch(
			    'elasticsearch.client.IndicesClient.create' ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk' ) as mocked_bulk:
					lowerCamelCase					:      Tuple          =   {'acknowledged': True}
					mocked_bulk.return_value([(True, None)] * 30 )
					lowerCamelCase					:      int          =   {'hits': {'hits': [{'_score': 1, '_id': 29}]}}
					lowerCamelCase					:      Optional[Any]          =   Elasticsearch()

					dset.add_elasticsearch_index('filename'		,			es_client=UpperCAmelCase_ )
					lowerCamelCase     ,   lowerCamelCase					:      str          =   dset.get_nearest_examples('filename'		,			'my_name-train_29' )
					self.assertEqual(examples['filename'][0]		,			'my_name-train_29' )






@require_faiss
class 	_lowercase       (    __UpperCAmelCase		):




	def       _UpperCamelCase   (			self )		->							Union[str, Any]:
			import faiss

			lowerCamelCase					:      str          =   FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT )

			# add vectors
			index.add_vectors(np.eye(5		,			dtype=np.floataa ) )
			self.assertIsNotNone(index.faiss_index )
			self.assertEqual(index.faiss_index.ntotal		,			5 )
			index.add_vectors(np.zeros((5, 5)		,			dtype=np.floataa ) )
			self.assertEqual(index.faiss_index.ntotal		,			10 )

			# single query
			lowerCamelCase					:      Optional[int]          =   np.zeros(5		,			dtype=np.floataa )
			lowerCamelCase					:      List[str]          =   1
			lowerCamelCase     ,   lowerCamelCase					:      int          =   index.search(UpperCAmelCase_ )
			self.assertRaises(UpperCAmelCase_		,			index.search		,			query.reshape(-1		,			1 ) )
			self.assertGreater(scores[0]		,			0 )
			self.assertEqual(indices[0]		,			1 )

			# batched queries
			lowerCamelCase					:      Tuple          =   np.eye(5		,			dtype=np.floataa )[::-1]
			lowerCamelCase     ,   lowerCamelCase					:      List[str]          =   index.search_batch(UpperCAmelCase_ )
			self.assertRaises(UpperCAmelCase_		,			index.search_batch		,			queries[0] )
			lowerCamelCase					:      List[str]          =   [scores[0] for scores in total_scores]
			lowerCamelCase					:      List[str]          =   [indices[0] for indices in total_indices]
			self.assertGreater(np.min(UpperCAmelCase_ )		,			0 )
			self.assertListEqual([4, 3, 2, 1, 0]		,			UpperCAmelCase_ )




	def       _UpperCamelCase   (			self )		->							Dict:
			import faiss

			lowerCamelCase					:      List[Any]          =   FaissIndex(string_factory='Flat' )
			index.add_vectors(np.eye(5		,			dtype=np.floataa ) )
			self.assertIsInstance(index.faiss_index		,			faiss.IndexFlat )
			lowerCamelCase					:      int          =   FaissIndex(string_factory='LSH' )
			index.add_vectors(np.eye(5		,			dtype=np.floataa ) )
			self.assertIsInstance(index.faiss_index		,			faiss.IndexLSH )
			with self.assertRaises(UpperCAmelCase_ ):
					lowerCamelCase					:      str          =   FaissIndex(string_factory='Flat'		,			custom_index=faiss.IndexFlat(5 ) )




	def       _UpperCamelCase   (			self )		->							Any:
			import faiss

			lowerCamelCase					:      Any          =   faiss.IndexFlat(5 )
			lowerCamelCase					:      Any          =   FaissIndex(custom_index=UpperCAmelCase_ )
			index.add_vectors(np.eye(5		,			dtype=np.floataa ) )
			self.assertIsInstance(index.faiss_index		,			faiss.IndexFlat )




	def       _UpperCamelCase   (			self )		->							Any:
			import faiss

			lowerCamelCase					:      Any          =   FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT )
			index.add_vectors(np.eye(5		,			dtype=np.floataa ) )

			# Setting delete=False and unlinking manually is not pretty... but it is required on Windows to
			# ensure somewhat stable behaviour. If we don't, we get PermissionErrors. This is an age-old issue.
			# see https://bugs.python.org/issue14243 and
			# https://stackoverflow.com/questions/23212435/permission-denied-to-write-to-my-temporary-file/23212515
			with tempfile.NamedTemporaryFile(delete=UpperCAmelCase_ ) as tmp_file:
					index.save(tmp_file.name )
					lowerCamelCase					:      List[str]          =   FaissIndex.load(tmp_file.name )
			os.unlink(tmp_file.name )

			lowerCamelCase					:      Dict          =   np.zeros(5		,			dtype=np.floataa )
			lowerCamelCase					:      Optional[Any]          =   1
			lowerCamelCase     ,   lowerCamelCase					:      str          =   index.search(UpperCAmelCase_ )
			self.assertGreater(scores[0]		,			0 )
			self.assertEqual(indices[0]		,			1 )


@require_faiss
def 		UpperCAmelCase (		a_      ):





		'''simple docstring'''


		import faiss

		lowerCamelCase					:      int          =   FaissIndex(metric_type=faiss.METRIC_INNER_PRODUCT      )
		index.add_vectors(np.eye(5,						dtype=np.floataa      )      )

		lowerCamelCase					:      Union[str, Any]          =   'index.faiss'
		lowerCamelCase					:      List[Any]          =   F"""mock://{index_name}"""
		index.save(a_,						storage_options=mockfs.storage_options      )
		lowerCamelCase					:      Optional[int]          =   FaissIndex.load(a_,						storage_options=mockfs.storage_options      )

		lowerCamelCase					:      str          =   np.zeros(5,						dtype=np.floataa      )
		lowerCamelCase					:      str          =   1
		lowerCamelCase     ,   lowerCamelCase					:      int          =   index.search(a_      )
		assert scores[0] > 0
		assert indices[0] == 1






@require_elasticsearch
class 	_lowercase       (    __UpperCAmelCase		):




	def       _UpperCamelCase   (			self )		->							int:
			from elasticsearch import Elasticsearch

			with patch('elasticsearch.Elasticsearch.search' ) as mocked_search, patch(
			    'elasticsearch.client.IndicesClient.create' ) as mocked_index_create, patch('elasticsearch.helpers.streaming_bulk' ) as mocked_bulk:
					lowerCamelCase					:      Union[str, Any]          =   Elasticsearch()
					lowerCamelCase					:      Optional[Any]          =   {'acknowledged': True}
					lowerCamelCase					:      str          =   ElasticSearchIndex(es_client=UpperCAmelCase_ )
					mocked_bulk.return_value([(True, None)] * 3 )
					index.add_documents(['foo', 'bar', 'foobar'] )

					# single query
					lowerCamelCase					:      Tuple          =   'foo'
					lowerCamelCase					:      List[str]          =   {'hits': {'hits': [{'_score': 1, '_id': 0}]}}
					lowerCamelCase     ,   lowerCamelCase					:      Any          =   index.search(UpperCAmelCase_ )
					self.assertEqual(scores[0]		,			1 )
					self.assertEqual(indices[0]		,			0 )

					# single query with timeout
					lowerCamelCase					:      Dict          =   'foo'
					lowerCamelCase					:      Optional[Any]          =   {'hits': {'hits': [{'_score': 1, '_id': 0}]}}
					lowerCamelCase     ,   lowerCamelCase					:      Optional[Any]          =   index.search(UpperCAmelCase_		,			request_timeout=30 )
					self.assertEqual(scores[0]		,			1 )
					self.assertEqual(indices[0]		,			0 )

					# batched queries
					lowerCamelCase					:      str          =   ['foo', 'bar', 'foobar']
					lowerCamelCase					:      Union[str, Any]          =   {'hits': {'hits': [{'_score': 1, '_id': 1}]}}
					lowerCamelCase     ,   lowerCamelCase					:      Optional[int]          =   index.search_batch(UpperCAmelCase_ )
					lowerCamelCase					:      Dict          =   [scores[0] for scores in total_scores]
					lowerCamelCase					:      Optional[int]          =   [indices[0] for indices in total_indices]
					self.assertGreater(np.min(UpperCAmelCase_ )		,			0 )
					self.assertListEqual([1, 1, 1]		,			UpperCAmelCase_ )

					# batched queries with timeout
					lowerCamelCase					:      List[str]          =   ['foo', 'bar', 'foobar']
					lowerCamelCase					:      str          =   {'hits': {'hits': [{'_score': 1, '_id': 1}]}}
					lowerCamelCase     ,   lowerCamelCase					:      Dict          =   index.search_batch(UpperCAmelCase_		,			request_timeout=30 )
					lowerCamelCase					:      Dict          =   [scores[0] for scores in total_scores]
					lowerCamelCase					:      int          =   [indices[0] for indices in total_indices]
					self.assertGreater(np.min(UpperCAmelCase_ )		,			0 )
					self.assertListEqual([1, 1, 1]		,			UpperCAmelCase_ )






