def      __lowercase  (		lowerCamelCase      :  int						,						lowerCamelCase      :  int			):
	UpperCamelCase_      :		Dict				=      1.0
	for i in range(1						,						r + 1			):
		ret *= (n + 1 - i) / i
	return round(_A			)





def      __lowercase  (		lowerCamelCase      :  int			):
	return choose(8 + n						,						_A			) + choose(9 + n						,						_A			) - 10





def      __lowercase  (		lowerCamelCase      :  int			):
	return sum(non_bouncy_exact(_A			) for i in range(1						,						n + 1			)			)





def      __lowercase  (		lowerCamelCase      :  int = 100			):
	return non_bouncy_upto(_A			)


if __name__ == "__main__":
			print(F"""{solution() = }""")




from typing import Any

import numpy as np





class 	_lowercase		:

 def __init__(				self			:							Dict     ,   snake_case			:							np.ndarray     ,   snake_case			:							int    )     ->		None:

  """simple docstring"""





  if np.any(tableau[:, -1]     ,   where=tableau[:, -1] < 0    ):
   raise ValueError('RHS must be > 0'    )

  UpperCamelCase_      :		List[str]				=      tableau
  UpperCamelCase_,				UpperCamelCase_      :		Tuple				=      tableau.shape

  # Number of decision variables x1, x2, x3...
  UpperCamelCase_      :		Dict				=      n_vars

  # Number of artificial variables to be minimised
  UpperCamelCase_      :		str				=      len(np.where(tableau[self.n_vars : -1] == -1    )[0]    )

  # 2 if there are >= or == constraints (nonstandard), 1 otherwise (std)
  UpperCamelCase_      :		int				=      (self.n_art_vars > 0) + 1

  # Number of slack variables added to make inequalities into equalities
  UpperCamelCase_      :		Union[str, Any]				=      self.n_rows - self.n_stages

  # Objectives for each stage
  UpperCamelCase_      :		Dict				=      ['max']

  # In two stage simplex, first minimise then maximise
  if self.n_art_vars:
   self.objectives.append('min'    )

  UpperCamelCase_      :		str				=      ['']

  # Index of current pivot row and column
  UpperCamelCase_      :		str				=      None
  UpperCamelCase_      :		Optional[int]				=      None

  # Does objective row only contain (non)-negative values?
  UpperCamelCase_      :		Any				=      False

 @staticmethod
 def 		SCREAMING_SNAKE_CASE__     (				*snake_case			:							int    )     ->		list[str]:

  """simple docstring"""





  if len(snake_case    ) != 3:
   raise ValueError('Must provide n_vars, n_slack, and n_art_vars'    )

  if not all(x >= 0 and isinstance(snake_case     ,   snake_case    ) for x in args    ):
   raise ValueError('All arguments must be non-negative integers'    )

  # decision | slack | artificial
  UpperCamelCase_      :		Tuple				=      ['x', 's', 'a']
  UpperCamelCase_      :		Optional[int]				=      []
  for i in range(3    ):
   for j in range(args[i]    ):
    titles.append(string_starts[i] + str(j + 1    )    )
  titles.append('RHS'    )
  return titles

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Any     ,   snake_case			:							np.ndarray    )     ->		tuple[Any, Any]:

  """simple docstring"""





  UpperCamelCase_      :		Any				=      self.objectives[-1]

  # Find entries of highest magnitude in objective rows
  UpperCamelCase_      :		str				=      (objective == 'min') - (objective == 'max')
  UpperCamelCase_      :		str				=      np.argmax(sign * tableau[0, : self.n_vars]    )

  # Choice is only valid if below 0 for maximise, and above for minimise
  if sign * self.tableau[0, col_idx] <= 0:
   UpperCamelCase_      :		Tuple				=      True
   return 0, 0

  # Pivot row is chosen as having the lowest quotient when elements of
  # the pivot column divide the right-hand side

  # Slice excluding the objective rows
  UpperCamelCase_      :		Dict				=      slice(self.n_stages     ,   self.n_rows    )

  # RHS
  UpperCamelCase_      :		str				=      tableau[s, -1]

  # Elements of pivot column within slice
  UpperCamelCase_      :		List[Any]				=      tableau[s, col_idx]

  # Array filled with nans
  UpperCamelCase_      :		Optional[int]				=      np.full(self.n_rows - self.n_stages     ,   np.nan    )

  # If element in pivot column is greater than zeron_stages, return
  # quotient or nan otherwise
  UpperCamelCase_      :		int				=      np.divide(snake_case     ,   snake_case     ,   out=snake_case     ,   where=divisor > 0    )

  # Arg of minimum quotient excluding the nan values. n_stages is added
  # to compensate for earlier exclusion of objective columns
  UpperCamelCase_      :		int				=      np.nanargmin(snake_case    ) + self.n_stages
  return row_idx, col_idx

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Any     ,   snake_case			:							np.ndarray     ,   snake_case			:							int     ,   snake_case			:							int    )     ->		np.ndarray:

  """simple docstring"""





  UpperCamelCase_      :		Union[str, Any]				=      tableau[row_idx].copy()

  UpperCamelCase_      :		List[Any]				=      piv_row[col_idx]

  # Entry becomes 1
  piv_row *= 1 / piv_val

  # Variable in pivot column becomes basic, ie the only non-zero entry
  for idx, coeff in enumerate(tableau[:, col_idx]    ):
   tableau[idx] += -coeff * piv_row
  UpperCamelCase_      :		Any				=      piv_row
  return tableau

 def 		SCREAMING_SNAKE_CASE__     (				self			:							str     ,   snake_case			:							np.ndarray    )     ->		np.ndarray:

  """simple docstring"""





  self.objectives.pop()

  if not self.objectives:
   return tableau

  # Slice containing ids for artificial columns
  UpperCamelCase_      :		int				=      slice(-self.n_art_vars - 1     ,   -1    )

  # Delete the artificial variable columns
  UpperCamelCase_      :		Any				=      np.delete(snake_case     ,   snake_case     ,   axis=1    )

  # Delete the objective row of the first stage
  UpperCamelCase_      :		Dict				=      np.delete(snake_case     ,   0     ,   axis=0    )

  UpperCamelCase_      :		List[Any]				=      1
  self.n_rows -= 1
  UpperCamelCase_      :		int				=      0
  UpperCamelCase_      :		Optional[int]				=      False
  return tableau

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Optional[Any]    )     ->		dict[Any, Any]:

  """simple docstring"""





  for _ in range(1_0_0    ):
   # Completion of each stage removes an objective. If both stages
   # are complete, then no objectives are left
   if not self.objectives:
    UpperCamelCase_      :		Any				=      self.generate_col_titles(
        self.n_vars     ,   self.n_slack     ,   self.n_art_vars    )

    # Find the values of each variable at optimal solution
    return self.interpret_tableau(self.tableau     ,   self.col_titles    )

   UpperCamelCase_,				UpperCamelCase_      :		Tuple				=      self.find_pivot(self.tableau    )

   # If there are no more negative values in objective row
   if self.stop_iter:
    # Delete artificial variable columns and rows. Update attributes
    UpperCamelCase_      :		Union[str, Any]				=      self.change_stage(self.tableau    )
   else:
    UpperCamelCase_      :		Union[str, Any]				=      self.pivot(self.tableau     ,   snake_case     ,   snake_case    )
  return {}


 def 		SCREAMING_SNAKE_CASE__     (				self			:							Tuple     ,   snake_case			:							np.ndarray     ,   snake_case			:							list[str]    )     ->		dict[str, float]:

  """simple docstring"""





  UpperCamelCase_      :		str				=      {'P': abs(tableau[0, -1]    )}

  for i in range(self.n_vars    ):
   # Gives ids of nonzero entries in the ith column
   UpperCamelCase_      :		Dict				=      np.nonzero(tableau[:, i]    )
   UpperCamelCase_      :		Union[str, Any]				=      len(nonzero[0]    )

   # First entry in the nonzero ids
   UpperCamelCase_      :		Optional[int]				=      nonzero[0][0]
   UpperCamelCase_      :		Union[str, Any]				=      tableau[nonzero_rowidx, i]

   # If there is only one nonzero value in column, which is one
   if n_nonzero == nonzero_val == 1:
    UpperCamelCase_      :		Optional[int]				=      tableau[nonzero_rowidx, -1]
    UpperCamelCase_      :		Union[str, Any]				=      rhs_val

        # Check for basic variables
  for title in col_titles:
   # Don't add RHS or slack variables to output dict
   if title[0] not in "R-s-a":
    output_dict.setdefault(snake_case     ,   0    )
  return output_dict


if __name__ == "__main__":
   import doctest

   doctest.testmod()



