





'''simple docstring'''

import warnings
from typing import List
from unittest.mock import Mock

import torch
from torch.utils.data import DataLoader, IterableDataset, TensorDataset

from accelerate.accelerator import Accelerator
from accelerate.utils.dataclasses import DistributedType





class lowerCamelCase						(__UpperCAmelCase					):







  def __init__(		self     ,     lowercase__		)		->						Dict:






        """simple docstring"""





        _snake_case		:	Union[str, Any]					     =     data







  def __iter__(		self		)		->						Union[str, Any]:






        """simple docstring"""





        for element in self.data:
              yield element




def    _a    (							lowerCAmelCase_=True	):





      """simple docstring"""



      _snake_case		:	List[str]					     =     Accelerator(even_batches=__lowerCAmelCase	)
      assert accelerator.num_processes == 2, "this script expects that two GPUs are available"
      return accelerator




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_ = False	):





      """simple docstring"""



      if iterable:
            _snake_case		:	Any					     =     DummyIterableDataset(torch.as_tensor(range(__lowerCAmelCase	)	)	)
      else:
            _snake_case		:	Optional[int]					     =     TensorDataset(torch.as_tensor(range(__lowerCAmelCase	)	)	)

      _snake_case		:	Optional[int]					     =     DataLoader(__lowerCAmelCase			,      batch_size=__lowerCAmelCase	)
      _snake_case		:	Dict					     =     accelerator.prepare(__lowerCAmelCase	)

      return dl




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      ):





      """simple docstring"""



      _snake_case		:	Optional[int]					     =     create_dataloader(accelerator=__lowerCAmelCase			,      dataset_size=__lowerCAmelCase			,      batch_size=__lowerCAmelCase	)

      _snake_case		:	Union[str, Any]					     =     [len(batch[0]	) for batch in dl]

      if accelerator.process_index == 0:
            assert batch_sizes == process_0_expected_batch_sizes
      elif accelerator.process_index == 1:
            assert batch_sizes == process_1_expected_batch_sizes




def    _a    (							):





      """simple docstring"""



      _snake_case		:	Tuple					     =     create_accelerator()

      # without padding, we would expect a different number of batches
      verify_dataloader_batch_sizes(
          __lowerCAmelCase			,      dataset_size=3			,      batch_size=1			,      process_0_expected_batch_sizes=[1, 1]			,      process_1_expected_batch_sizes=[1, 1]			,      )

      # without padding, we would expect the same number of batches, but different sizes
      verify_dataloader_batch_sizes(
          __lowerCAmelCase			,      dataset_size=7			,      batch_size=2			,      process_0_expected_batch_sizes=[2, 2]			,      process_1_expected_batch_sizes=[2, 2]			,      )




def    _a    (							):





      """simple docstring"""



      _snake_case		:	Union[str, Any]					     =     create_accelerator(even_batches=__lowerCAmelCase	)

      verify_dataloader_batch_sizes(
          __lowerCAmelCase			,      dataset_size=3			,      batch_size=1			,      process_0_expected_batch_sizes=[1, 1]			,      process_1_expected_batch_sizes=[1]			,      )

      verify_dataloader_batch_sizes(
          __lowerCAmelCase			,      dataset_size=7			,      batch_size=2			,      process_0_expected_batch_sizes=[2, 2]			,      process_1_expected_batch_sizes=[2, 1]			,      )




def    _a    (							):





      """simple docstring"""



      _snake_case		:	Optional[Any]					     =     create_accelerator(even_batches=__lowerCAmelCase	)

      _snake_case		:	Union[str, Any]					     =     torch.nn.Linear(1			,      1	)
      _snake_case		:	Optional[int]					     =     accelerator.prepare(__lowerCAmelCase	)

      _snake_case		:	List[str]					     =     create_dataloader(__lowerCAmelCase			,      dataset_size=3			,      batch_size=1	)

      _snake_case		:	Tuple					     =     []
      with accelerator.join_uneven_inputs([ddp_model]	):
            for batch_idx, batch in enumerate(__lowerCAmelCase	):
                  _snake_case		:	List[Any]					     =     ddp_model(batch[0].float()	)
                  _snake_case		:	Any					     =     output.sum()
                  loss.backward()
                  batch_idxs.append(__lowerCAmelCase	)

      accelerator.wait_for_everyone()

      if accelerator.process_index == 0:
            assert batch_idxs == [0, 1]
      elif accelerator.process_index == 1:
            assert batch_idxs == [0]




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      with warnings.catch_warnings(record=__lowerCAmelCase	) as w:
            with accelerator.join_uneven_inputs([Mock()]	):
                  pass

            assert issubclass(w[-1].category			,      __lowerCAmelCase	)
            assert "only supported for multi-GPU" in str(w[-1].message	)




