
import math



def       __lowerCAmelCase      (						A       ,     A    ):
	if 0 not in (x, y):
		# We use the relation x^y = y*log10(x), where 10 is the base.
		return y * math.logaa(_SCREAMING_SNAKE_CASE    )
	else:
		if x == 0:  # 0 raised to any number is 0
			return 0
		elif y == 0:
			return 1  # any number raised to 0 is 1
	raise AssertionError("This should never happen"    )


if __name__ == "__main__":  # Main function
				# Read two numbers from input and typecast them to int using map function.
				# Here x is the base and y is the power.
				_a:    Optional[int] 							=			"""Enter the base and the power separated by a comma: """
				_a							,			_a:    List[str] 							=			map(int, input(prompt).split(""","""))
				_a							,			_a:    int 							=			map(int, input(prompt).split(""","""))

				# We find the log of each number, using the function res(), which takes two
				# arguments.
				_a:    Optional[Any] 							=			res(xa, ya)
				_a:    str 							=			res(xa, ya)

				# We check for the largest number
				if resa > resa:
								print("""Largest number is""", xa, """^""", ya)
				elif resa > resa:
								print("""Largest number is""", xa, """^""", ya)
				else:
								print("""Both are equal""")


from __future__ import annotations

class 						__UpperCamelCase    :




	def __init__(		self	:						Optional[Any]		,	lowerCAmelCase	:						str		,	lowerCAmelCase	:						str							):


		'''simple docstring'''







		UpperCAmelCase_				,   UpperCAmelCase_       				=			text, pattern
		UpperCAmelCase_				,   UpperCAmelCase_       				=			len(lowerCAmelCase							), len(lowerCAmelCase							)




	def       __A					(		self	:						List[str]		,	lowerCAmelCase	:						str							):


		'''simple docstring'''







		for i in range(self.patLen - 1		,	-1		,	-1							):
			if char == self.pattern[i]:
				return i
		return -1




	def       __A					(		self	:						int		,	lowerCAmelCase	:						int							):


		'''simple docstring'''







		for i in range(self.patLen - 1		,	-1		,	-1							):
			if self.pattern[i] != self.text[current_pos + i]:
				return current_pos + i
		return -1




	def       __A					(		self	:						str							):


		'''simple docstring'''







		UpperCAmelCase_       				=			[]
		for i in range(self.textLen - self.patLen + 1							):
			UpperCAmelCase_       				=			self.mismatch_in_text(lowerCAmelCase							)
			if mismatch_index == -1:
				positions.append(lowerCAmelCase							)
			else:
				UpperCAmelCase_       				=			self.match_in_pattern(self.text[mismatch_index]							)
				UpperCAmelCase_       				=			(
				    mismatch_index - match_index
				)  # shifting index lgtm [py/multiple-definition]
		return positions


_a:    Dict 							=			"""ABAABA"""
_a:    Union[str, Any] 							=			"""AB"""
_a:    str 							=			BoyerMooreSearch(text, pattern)
_a:    Dict 							=			bms.bad_character_heuristic()

if len(positions) == 0:
				print("""No match found""")
else:
				print("""Pattern found in following positions: """)
				print(positions)