


def 				__lowerCamelCase						( UpperCAmelCase_						:		int = 1000						):




      """simple docstring"""





      a							,				a						:int 							=       1, 1
      a						:Any 							=       2
      while True:
            a						:Optional[int] 							=       0
            a						:str 							=       fa + fa
            a							,				a						:List[Any] 							=       fa, f
            index += 1
            for _ in str(UpperCAmelCase_						):
                  i += 1
            if i == n:
                  break
      return index


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









def 				__lowerCamelCase						( UpperCAmelCase_						:		list ,  UpperCAmelCase_						:		list ,  UpperCAmelCase_						:		int						):




      """simple docstring"""





      if len(UpperCAmelCase_						) != len(UpperCAmelCase_						):
            raise ValueError('''The length of profit and weight must be same.'''						)
      if max_weight <= 0:
            raise ValueError('''max_weight must greater than zero.'''						)
      if any(p < 0 for p in profit						):
            raise ValueError('''Profit can not be negative.'''						)
      if any(w < 0 for w in weight						):
            raise ValueError('''Weight can not be negative.'''						)

      # List created to store profit gained for the 1kg in case of each weight
      # respectively.  Calculate and append profit/weight for each element.
      a						:Optional[int] 							=       [p / w for p, w in zip(UpperCAmelCase_ ,  UpperCAmelCase_						)]

      # Creating a copy of the list and sorting profit/weight in ascending order
      a						:List[Any] 							=       sorted(UpperCAmelCase_						)

      # declaring useful variables
      a						:Dict 							=       len(UpperCAmelCase_						)
      a						:Tuple 							=       0
      a						:List[Any] 							=       0
      a						:str 							=       0

      # loop till the total weight do not reach max limit e.g. 15 kg and till i<length
      while limit <= max_weight and i < length:
            # flag value for encountered greatest element in sorted_profit_by_weight
            a						:List[Any] 							=       sorted_profit_by_weight[length - i - 1]
            a						:Optional[Any] 							=       profit_by_weight.index(UpperCAmelCase_						)
            a						:Optional[int] 							=       -1

            # check if the weight encountered is less than the total weight
            # encountered before.
            if max_weight - limit >= weight[index]:
                  limit += weight[index]
                  # Adding profit gained for the given weight 1 ===
                  # weight[index]/weight[index]
                  gain += 1 * profit[index]
            else:
                  # Since the weight encountered is greater than limit, therefore take the
                  # required number of remaining kgs and calculate profit for it.
                  # weight remaining / weight[index]
                  gain += (max_weight - limit) / weight[index] * profit[index]
                  break
            i += 1
      return gain


if __name__ == "__main__":
     print(
         '''Input profits, weights, and then max_weight (all positive ints) separated by '''
         '''spaces.'''
     )

     snake_case				:    Union[str, Any]       				=     [int(x) for x in input('''Input profits separated by spaces: ''').split()]
     snake_case				:    Tuple       				=     [int(x) for x in input('''Input weights separated by spaces: ''').split()]
     snake_case				:    str       				=     int(input('''Max weight allowed: '''))

     # Function Call
     calc_profit(profit, weight, max_weight)





