

from math import ceil

def    A_  (							a					,   a  ):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     list(range(0					,   a  )  )

      SCREAMING_SNAKE_CASE_				:  str           =     [item for sublist in list(device_map.values()  ) for item in sublist]

      # Duplicate check
      SCREAMING_SNAKE_CASE_				:  str           =     []
      for i in device_map_blocks:
            if device_map_blocks.count(a  ) > 1 and i not in duplicate_blocks:
                  duplicate_blocks.append(a  )
    # Missing blocks
      SCREAMING_SNAKE_CASE_				:  List[str]           =     [i for i in blocks if i not in device_map_blocks]
      SCREAMING_SNAKE_CASE_				:  List[str]           =     [i for i in device_map_blocks if i not in blocks]

      if len(a  ) != 0:
            raise ValueError(
                'Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device.'
                ' These attention blocks were specified more than once: ' + str(a  )  )
      if len(a  ) != 0:
            raise ValueError(
                'There are attention blocks for this model that are not specified in the device_map. Add these attention '
                'blocks to a device on the device_map: ' + str(a  )  )
      if len(a  ) != 0:
            raise ValueError(
                'The device_map contains more attention blocks than this model has. Remove these from the device_map:'
                + str(a  )  )



def    A_  (							a					,   a  ):

      """simple docstring"""



      SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     list(range(a  )  )
      SCREAMING_SNAKE_CASE_				:  List[str]           =     int(ceil(n_layers / len(a  )  )  )
      SCREAMING_SNAKE_CASE_				:  Any           =     [layers[i : i + n_blocks] for i in range(0					,   a					,   a  )]

      return dict(zip(a					,   a  )  )









def    A_  (							a					,   a					,   a  ):

      """simple docstring"""



      if len(a  ) != len(a  ):
            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.
      SCREAMING_SNAKE_CASE_				:  Tuple           =     [p / w for p, w in zip(a					,   a  )]

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

      # declaring useful variables
      SCREAMING_SNAKE_CASE_				:  List[Any]           =     len(a  )
      SCREAMING_SNAKE_CASE_				:  str           =     0
      SCREAMING_SNAKE_CASE_				:  List[str]           =     0
      SCREAMING_SNAKE_CASE_				:  Any           =     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
            SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     sorted_profit_by_weight[length - i - 1]
            SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     profit_by_weight.index(a  )
            SCREAMING_SNAKE_CASE_				:  Dict           =     -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.'
    )

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

    # Function Call
    calc_profit(profit, weight, max_weight)






