






def 					lowercase_ (    __snake_case     :							str	,	__snake_case     :							int      )     -> str:





				'''simple docstring'''


				snake_case__      :list[list[str]]         =   [[] for _ in range(__snake_case      )]
				snake_case__      :List[str]         =   key - 1

				if key <= 0:
								raise ValueError("Height of grid can't be 0 or negative"      )
				if key == 1 or len(__snake_case      ) <= key:
								return input_string

				for position, character in enumerate(__snake_case      ):
								snake_case__      :str         =   position % (lowest * 2)  # puts it in bounds
								snake_case__      :str         =   min(__snake_case	,	lowest * 2 - num      )  # creates zigzag pattern
								temp_grid[num].append(__snake_case      )
				snake_case__      :Union[str, Any]         =   ["".join(__snake_case      ) for row in temp_grid]
				snake_case__      :Optional[int]         =   "".join(__snake_case      )

				return output_string





def 					lowercase_ (    __snake_case     :							str	,	__snake_case     :							int      )     -> str:





				'''simple docstring'''


				snake_case__      :Union[str, Any]         =   []
				snake_case__      :Tuple         =   key - 1

				if key <= 0:
								raise ValueError("Height of grid can't be 0 or negative"      )
				if key == 1:
								return input_string

				snake_case__      :list[list[str]]         =   [[] for _ in range(__snake_case      )]  # generates template
				for position in range(len(__snake_case      )      ):
								snake_case__      :Tuple         =   position % (lowest * 2)  # puts it in bounds
								snake_case__      :Union[str, Any]         =   min(__snake_case	,	lowest * 2 - num      )  # creates zigzag pattern
								temp_grid[num].append("*"      )

				snake_case__      :str         =   0
				for row in temp_grid:  # fills in the characters
								snake_case__      :Dict         =   input_string[counter : counter + len(__snake_case      )]
								grid.append(list(__snake_case      )      )
								counter += len(__snake_case      )

				snake_case__      :Union[str, Any]         =   ""  # reads as zigzag
				for position in range(len(__snake_case      )      ):
								snake_case__      :Any         =   position % (lowest * 2)  # puts it in bounds
								snake_case__      :int         =   min(__snake_case	,	lowest * 2 - num      )  # creates zigzag pattern
								output_string += grid[num][0]
								grid[num].pop(0      )
				return output_string





def 					lowercase_ (    __snake_case     :							str      )     -> dict[int, str]:





				'''simple docstring'''


				snake_case__      :Tuple         =   {}
				for key_guess in range(1	,	len(__snake_case      )      ):  # tries every key
								snake_case__      :Dict         =   decrypt(__snake_case	,	__snake_case      )
				return results


if __name__ == "__main__":
	import doctest

	doctest.testmod()







def 					lowercase_ (    __snake_case     :							int = 10_00      )     -> int:





				'''simple docstring'''


				snake_case__      :int         =   3
				snake_case__      :int         =   0
				while a < n:
								if a % 3 == 0 or a % 5 == 0:
												result += a
								elif a % 15 == 0:
												result -= a
								a += 1
				return result


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