

import argparse

import torch

from transformers import HubertConfig, HubertForSequenceClassification, WavaVecaFeatureExtractor, logging


logging.set_verbosity_info()
_a									=  logging.get_logger(__name__)

_a									=  ['''UtteranceLevel''']







@torch.no_grad()
def _a					(			SCREAMING_SNAKE_CASE						:     Optional[Any]       ,   SCREAMING_SNAKE_CASE						:     int       ,   SCREAMING_SNAKE_CASE						:     Any       ,   SCREAMING_SNAKE_CASE						:     Any						)       ->       str:

 """simple docstring"""






 __lowerCAmelCase:  Dict        = torch.load(SCREAMING_SNAKE_CASE       ,   map_location='cpu'						)
 if checkpoint["Config"]["downstream_expert"]["modelrc"]["select"] not in SUPPORTED_MODELS:
  raise NotImplementedError(f'''The supported s3prl models are {SUPPORTED_MODELS}'''						)

 __lowerCAmelCase:  List[Any]        = checkpoint['Downstream']

 __lowerCAmelCase:  str        = HubertConfig.from_pretrained(SCREAMING_SNAKE_CASE						)
 __lowerCAmelCase:  Dict        = HubertForSequenceClassification.from_pretrained(SCREAMING_SNAKE_CASE       ,   config=SCREAMING_SNAKE_CASE						)
 __lowerCAmelCase:  Optional[Any]        = WavaVecaFeatureExtractor.from_pretrained(
     SCREAMING_SNAKE_CASE       ,   return_attention_mask=SCREAMING_SNAKE_CASE       ,   do_normalize=SCREAMING_SNAKE_CASE						)

 if hf_congfig.use_weighted_layer_sum:
  __lowerCAmelCase:  Optional[int]        = checkpoint['Featurizer']['weights']

 __lowerCAmelCase:  int        = downstream_dict['projector.weight']
 __lowerCAmelCase:  Tuple        = downstream_dict['projector.bias']
 __lowerCAmelCase:  str        = downstream_dict['model.post_net.linear.weight']
 __lowerCAmelCase:  str        = downstream_dict['model.post_net.linear.bias']

 hf_feature_extractor.save_pretrained(SCREAMING_SNAKE_CASE						)
 hf_model.save_pretrained(SCREAMING_SNAKE_CASE						)


if __name__ == "__main__":
  _a									=  argparse.ArgumentParser()
  parser.add_argument(
      '''--base_model_name''', default=None, type=str, help='''Name of the huggingface pretrained base model.'''
  )
  parser.add_argument('''--config_path''', default=None, type=str, help='''Path to the huggingface classifier config.''')
  parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to the s3prl checkpoint.''')
  parser.add_argument('''--model_dump_path''', default=None, type=str, help='''Path to the final converted model.''')
  _a									=  parser.parse_args()
  convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)








def _a					(			SCREAMING_SNAKE_CASE						:     int = 10_00						)       ->       int:

 """simple docstring"""






 __lowerCAmelCase:  Tuple        = [0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8]
 # number of letters in twenty, thirty, ..., ninety (0 for numbers less than
 # 20 due to inconsistency in teens)
 __lowerCAmelCase:  List[Any]        = [0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

 __lowerCAmelCase:  Dict        = 0

 for i in range(1       ,   n + 1						):
  if i < 10_00:
   if i >= 1_00:
    # add number of letters for "n hundred"
    count += ones_counts[i // 1_00] + 7

    if i % 1_00 != 0:
     # add number of letters for "and" if number is not multiple
     # of 100
     count += 3

   if 0 < i % 1_00 < 20:
    # add number of letters for one, two, three, ..., nineteen
    # (could be combined with below if not for inconsistency in
    # teens)
    count += ones_counts[i % 1_00]
   else:
    # add number of letters for twenty, twenty one, ..., ninety
    # nine
    count += ones_counts[i % 10]
    count += tens_counts[(i % 1_00 - i % 10) // 10]
  else:
   count += ones_counts[i // 10_00] + 8
 return count


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





