


'''simple docstring'''


from manim import *





class    lowercase__  (						_snake_case ):





							'''simple docstring'''


							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	Any							=				Rectangle(height=0.5   , width=0.5  )
											_SCREAMING_SNAKE_CASE			:	int							=				Rectangle(height=0.46   , width=0.46  ).set_stroke(width=0  )
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				Rectangle(height=0.25   , width=0.25  )

											_SCREAMING_SNAKE_CASE			:	Tuple							=				[mem.copy() for i in range(6  )]
											_SCREAMING_SNAKE_CASE			:	Tuple							=				[mem.copy() for i in range(6  )]
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	Tuple							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				VGroup(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	str							=				Text("""CPU"""   , font_size=24  )
											_SCREAMING_SNAKE_CASE			:	str							=				Group(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0.5   , aligned_edge=__snake_case  )
											cpu.move_to([-2.5, -0.5, 0]  )
											self.add(__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				[mem.copy() for i in range(4  )]
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				Text("""GPU"""   , font_size=24  )
											_SCREAMING_SNAKE_CASE			:	Any							=				Group(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0.5   , aligned_edge=__snake_case  )
											gpu.move_to([-1, -1, 0]  )
											self.add(__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				[mem.copy() for i in range(6  )]
											_SCREAMING_SNAKE_CASE			:	Any							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				Text("""Model"""   , font_size=24  )
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				Group(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0.5   , aligned_edge=__snake_case  )
											model.move_to([3, -1.0, 0]  )
											self.add(__snake_case  )

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				[]
											_SCREAMING_SNAKE_CASE			:	str							=				[]

											for i, rect in enumerate(__snake_case  ):
															rect.set_stroke(__snake_case  )

															_SCREAMING_SNAKE_CASE			:	int							=				Rectangle(height=0.46 / 4   , width=0.46 / 3  ).set_stroke(width=0.0  ).set_fill(__snake_case   , opacity=0.7  )

															if i == 0:
																			cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT  )   , buff=0.02   , direction=__snake_case  )
																			cpu_target.set_x(cpu_target.get_x() + 0.1  )
															elif i == 3:
																			cpu_target.next_to(model_cpu_arr[0]   , direction=__snake_case   , buff=0.0  )
															else:
																			cpu_target.next_to(model_cpu_arr[i - 1]   , direction=__snake_case   , buff=0.0  )
															self.add(__snake_case  )
															model_cpu_arr.append(__snake_case  )

											self.add(*__snake_case   , *__snake_case  )

											_SCREAMING_SNAKE_CASE			:	str							=				[meta_mem.copy() for i in range(6  )]
											_SCREAMING_SNAKE_CASE			:	str							=				[meta_mem.copy() for i in range(6  )]
											_SCREAMING_SNAKE_CASE			:	Any							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	int							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	Tuple							=				VGroup(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	int							=				Text("""Disk"""   , font_size=24  )
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				Group(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0.5   , aligned_edge=__snake_case  )
											disk.move_to([-4.0, -1.25, 0]  )
											self.add(__snake_case   , __snake_case  )

											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				[]

											for i in range(6  ):
															_SCREAMING_SNAKE_CASE			:	List[Any]							=				fill.copy().set_fill(__snake_case   , opacity=0.8  )
															target.move_to(disk_left_col_base[i]  ).scale(0.5  )
															cpu_disk_arr.append(__snake_case  )

											self.add(*__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				Square(side_length=2.2  )
											key.move_to([-5, 2, 0]  )

											_SCREAMING_SNAKE_CASE			:	Dict							=				MarkupText(
											    f"""<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"""   , font_size=18   , )

											key_text.move_to([-5, 2.4, 0]  )

											self.add(__snake_case   , __snake_case  )

											_SCREAMING_SNAKE_CASE			:	str							=				MarkupText(
											    f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""   , font_size=18   , )

											blue_text.next_to(__snake_case   , DOWN * 2.4   , aligned_edge=key_text.get_left()  )
											self.add(__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				MarkupText(f"""The offloaded weights are all sent to the CPU."""   , font_size=24  )
											step_a.move_to([2, 2, 0]  )

											self.play(Write(__snake_case   , run_time=3  )  )

											for i in range(6  ):
															_SCREAMING_SNAKE_CASE			:	Optional[int]							=				cpu_disk_arr[i]
															_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				rect.copy().set_fill(__snake_case   , opacity=0.8  ).scale(2.0  )
															cpa.generate_target()
															cpa.target.move_to(model_base[i]  )

															if i == 0:
																			rect.set_fill(__snake_case   , opacity=0.8  )
																			rect.generate_target()
																			rect.target.move_to(cpu_left_col_base[0]  ).scale(2.0  )

																			self.remove(
																			    *__snake_case   , *__snake_case   , )

															else:
																			rect.generate_target()
																			rect.target.move_to(cpu_left_col_base[i]  ).scale(2.0  )
															self.play(MoveToTarget(__snake_case  )   , MoveToTarget(__snake_case  )   , model_base[i].animate.set_stroke(__snake_case  )  )
											self.play(FadeOut(__snake_case  )  )

											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				MarkupText(
											    f"""Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed."""   , font_size=24   , )
											step_a.move_to([2, 2, 0]  )

											self.play(Write(__snake_case   , run_time=3  )  )

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				[]
											_SCREAMING_SNAKE_CASE			:	int							=				[]
											for i in range(6  ):
															_SCREAMING_SNAKE_CASE			:	str							=				Arrow(start=__snake_case   , end=__snake_case   , color=__snake_case   , buff=0.5  )
															a.next_to(model_base[i].get_left()   , __snake_case   , buff=0.2  )
															arrows.append(__snake_case  )
															animations.append(Write(__snake_case  )  )
											self.play(*__snake_case  )
											self.wait()








'''simple docstring'''


def       snake_case_       (  SCREAMING_SNAKE_CASE__ = 1000					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				[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)
				_SCREAMING_SNAKE_CASE			:	str							=				[0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

				_SCREAMING_SNAKE_CASE			:	Any							=				0

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

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

												if 0 < i % 100 < 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 % 100]
												else:
																# add number of letters for twenty, twenty one, ..., ninety
																# nine
																count += ones_counts[i % 10]
																count += tens_counts[(i % 100 - i % 10) // 10]
								else:
												count += ones_counts[i // 1000] + 8
				return count


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




