"""simple docstring"""






__lowerCAmelCase					: Optional[Any]        =2_5_6
# Modulus to hash a string
__lowerCAmelCase					: Any        =1_0_0_0_0_0_3


def     UpperCAmelCase__ (       lowerCAmelCase__  :str      ,	lowerCAmelCase__  :str	)				->					bool:
      '''simple docstring'''


      lowercase														=			len(lowerCAmelCase__	)
      lowercase														=			len(lowerCAmelCase__	)
      if p_len > t_len:
            return False

      lowercase														=			0
      lowercase														=			0
      lowercase														=			1

      # Calculating the hash of pattern and substring of text
      for i in range(lowerCAmelCase__	):
            lowercase														=			(ord(pattern[i]	) + p_hash * alphabet_size) % modulus
            lowercase														=			(ord(text[i]	) + text_hash * alphabet_size) % modulus
            if i == p_len - 1:
                  continue
            lowercase														=			(modulus_power * alphabet_size) % modulus

      for i in range(0      ,	t_len - p_len + 1	):
            if text_hash == p_hash and text[i : i + p_len] == pattern:
                  return True
            if i == t_len - p_len:
                  continue
            # Calculate the https://en.wikipedia.org/wiki/Rolling_hash
            lowercase														=			(
                (text_hash - ord(text[i]	) * modulus_power) * alphabet_size
                + ord(text[i + p_len]	)
            ) % modulus
      return False


def     UpperCAmelCase__ (       )				->					None:
      '''simple docstring'''


      lowercase														=			"""abc1abc12"""
      lowercase														=			"""alskfjaldsabc1abc1abc12k23adsfabcabc"""
      lowercase														=			"""alskfjaldsk23adsfabcabc"""
      assert rabin_karp(lowerCAmelCase__      ,	lowerCAmelCase__	) and not rabin_karp(lowerCAmelCase__      ,	lowerCAmelCase__	)

      # Test 2)
      lowercase														=			"""ABABX"""
      lowercase														=			"""ABABZABABYABABX"""
      assert rabin_karp(lowerCAmelCase__      ,	lowerCAmelCase__	)

      # Test 3)
      lowercase														=			"""AAAB"""
      lowercase														=			"""ABAAAAAB"""
      assert rabin_karp(lowerCAmelCase__      ,	lowerCAmelCase__	)

      # Test 4)
      lowercase														=			"""abcdabcy"""
      lowercase														=			"""abcxabcdabxabcdabcdabcy"""
      assert rabin_karp(lowerCAmelCase__      ,	lowerCAmelCase__	)

      # Test 5)
      lowercase														=			"""Lü"""
      lowercase														=			"""Lüsai"""
      assert rabin_karp(lowerCAmelCase__      ,	lowerCAmelCase__	)
      lowercase														=			"""Lue"""
      assert not rabin_karp(lowerCAmelCase__      ,	lowerCAmelCase__	)
      print("""Success."""	)


if __name__ == "__main__":
       test_rabin_karp()




"""simple docstring"""






# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from argparse import ArgumentParser

from accelerate.commands.config import get_config_parser
from accelerate.commands.env import env_command_parser
from accelerate.commands.launch import launch_command_parser
from accelerate.commands.test import test_command_parser
from accelerate.commands.tpu import tpu_command_parser


def     UpperCAmelCase__ (       )				->					Tuple:
      '''simple docstring'''


      lowercase														=			ArgumentParser("""Accelerate CLI tool"""      ,	usage="""accelerate <command> [<args>]"""      ,	allow_abbrev=lowerCAmelCase__	)
      lowercase														=			parser.add_subparsers(help="""accelerate command helpers"""	)

      # Register commands
      get_config_parser(subparsers=lowerCAmelCase__	)
      env_command_parser(subparsers=lowerCAmelCase__	)
      launch_command_parser(subparsers=lowerCAmelCase__	)
      tpu_command_parser(subparsers=lowerCAmelCase__	)
      test_command_parser(subparsers=lowerCAmelCase__	)

      # Let's go
      lowercase														=			parser.parse_args()

      if not hasattr(lowerCAmelCase__      ,	"""func"""	):
            parser.print_help()
            exit(1	)

      # Run
      args.func(lowerCAmelCase__	)


if __name__ == "__main__":
       main()



