




'''simple docstring'''





def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if len(lowercase__   ) != len(lowercase__   ):
						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           =					[p / w for p, w in zip(lowercase__					,	lowercase__   )]

			# Creating a copy of the list and sorting profit/weight in ascending order
			SCREAMING_SNAKE_CASE           =					sorted(lowercase__   )

			# declaring useful variables
			SCREAMING_SNAKE_CASE           =					len(lowercase__   )
			SCREAMING_SNAKE_CASE           =					0
			SCREAMING_SNAKE_CASE           =					0
			SCREAMING_SNAKE_CASE           =					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           =					sorted_profit_by_weight[length - i - 1]
						SCREAMING_SNAKE_CASE           =					profit_by_weight.index(lowercase__   )
						SCREAMING_SNAKE_CASE           =					-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."""
		)

		__A						:							List[Any]							=  [int(x) for x in input("""Input profits separated by spaces: """).split()]
		__A						:							Optional[Any]							=  [int(x) for x in input("""Input weights separated by spaces: """).split()]
		__A						:							Tuple							=  int(input("""Max weight allowed: """))

		# Function Call
		calc_profit(profit, weight, max_weight)












import importlib
import shutil
import threading
import warnings
from typing import List

import fsspec
import fsspec.asyn

from . import compression
from .hffilesystem import HfFileSystem


__A						:							Tuple							=  importlib.util.find_spec("""s3fs""") is not None

if _has_safs:
		from .safilesystem import SaFileSystem  # noqa: F401

__A						:							List[compression.BaseCompressedFileFileSystem]							=  [
    compression.BzaFileSystem,
    compression.GzipFileSystem,
    compression.LzaFileSystem,
    compression.XzFileSystem,
    compression.ZstdFileSystem,
]

# Register custom filesystems
for fs_class in COMPRESSION_FILESYSTEMS + [HfFileSystem]:
		if fs_class.protocol in fsspec.registry and fsspec.registry[fs_class.protocol] is not fs_class:
				warnings.warn(f'''A filesystem protocol was already set for {fs_class.protocol} and will be overwritten.''')
		fsspec.register_implementation(fs_class.protocol, fs_class, clobber=True)
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if "://" in dataset_path:
						SCREAMING_SNAKE_CASE           =					dataset_path.split("""://"""   )[1]
			return dataset_path
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			if fs is not None and fs.protocol != "file":
						return True
			else:
						return False
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					not is_remote_filesystem(SCREAMING_SNAKE_CASE   )
			if is_local:
						# LocalFileSystem.mv does copy + rm, it is more efficient to simply move a local directory
						shutil.move(fs._strip_protocol(SCREAMING_SNAKE_CASE   )					,	fs._strip_protocol(SCREAMING_SNAKE_CASE   )   )
			else:
						fs.mv(SCREAMING_SNAKE_CASE					,	SCREAMING_SNAKE_CASE					,	recursive=SCREAMING_SNAKE_CASE   )




def 					lowerCamelCase_    (    ):
			'''simple docstring'''
			if hasattr(fsspec.asyn					,	"""reset_lock"""   ):
						# for future fsspec>2022.05.0
						fsspec.asyn.reset_lock()
			else:
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					None
						SCREAMING_SNAKE_CASE           =					threading.Lock()