def    _a    (							):





      """simple docstring"""



      _snake_case		:	List[Any]					     =     True
      _snake_case		:	Tuple					     =     False
      _snake_case		:	List[Any]					     =     create_accelerator(even_batches=__lowerCAmelCase	)
      _snake_case		:	List[str]					     =     torch.nn.Linear(1			,      1	)
      _snake_case		:	Any					     =     accelerator.prepare(__lowerCAmelCase	)
      _snake_case		:	Tuple					     =     create_dataloader(__lowerCAmelCase			,      dataset_size=3			,      batch_size=1	)
      _snake_case		:	Any					     =     create_dataloader(__lowerCAmelCase			,      dataset_size=3			,      batch_size=1	)

      with accelerator.join_uneven_inputs([ddp_model]			,      even_batches=__lowerCAmelCase	):
            _snake_case		:	List[Any]					     =     train_dl.batch_sampler.even_batches
            _snake_case		:	str					     =     valid_dl.batch_sampler.even_batches

      assert train_dl_overridden_value == overridden_even_batches
      assert valid_dl_overridden_value == overridden_even_batches
      assert train_dl.batch_sampler.even_batches == default_even_batches
      assert valid_dl.batch_sampler.even_batches == default_even_batches




def    _a    (							):





      """simple docstring"""



      _snake_case		:	Optional[Any]					     =     True
      _snake_case		:	Optional[int]					     =     False
      _snake_case		:	Dict					     =     create_accelerator(even_batches=__lowerCAmelCase	)
      _snake_case		:	List[Any]					     =     torch.nn.Linear(1			,      1	)
      _snake_case		:	str					     =     accelerator.prepare(__lowerCAmelCase	)
      create_dataloader(__lowerCAmelCase			,      dataset_size=3			,      batch_size=1			,      iterable=__lowerCAmelCase	)
      _snake_case		:	Dict					     =     create_dataloader(__lowerCAmelCase			,      dataset_size=3			,      batch_size=1	)

      with warnings.catch_warnings():
            warnings.filterwarnings('''ignore'''	)
            try:
                  with accelerator.join_uneven_inputs([ddp_model]			,      even_batches=__lowerCAmelCase	):
                        _snake_case		:	List[str]					     =     batch_dl.batch_sampler.even_batches
            except AttributeError:
                  # ensure attribute error is not raised when processing iterable dl
                  raise AssertionError

      assert batch_dl_overridden_value == overridden_even_batches
      assert batch_dl.batch_sampler.even_batches == default_even_batches




def    _a    (							):





      """simple docstring"""



      _snake_case		:	Union[str, Any]					     =     create_accelerator()
      _snake_case		:	str					     =     torch.nn.Linear(1			,      1	)
      _snake_case		:	Tuple					     =     accelerator.prepare(__lowerCAmelCase	)
      create_dataloader(__lowerCAmelCase			,      dataset_size=3			,      batch_size=1			,      iterable=__lowerCAmelCase	)

      with warnings.catch_warnings(record=__lowerCAmelCase	) as w:
            with accelerator.join_uneven_inputs([ddp_model]			,      even_batches=__lowerCAmelCase	):
                  pass

            assert issubclass(w[-1].category			,      __lowerCAmelCase	)
            assert "only supported for map-style datasets" in str(w[-1].message	)




def    _a    (							):





      """simple docstring"""



      _snake_case		:	Union[str, Any]					     =     create_accelerator()

      accelerator.print('''Test that even_batches variable ensures uniform batches across processes'''	)
      test_default_ensures_even_batch_sizes()

      accelerator.print('''Run tests with even_batches disabled'''	)
      test_can_disable_even_batches()

      accelerator.print('''Test joining uneven inputs'''	)
      test_can_join_uneven_inputs()

      accelerator.print('''Test overriding even_batches when joining uneven inputs'''	)
      test_join_can_override_even_batches()

      accelerator.print('''Test overriding even_batches for mixed dataloader types'''	)
      test_join_can_override_for_mixed_type_dataloaders()

      accelerator.print('''Test overriding even_batches raises a warning for iterable dataloaders'''	)
      test_join_raises_warning_for_iterable_when_overriding_even_batches()

      accelerator.print('''Test join with non DDP distributed raises warning'''	)
      _snake_case		:	Union[str, Any]					     =     accelerator.state.distributed_type
      _snake_case		:	int					     =     DistributedType.FSDP
      test_join_raises_warning_for_non_ddp_distributed(__lowerCAmelCase	)
      _snake_case		:	Optional[Any]					     =     original_state


if __name__ == "__main__":
   main()









'''simple docstring'''

def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      if n == 1 or not isinstance(lowerCAmelCase_			,      lowerCAmelCase_	):
            return 0
      elif n == 2:
            return 1
      else:
            _snake_case		:	Union[str, Any]					     =     [0, 1]
            for i in range(2			,      n + 1	):
                  sequence.append(sequence[i - 1] + sequence[i - 2]	)

            return sequence[n]




def    _a    (							lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Optional[int]					     =     0
      _snake_case		:	int					     =     2

      while digits < n:
            index += 1
            _snake_case		:	Tuple					     =     len(str(fibonacci(lowerCAmelCase_	)	)	)

      return index




def    _a    (							lowerCAmelCase_ = 1_000	):





      """simple docstring"""



      return fibonacci_digits_index(lowerCAmelCase_	)


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


