


'''simple docstring'''
def       _lowercase							(					UpperCamelCase__							:       str,					UpperCamelCase__							:       int      ):
 __A	:		Tuple	  =      [[] for _ in range(_snake_case      )]
 __A	:		Union[str, Any]	  =      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      ):
  __A	:		List[Any]	  =      position % (lowest * 2)  # puts it in bounds
  __A	:		Tuple	  =      min(_snake_case,					lowest * 2 - num      )  # creates zigzag pattern
  temp_grid[num].append(_snake_case      )
 __A	:		List[str]	  =      [''.join(_snake_case      ) for row in temp_grid]
 __A	:		Dict	  =      ''.join(_snake_case      )

 return output_string


def       _lowercase							(					UpperCamelCase__							:       str,					UpperCamelCase__							:       int      ):
 __A	:		str	  =      []
 __A	:		Any	  =      key - 1

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

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

 __A	:		int	  =      0
 for row in temp_grid:  # fills in the characters
  __A	:		Union[str, Any]	  =      input_string[counter : counter + len(_snake_case      )]
  grid.append(list(_snake_case      )      )
  counter += len(_snake_case      )

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


def       _lowercase							(					UpperCamelCase__							:       str      ):
 __A	:		Dict	  =      {}
 for key_guess in range(1,					len(_snake_case      )      ):  # tries every key
  __A	:		Any	  =      decrypt(_snake_case,					_snake_case      )
 return results


if __name__ == "__main__":
 import doctest

 doctest.testmod()












"""simple docstring"""

from .configuration_bert_masked import MaskedBertConfig
from .modeling_bert_masked import (
    MaskedBertForMultipleChoice,
    MaskedBertForQuestionAnswering,
    MaskedBertForSequenceClassification,
    MaskedBertForTokenClassification,
    MaskedBertModel,
)
from .modules import *

