





import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length


def 							__snake_case							(    lowerCAmelCase_	)				->						Optional[Any]:
    SCREAMING_SNAKE_CASE__											=			int(lowerCAmelCase_	)
    SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			t // 3_6_0_0, (t // 6_0) % 6_0, t % 6_0
    return f'''{h}:{m:02d}:{s:02d}''' if h != 0 else f'''{m:02d}:{s:02d}'''


def 							__snake_case							(    lowerCAmelCase_ ,							lowerCAmelCase_ ,							lowerCAmelCase_ ,							lowerCAmelCase_ ,							lowerCAmelCase_=3_0_0	)				->						Dict:
    # docstyle-ignore
    return f'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''


def 							__snake_case							(    lowerCAmelCase_	)				->						Optional[Any]:
    SCREAMING_SNAKE_CASE__											=			'''<table border="1" class="dataframe">\n'''
    html_code += """  <thead>\n <tr style="text-align: left;">\n"""
    for i in items[0]:
        html_code += f'''      <th>{i}</th>\n'''
    html_code += "    </tr>\n  </thead>\n  <tbody>\n"
    for line in items[1:]:
        html_code += "    <tr>\n"
        for elt in line:
            SCREAMING_SNAKE_CASE__											=			f'''{elt:.6f}''' if isinstance(lowerCAmelCase_ ,							lowerCAmelCase_	) else str(lowerCAmelCase_	)
            html_code += f'''      <td>{elt}</td>\n'''
        html_code += "    </tr>\n"
    html_code += "  </tbody>\n</table><p>"
    return html_code



