
"""simple docstring"""



import flax.linen as nn
import jax
import jax.numpy as jnp





class 				a			(					nn.Module      ):
      UpperCamelCase							:   int
      UpperCamelCase							:   jnp.dtype           =     jnp.floataa



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      int     							=					nn.Conv(
              self.out_channels     ,	kernel_size=(3, 3)     ,	strides=(1, 1)     ,	padding=((1, 1), (1, 1))     ,	dtype=self.dtype     ,	)



      def __call__(   self     ,	UpperCamelCase_      ):
          UpperCAmelCase__							,							UpperCAmelCase__							,							UpperCAmelCase__							,							UpperCAmelCase__	:      List[Any]     							=					hidden_states.shape
          UpperCAmelCase__	:      List[Any]     							=					jax.image.resize(
              UpperCamelCase_     ,	shape=(batch, height * 2, width * 2, channels)     ,	method='nearest'     ,	)
          UpperCAmelCase__	:      Dict     							=					self.conv(UpperCamelCase_      )
          return hidden_states





class 				a			(					nn.Module      ):
      UpperCamelCase							:   int
      UpperCamelCase							:   jnp.dtype           =     jnp.floataa



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      Any     							=					nn.Conv(
              self.out_channels     ,	kernel_size=(3, 3)     ,	strides=(2, 2)     ,	padding=((1, 1), (1, 1))     ,	dtype=self.dtype     ,	)



      def __call__(   self     ,	UpperCamelCase_      ):
          # pad = ((0, 0), (0, 1), (0, 1), (0, 0))  # pad height and width dim
          # hidden_states = jnp.pad(hidden_states, pad_width=pad)
          UpperCAmelCase__	:      List[str]     							=					self.conv(UpperCamelCase_      )
          return hidden_states





class 				a			(					nn.Module      ):
      UpperCamelCase							:   int
      UpperCamelCase							:   int           =     None
      UpperCamelCase							:   float           =     0.0
      UpperCamelCase							:   bool           =     None
      UpperCamelCase							:   jnp.dtype           =     jnp.floataa



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      Optional[Any]     							=					self.in_channels if self.out_channels is None else self.out_channels

          UpperCAmelCase__	:      Union[str, Any]     							=					nn.GroupNorm(num_groups=32     ,	epsilon=1E-5      )
          UpperCAmelCase__	:      List[Any]     							=					nn.Conv(
              UpperCamelCase_     ,	kernel_size=(3, 3)     ,	strides=(1, 1)     ,	padding=((1, 1), (1, 1))     ,	dtype=self.dtype     ,	)

          UpperCAmelCase__	:      Any     							=					nn.Dense(UpperCamelCase_     ,	dtype=self.dtype      )

          UpperCAmelCase__	:      Tuple     							=					nn.GroupNorm(num_groups=32     ,	epsilon=1E-5      )
          UpperCAmelCase__	:      List[Any]     							=					nn.Dropout(self.dropout_prob      )
          UpperCAmelCase__	:      List[Any]     							=					nn.Conv(
              UpperCamelCase_     ,	kernel_size=(3, 3)     ,	strides=(1, 1)     ,	padding=((1, 1), (1, 1))     ,	dtype=self.dtype     ,	)

          UpperCAmelCase__	:      Dict     							=					self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut

          UpperCAmelCase__	:      Optional[int]     							=					None
          if use_nin_shortcut:
              UpperCAmelCase__	:      Union[str, Any]     							=					nn.Conv(
                  UpperCamelCase_     ,	kernel_size=(1, 1)     ,	strides=(1, 1)     ,	padding='VALID'     ,	dtype=self.dtype     ,	)



      def __call__(   self     ,	UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_=True      ):
          UpperCAmelCase__	:      str     							=					hidden_states
          UpperCAmelCase__	:      Tuple     							=					self.norma(UpperCamelCase_      )
          UpperCAmelCase__	:      str     							=					nn.swish(UpperCamelCase_      )
          UpperCAmelCase__	:      int     							=					self.conva(UpperCamelCase_      )

          UpperCAmelCase__	:      Dict     							=					self.time_emb_proj(nn.swish(UpperCamelCase_      )      )
          UpperCAmelCase__	:      List[Any]     							=					jnp.expand_dims(jnp.expand_dims(UpperCamelCase_     ,	1      )     ,	1      )
          UpperCAmelCase__	:      Dict     							=					hidden_states + temb

          UpperCAmelCase__	:      Optional[int]     							=					self.norma(UpperCamelCase_      )
          UpperCAmelCase__	:      List[Any]     							=					nn.swish(UpperCamelCase_      )
          UpperCAmelCase__	:      int     							=					self.dropout(UpperCamelCase_     ,	UpperCamelCase_      )
          UpperCAmelCase__	:      Optional[int]     							=					self.conva(UpperCamelCase_      )

          if self.conv_shortcut is not None:
              UpperCAmelCase__	:      str     							=					self.conv_shortcut(UpperCamelCase_      )

          return hidden_states + residual



"""simple docstring"""



def 					lowerCamelCase   (     _snake_case    ,_snake_case    ,_snake_case ):
    if len(_snake_case ) != len(_snake_case ):
        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.
    UpperCAmelCase__	:      Any     							=					[p / w for p, w in zip(_snake_case    ,_snake_case )]

    # Creating a copy of the list and sorting profit/weight in ascending order
    UpperCAmelCase__	:      Union[str, Any]     							=					sorted(_snake_case )

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

    UpperCamelCase__          =	[int(x) for x in input('Input profits separated by spaces: ').split()]
    UpperCamelCase__          =	[int(x) for x in input('Input weights separated by spaces: ').split()]
    UpperCamelCase__          =	int(input('Max weight allowed: '))

    # Function Call
    calc_profit(profit, weight, max_weight)

