


from __future__ import annotations

class     a		:




							"""simple docstring"""


							def __init__(							self	:  Tuple   ,     lowerCamelCase	:  str   ,     lowerCamelCase	:  str    )     ->   Tuple:
														__snake_case			,      __snake_case		:      Any										=       text, pattern
														__snake_case			,      __snake_case		:      Any										=       len(lowerCamelCase    ), len(lowerCamelCase    )

							def    __snake_case (							self	:  Any   ,     lowerCamelCase	:  str    )     ->   int:

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

							def    __snake_case (							self	:  Optional[Any]   ,     lowerCamelCase	:  int    )     ->   int:

														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    __snake_case (							self	:  int    )     ->   list[int]:
														# searches pattern in text and returns index positions
														__snake_case		:      Optional[int]										=       []
														for i in range(self.textLen - self.patLen + 1    ):
																					__snake_case		:      Optional[Any]										=       self.mismatch_in_text(lowerCamelCase    )
																					if mismatch_index == -1:
																												positions.append(lowerCamelCase    )
																					else:
																												__snake_case		:      Optional[int]										=       self.match_in_pattern(self.text[mismatch_index]    )
																												__snake_case		:      Union[str, Any]										=       (
																												    mismatch_index - match_index
																												)  # shifting index lgtm [py/multiple-definition]
														return positions
_snake_case					:		Dict      =    "ABAABA"
_snake_case					:		Dict      =    "AB"
_snake_case					:		Tuple      =    BoyerMooreSearch(text, pattern)
_snake_case					:		Dict      =    bms.bad_character_heuristic()

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





def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							return x if y == 0 else greatest_common_divisor(__lowerCamelCase							,     x % y     )







def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase     ):
							return (x * y) // greatest_common_divisor(__lowerCamelCase							,     __lowerCamelCase     )







def     lowerCAmelCase_					( __lowerCamelCase = 2_0     ):
							__snake_case		:      Optional[Any]										=       1
							for i in range(1							,     n + 1     ):
														__snake_case		:      Any										=       lcm(__lowerCamelCase							,     __lowerCamelCase     )
							return g


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