class 					__snake_case	:


    '''simple docstring'''







    lowerCamelCase__    :		Tuple				=	5
    lowerCamelCase__    :		str				=	0.2



    def __init__(       self   ,				A_   ,				A_ = None   ,				A_ = True   ,				A_ = None   ,				A_ = 3_00   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			total
        SCREAMING_SNAKE_CASE__											=			'''''' if prefix is None else prefix
        SCREAMING_SNAKE_CASE__											=			leave
        SCREAMING_SNAKE_CASE__											=			parent
        SCREAMING_SNAKE_CASE__											=			width
        SCREAMING_SNAKE_CASE__											=			None
        SCREAMING_SNAKE_CASE__											=			None
        SCREAMING_SNAKE_CASE__											=			None



    def  lowercase_					(       self   ,				A_   ,				A_ = False   ,				A_ = None     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			value
        if comment is not None:
            SCREAMING_SNAKE_CASE__											=			comment
        if self.last_value is None:
            SCREAMING_SNAKE_CASE__											=			SCREAMING_SNAKE_CASE__											=			time.time()
            SCREAMING_SNAKE_CASE__											=			SCREAMING_SNAKE_CASE__											=			value
            SCREAMING_SNAKE_CASE__											=			SCREAMING_SNAKE_CASE__											=			None
            SCREAMING_SNAKE_CASE__											=			self.warmup
            SCREAMING_SNAKE_CASE__											=			1
            self.update_bar(A_     )
        elif value <= self.last_value and not force_update:
            return
        elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for   ,				self.total     ):
            if self.first_calls > 0:
                self.first_calls -= 1
            SCREAMING_SNAKE_CASE__											=			time.time()
            SCREAMING_SNAKE_CASE__											=			current_time - self.start_time
            # We could have value = self.start_value if the update is called twixe with the same start value.
            if value > self.start_value:
                SCREAMING_SNAKE_CASE__											=			self.elapsed_time / (value - self.start_value)
            else:
                SCREAMING_SNAKE_CASE__											=			None
            if value >= self.total:
                SCREAMING_SNAKE_CASE__											=			self.total
                SCREAMING_SNAKE_CASE__											=			None
                if not self.leave:
                    self.close()
            elif self.average_time_per_item is not None:
                SCREAMING_SNAKE_CASE__											=			self.average_time_per_item * (self.total - value)
            self.update_bar(A_     )
            SCREAMING_SNAKE_CASE__											=			value
            SCREAMING_SNAKE_CASE__											=			current_time
            if self.average_time_per_item is None:
                SCREAMING_SNAKE_CASE__											=			1
            else:
                SCREAMING_SNAKE_CASE__											=			max(int(self.update_every / self.average_time_per_item     )   ,				1     )



    def  lowercase_					(       self   ,				A_   ,				A_=None     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			''' ''' * (len(str(self.total     )     ) - len(str(A_     )     )) + str(A_     )
        if self.elapsed_time is None:
            SCREAMING_SNAKE_CASE__											=			f'''[{spaced_value}/{self.total} : < :'''
        elif self.predicted_remaining is None:
            SCREAMING_SNAKE_CASE__											=			f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time     )}'''
        else:
            SCREAMING_SNAKE_CASE__											=			(
                f'''[{spaced_value}/{self.total} {format_time(self.elapsed_time     )} <'''
                f''' {format_time(self.predicted_remaining     )}'''
            )
            self.label += f''', {1/self.average_time_per_item:.2f} it/s'''
        self.label += "]" if self.comment is None or len(self.comment     ) == 0 else f''', {self.comment}]'''
        self.display()



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			html_progress_bar(self.value   ,				self.total   ,				self.prefix   ,				self.label   ,				self.width     )
        if self.parent is not None:
            # If this is a child bar, the parent will take care of the display.
            self.parent.display()
            return
        if self.output is None:
            SCREAMING_SNAKE_CASE__											=			disp.display(disp.HTML(self.html_code     )   ,				display_id=A_     )
        else:
            self.output.update(disp.HTML(self.html_code     )     )




    def  lowercase_					(       self     ):





        '''simple docstring'''

        if self.parent is None and self.output is not None:
            self.output.update(disp.HTML(''''''     )     )





class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_=None     ):





        '''simple docstring'''

        super().__init__(A_     )
        SCREAMING_SNAKE_CASE__											=			None if column_names is None else [column_names]
        SCREAMING_SNAKE_CASE__											=			None



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			html_progress_bar(self.value   ,				self.total   ,				self.prefix   ,				self.label   ,				self.width     )
        if self.inner_table is not None:
            self.html_code += text_to_html_table(self.inner_table     )
        if self.child_bar is not None:
            self.html_code += self.child_bar.html_code
        if self.output is None:
            SCREAMING_SNAKE_CASE__											=			disp.display(disp.HTML(self.html_code     )   ,				display_id=A_     )
        else:
            self.output.update(disp.HTML(self.html_code     )     )



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        if self.inner_table is None:
            SCREAMING_SNAKE_CASE__											=			[list(values.keys()     ), list(values.values()     )]
        else:
            SCREAMING_SNAKE_CASE__											=			self.inner_table[0]
            if len(self.inner_table     ) == 1:
                # We give a chance to update the column names at the first iteration
                for key in values.keys():
                    if key not in columns:
                        columns.append(A_     )
                SCREAMING_SNAKE_CASE__											=			columns
            self.inner_table.append([values[c] for c in columns]     )



    def  lowercase_					(       self   ,				A_   ,				A_=None   ,				A_=3_00     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			NotebookProgressBar(A_   ,				prefix=A_   ,				parent=self   ,				width=A_     )
        return self.child_bar




    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			None
        self.display()





class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    def __init__(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			None
        SCREAMING_SNAKE_CASE__											=			None
        SCREAMING_SNAKE_CASE__											=			False



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				**A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			'''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
        SCREAMING_SNAKE_CASE__											=			0
        SCREAMING_SNAKE_CASE__											=			0
        SCREAMING_SNAKE_CASE__											=			[self.first_column] + ['''Training Loss''']
        if args.evaluation_strategy != IntervalStrategy.NO:
            column_names.append('''Validation Loss'''     )
        SCREAMING_SNAKE_CASE__											=			NotebookTrainingTracker(state.max_steps   ,				A_     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				**A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			int(state.epoch     ) if int(state.epoch     ) == state.epoch else f'''{state.epoch:.2f}'''
        self.training_tracker.update(
            state.global_step + 1   ,				comment=f'''Epoch {epoch}/{state.num_train_epochs}'''   ,				force_update=self._force_next_update   ,				)
        SCREAMING_SNAKE_CASE__											=			False



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_=None   ,				**A_     ):





        '''simple docstring'''

        if not has_length(A_     ):
            return
        if self.prediction_bar is None:
            if self.training_tracker is not None:
                SCREAMING_SNAKE_CASE__											=			self.training_tracker.add_child(len(A_     )     )
            else:
                SCREAMING_SNAKE_CASE__											=			NotebookProgressBar(len(A_     )     )
            self.prediction_bar.update(1     )
        else:
            self.prediction_bar.update(self.prediction_bar.value + 1     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				**A_     ):





        '''simple docstring'''

        if self.prediction_bar is not None:
            self.prediction_bar.close()
        SCREAMING_SNAKE_CASE__											=			None



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_=None   ,				**A_     ):





        '''simple docstring'''

        if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
            SCREAMING_SNAKE_CASE__											=			{'''Training Loss''': logs['''loss''']}
            # First column is necessarily Step sine we're not in epoch eval strategy
            SCREAMING_SNAKE_CASE__											=			state.global_step
            self.training_tracker.write_line(A_     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_=None   ,				**A_     ):





        '''simple docstring'''

        if self.training_tracker is not None:
            SCREAMING_SNAKE_CASE__											=			{'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
            for log in reversed(state.log_history     ):
                if "loss" in log:
                    SCREAMING_SNAKE_CASE__											=			log['''loss''']
                    break

            if self.first_column == "Epoch":
                SCREAMING_SNAKE_CASE__											=			int(state.epoch     )
            else:
                SCREAMING_SNAKE_CASE__											=			state.global_step
            SCREAMING_SNAKE_CASE__											=			'''eval'''
            for k in metrics:
                if k.endswith('''_loss'''     ):
                    SCREAMING_SNAKE_CASE__											=			re.sub(r'''\_loss$'''   ,				''''''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			metrics.pop('''total_flos'''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			metrics.pop('''epoch'''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			metrics.pop(f'''{metric_key_prefix}_runtime'''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			metrics.pop(f'''{metric_key_prefix}_samples_per_second'''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			metrics.pop(f'''{metric_key_prefix}_steps_per_second'''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			metrics.pop(f'''{metric_key_prefix}_jit_compilation_time'''   ,				A_     )
            for k, v in metrics.items():
                if k == f'''{metric_key_prefix}_loss''':
                    SCREAMING_SNAKE_CASE__											=			v
                else:
                    SCREAMING_SNAKE_CASE__											=			k.split('''_'''     )
                    SCREAMING_SNAKE_CASE__											=			''' '''.join([part.capitalize() for part in splits[1:]]     )
                    SCREAMING_SNAKE_CASE__											=			v
            self.training_tracker.write_line(A_     )
            self.training_tracker.remove_child()
            SCREAMING_SNAKE_CASE__											=			None
            # Evaluation takes a long time so we should force the next update.
            SCREAMING_SNAKE_CASE__											=			True




    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				**A_     ):





        '''simple docstring'''

        self.training_tracker.update(
            state.global_step   ,				comment=f'''Epoch {int(state.epoch     )}/{state.num_train_epochs}'''   ,				force_update=A_     )
        SCREAMING_SNAKE_CASE__											=			None







def 							__snake_case							(    )				->						int:
    return 1


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else two_pence(x - 2	) + one_pence()


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else five_pence(x - 5	) + two_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else ten_pence(x - 1_0	) + five_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else twenty_pence(x - 2_0	) + ten_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else fifty_pence(x - 5_0	) + twenty_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else one_pound(x - 1_0_0	) + fifty_pence(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_	)				->						int:
    return 0 if x < 0 else two_pound(x - 2_0_0	) + one_pound(lowerCAmelCase_	)


def 							__snake_case							(    lowerCAmelCase_ = 2_0_0	)				->						int:
    return two_pound(lowerCAmelCase_	)


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