
import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY




@is_pipeline_test
class     _SCREAMING_SNAKE_CASE     (      unittest.TestCase						):
	lowerCAmelCase__         = MODEL_FOR_MASKED_LM_MAPPING
	lowerCAmelCase__         = TF_MODEL_FOR_MASKED_LM_MAPPING



	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					super().tearDown()
					# clean-up as much as possible GPU memory occupied by PyTorch
					gc.collect()
					if is_torch_available():
									import torch

									torch.cuda.empty_cache()



	@require_tf
	def     SCREAMING_SNAKE_CASE_(    self )				->       Tuple:
					lowerCamelCase_						=			pipeline(task="fill-mask"						,  model="sshleifer/tiny-distilroberta-base"						,  top_k=2						,  framework="tf" )
					lowerCamelCase_						=			unmasker("My name is <mask>" )
					self.assertEqual(
					    nested_simplify(lowercase						,  decimals=6 )						,  [
					        {"sequence": "My name is grouped", "score": 2.1e-05, "token": 38015, "token_str": " grouped"},
					        {"sequence": "My name is accuser", "score": 2.1e-05, "token": 25506, "token_str": " accuser"},
					    ]						,  )

					lowerCamelCase_						=			unmasker("The largest city in France is <mask>" )
					self.assertEqual(
					    nested_simplify(lowercase						,  decimals=6 )						,  [
					        {
					            "sequence": "The largest city in France is grouped",
					            "score": 2.1e-05,
					            "token": 38015,
					            "token_str": " grouped",
					        },
					        {
					            "sequence": "The largest city in France is accuser",
					            "score": 2.1e-05,
					            "token": 25506,
					            "token_str": " accuser",
					        },
					    ]						,  )

					lowerCamelCase_						=			unmasker("My name is <mask>"						,  targets=[" Patrick", " Clara", " Teven"]						,  top_k=3 )
					self.assertEqual(
					    nested_simplify(lowercase						,  decimals=6 )						,  [
					        {"sequence": "My name is Clara", "score": 2e-05, "token": 13606, "token_str": " Clara"},
					        {"sequence": "My name is Patrick", "score": 2e-05, "token": 3499, "token_str": " Patrick"},
					        {"sequence": "My name is Te", "score": 1.9e-05, "token": 2941, "token_str": " Te"},
					    ]						,  )



	@require_torch
	def     SCREAMING_SNAKE_CASE_(    self )				->       List[Any]:
					lowerCamelCase_						=			pipeline(task="fill-mask"						,  model="sshleifer/tiny-distilroberta-base"						,  top_k=2						,  framework="pt" )

					lowerCamelCase_						=			unmasker("My name is <mask>" )
					self.assertEqual(
					    nested_simplify(lowercase						,  decimals=6 )						,  [
					        {"sequence": "My name is Maul", "score": 2.2e-05, "token": 35676, "token_str": " Maul"},
					        {"sequence": "My name isELS", "score": 2.2e-05, "token": 16416, "token_str": "ELS"},
					    ]						,  )

					lowerCamelCase_						=			unmasker("The largest city in France is <mask>" )
					self.assertEqual(
					    nested_simplify(lowercase						,  decimals=6 )						,  [
					        {
					            "sequence": "The largest city in France is Maul",
					            "score": 2.2e-05,
					            "token": 35676,
					            "token_str": " Maul",
					        },
					        {"sequence": "The largest city in France isELS", "score": 2.2e-05, "token": 16416, "token_str": "ELS"},
					    ]						,  )

					lowerCamelCase_						=			unmasker("My name is <mask>"						,  targets=[" Patrick", " Clara", " Teven"]						,  top_k=3 )
					self.assertEqual(
					    nested_simplify(lowercase						,  decimals=6 )						,  [
					        {"sequence": "My name is Patrick", "score": 2.1e-05, "token": 3499, "token_str": " Patrick"},
					        {"sequence": "My name is Te", "score": 2e-05, "token": 2941, "token_str": " Te"},
					        {"sequence": "My name is Clara", "score": 2e-05, "token": 13606, "token_str": " Clara"},
					    ]						,  )

					lowerCamelCase_						=			unmasker("My name is <mask> <mask>"						,  top_k=2 )

					self.assertEqual(
					    nested_simplify(lowercase						,  decimals=6 )						,  [
					        [
					            {
					                "score": 2.2e-05,
					                "token": 35676,
					                "token_str": " Maul",
					                "sequence": "<s>My name is Maul<mask></s>",
					            },
					            {"score": 2.2e-05, "token": 16416, "token_str": "ELS", "sequence": "<s>My name isELS<mask></s>"},
					        ],
					        [
					            {
					                "score": 2.2e-05,
					                "token": 35676,
					                "token_str": " Maul",
					                "sequence": "<s>My name is<mask> Maul</s>",
					            },
					            {"score": 2.2e-05, "token": 16416, "token_str": "ELS", "sequence": "<s>My name is<mask>ELS</s>"},
					        ],
					    ]						,  )



	@require_torch_gpu
	def     SCREAMING_SNAKE_CASE_(    self )				->       Union[str, Any]:
					lowerCamelCase_						=			pipeline("fill-mask"						,  model="hf-internal-testing/tiny-random-distilbert"						,  device=0						,  framework="pt" )

					# convert model to fp16
					pipe.model.half()

					lowerCamelCase_						=			pipe("Paris is the [MASK] of France." )
					# We actually don't care about the result, we just want to make sure
					# it works, meaning the float16 tensor got casted back to float32
					# for postprocessing.
					self.assertIsInstance(lowercase						,  lowercase )



	@slow
	@require_torch
	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[int]:
					lowerCamelCase_						=			pipeline(task="fill-mask"						,  model="distilroberta-base"						,  top_k=2						,  framework="pt" )
					self.run_large_test(lowercase )



	@slow
	@require_tf
	def     SCREAMING_SNAKE_CASE_(    self )				->       Optional[Any]:
					lowerCamelCase_						=			pipeline(task="fill-mask"						,  model="distilroberta-base"						,  top_k=2						,  framework="tf" )
					self.run_large_test(lowercase )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase )				->       int:
					lowerCamelCase_						=			unmasker("My name is <mask>" )
					self.assertEqual(
					    nested_simplify(lowercase )						,  [
					        {"sequence": "My name is John", "score": 0.0_0_8, "token": 610, "token_str": " John"},
					        {"sequence": "My name is Chris", "score": 0.0_0_7, "token": 1573, "token_str": " Chris"},
					    ]						,  )
					lowerCamelCase_						=			unmasker("The largest city in France is <mask>" )
					self.assertEqual(
					    nested_simplify(lowercase )						,  [
					        {
					            "sequence": "The largest city in France is Paris",
					            "score": 0.2_5_1,
					            "token": 2201,
					            "token_str": " Paris",
					        },
					        {
					            "sequence": "The largest city in France is Lyon",
					            "score": 0.2_1_4,
					            "token": 12790,
					            "token_str": " Lyon",
					        },
					    ]						,  )

					lowerCamelCase_						=			unmasker("My name is <mask>"						,  targets=[" Patrick", " Clara", " Teven"]						,  top_k=3 )
					self.assertEqual(
					    nested_simplify(lowercase )						,  [
					        {"sequence": "My name is Patrick", "score": 0.0_0_5, "token": 3499, "token_str": " Patrick"},
					        {"sequence": "My name is Clara", "score": 0.0_0_0, "token": 13606, "token_str": " Clara"},
					        {"sequence": "My name is Te", "score": 0.0_0_0, "token": 2941, "token_str": " Te"},
					    ]						,  )



	@require_torch
	def     SCREAMING_SNAKE_CASE_(    self )				->       int:
					lowerCamelCase_						=			pipeline(task="fill-mask"						,  model="sshleifer/tiny-distilroberta-base"						,  framework="pt" )
					lowerCamelCase_						=			None
					lowerCamelCase_						=			None
					self.run_pipeline_test(lowercase						,  [] )



	@require_tf
	def     SCREAMING_SNAKE_CASE_(    self )				->       List[Any]:
					lowerCamelCase_						=			pipeline(task="fill-mask"						,  model="sshleifer/tiny-distilroberta-base"						,  framework="tf" )
					lowerCamelCase_						=			None
					lowerCamelCase_						=			None
					self.run_pipeline_test(lowercase						,  [] )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase						,  lowercase )				->       Union[str, Any]:
					if tokenizer is None or tokenizer.mask_token_id is None:
									self.skipTest("The provided tokenizer has no mask token, (probably reformer or wav2vec2)" )

					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase )
					lowerCamelCase_						=			[
					    f'This is another {tokenizer.mask_token} test',
					]
					return fill_masker, examples



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase )				->       Dict:
					lowerCamelCase_						=			fill_masker.tokenizer
					lowerCamelCase_						=			fill_masker.model

					lowerCamelCase_						=			fill_masker(
					    f'This is a {tokenizer.mask_token}'						,  )
					self.assertEqual(
					    lowercase						,  [
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					    ]						,  )

					lowerCamelCase_						=			fill_masker([f'This is a {tokenizer.mask_token}'] )
					self.assertEqual(
					    lowercase						,  [
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					    ]						,  )

					lowerCamelCase_						=			fill_masker([f'This is a {tokenizer.mask_token}', f'Another {tokenizer.mask_token} great test.'] )
					self.assertEqual(
					    lowercase						,  [
					        [
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        ],
					        [
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        ],
					    ]						,  )

					with self.assertRaises(lowercase ):
									fill_masker([None] )
					# No mask_token is not supported
					with self.assertRaises(lowercase ):
									fill_masker("This is" )

					self.run_test_top_k(lowercase						,  lowercase )
					self.run_test_targets(lowercase						,  lowercase )
					self.run_test_top_k_targets(lowercase						,  lowercase )
					self.fill_mask_with_duplicate_targets_and_top_k(lowercase						,  lowercase )
					self.fill_mask_with_multiple_masks(lowercase						,  lowercase )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase )				->       Dict:
					lowerCamelCase_						=			tokenizer.get_vocab()
					lowerCamelCase_						=			sorted(vocab.keys() )[:2]
					# Pipeline argument
					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase						,  targets=lowercase )
					lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}' )
					self.assertEqual(
					    lowercase						,  [
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					    ]						,  )
					lowerCamelCase_						=			{vocab[el] for el in targets}
					self.assertEqual({el["token"] for el in outputs}						,  lowercase )
					lowerCamelCase_						=			[tokenizer.decode([x] ) for x in target_ids]
					self.assertEqual({el["token_str"] for el in outputs}						,  set(lowercase ) )

					# Call argument
					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase )
					lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  targets=lowercase )
					self.assertEqual(
					    lowercase						,  [
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					    ]						,  )
					lowerCamelCase_						=			{vocab[el] for el in targets}
					self.assertEqual({el["token"] for el in outputs}						,  lowercase )
					lowerCamelCase_						=			[tokenizer.decode([x] ) for x in target_ids]
					self.assertEqual({el["token_str"] for el in outputs}						,  set(lowercase ) )

					# Score equivalence
					lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  targets=lowercase )
					lowerCamelCase_						=			[top_mask["token_str"] for top_mask in outputs]
					lowerCamelCase_						=			[top_mask["score"] for top_mask in outputs]

					# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
					if set(lowercase ) == set(lowercase ):
									lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  targets=lowercase )
									lowerCamelCase_						=			[top_mask["score"] for top_mask in unmasked_targets]
									self.assertEqual(nested_simplify(lowercase )						,  nested_simplify(lowercase ) )

					# Raises with invalid
					with self.assertRaises(lowercase ):
									lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  targets=[] )
					# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
					if "" not in tokenizer.get_vocab():
									with self.assertRaises(lowercase ):
													lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  targets=[""] )
									with self.assertRaises(lowercase ):
													lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  targets="" )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase )				->       List[Any]:
					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase						,  top_k=2 )
					lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}' )
					self.assertEqual(
					    lowercase						,  [
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					    ]						,  )

					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase )
					lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  top_k=2 )
					self.assertEqual(
					    lowercase						,  [
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					    ]						,  )
					self.assertEqual(nested_simplify(lowercase )						,  nested_simplify(lowercase ) )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase )				->       List[Any]:
					lowerCamelCase_						=			tokenizer.get_vocab()
					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase )

					# top_k=2, ntargets=3
					lowerCamelCase_						=			sorted(vocab.keys() )[:3]
					lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  top_k=2						,  targets=lowercase )

					# If we use the most probably targets, and filter differently, we should still
					# have the same results
					lowerCamelCase_						=			[el["token_str"] for el in sorted(lowercase						,  key=lambda lowercase : x["score"]						,  reverse=lowercase )]
					# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
					if set(lowercase ).issubset(lowercase ):
									lowerCamelCase_						=			fill_masker(f'This is a {tokenizer.mask_token}'						,  top_k=3						,  targets=lowercase )
									# They should yield exactly the same result
									self.assertEqual(nested_simplify(lowercase )						,  nested_simplify(lowercase ) )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase )				->       List[Any]:
					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase )
					lowerCamelCase_						=			tokenizer.get_vocab()
					# String duplicates + id duplicates
					lowerCamelCase_						=			sorted(vocab.keys() )[:3]
					lowerCamelCase_						=			[targets[0], targets[1], targets[0], targets[2], targets[1]]
					lowerCamelCase_						=			fill_masker(f'My name is {tokenizer.mask_token}'						,  targets=lowercase						,  top_k=10 )

					# The target list contains duplicates, so we can't output more
					# than them
					self.assertEqual(len(lowercase )						,  3 )



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase )				->       Dict:
					lowerCamelCase_						=			FillMaskPipeline(model=lowercase						,  tokenizer=lowercase )

					lowerCamelCase_						=			fill_masker(
					    f'This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}'						,  top_k=2 )
					self.assertEqual(
					    lowercase						,  [
					        [
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        ],
					        [
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        ],
					        [
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					            {"sequence": ANY(lowercase ), "score": ANY(lowercase ), "token": ANY(lowercase ), "token_str": ANY(lowercase )},
					        ],
					    ]						,  )






def       lowercase_		(		_A			:    int    ,					_A			:    list						):

      """simple docstring"""




      _enforce_args(_A    ,					_A						)
      if n == 0:
            return 0
      lowerCamelCase__		:				Union[str, Any]    =  float("-inf"						)
      for i in range(1    ,					n + 1						):
            lowerCamelCase__		:				int    =  max(
                _A    ,					prices[i - 1] + naive_cut_rod_recursive(n - i    ,					_A						)						)

      return max_revue

def       lowercase_		(		_A			:    int    ,					_A			:    list						):

      """simple docstring"""




      _enforce_args(_A    ,					_A						)
      lowerCamelCase__		:				int    =  [float("-inf"						) for _ in range(n + 1						)]
      return _top_down_cut_rod_recursive(_A    ,					_A    ,					_A						)

def       lowercase_		(		_A			:    int    ,					_A			:    list    ,					_A			:    list						):

      """simple docstring"""




      if max_rev[n] >= 0:
            return max_rev[n]
      elif n == 0:
            return 0
      else:
            lowerCamelCase__		:				Dict    =  float("-inf"						)
            for i in range(1    ,					n + 1						):
                  lowerCamelCase__		:				int    =  max(
                      _A    ,					prices[i - 1] + _top_down_cut_rod_recursive(n - i    ,					_A    ,					_A						)    ,					)

            lowerCamelCase__		:				List[Any]    =  max_revenue

      return max_rev[n]

def       lowercase_		(		_A			:    int    ,					_A			:    list						):

      """simple docstring"""




      _enforce_args(_A    ,					_A						)

      # length(max_rev) = n + 1, to accommodate for the revenue obtainable from a rod of
      # length 0.
      lowerCamelCase__		:				int    =  [float("-inf"						) for _ in range(n + 1						)]
      lowerCamelCase__		:				Optional[int]    =  0

      for i in range(1    ,					n + 1						):
            lowerCamelCase__		:				Union[str, Any]    =  max_rev[i]
            for j in range(1    ,					i + 1						):
                  lowerCamelCase__		:				Any    =  max(_A    ,					prices[j - 1] + max_rev[i - j]						)

            lowerCamelCase__		:				Any    =  max_revenue_i

      return max_rev[n]

def       lowercase_		(		_A			:    int    ,					_A			:    list						):

      """simple docstring"""




      if n < 0:
            lowerCamelCase__		:				Optional[int]    =  F"n must be greater than or equal to 0. Got n = {n}"
            raise ValueError(_A						)

      if n > len(_A						):
            lowerCamelCase__		:				Optional[int]    =  (
                "Each integral piece of rod must have a corresponding price. "
                F"Got n = {n} but length of prices = {len(_A						)}"
            )
            raise ValueError(_A						)

def       lowercase_		(		):

      """simple docstring"""




      lowerCamelCase__		:				Optional[Any]    =  [6, 10, 12, 15, 20, 23]
      lowerCamelCase__		:				Dict    =  len(_A						)

      # the best revenue comes from cutting the rod into 6 pieces, each
      # of length 1 resulting in a revenue of 6 * 6 = 36.
      lowerCamelCase__		:				int    =  36

      lowerCamelCase__		:				List[Any]    =  top_down_cut_rod(_A    ,					_A						)
      lowerCamelCase__		:				List[Any]    =  bottom_up_cut_rod(_A    ,					_A						)
      lowerCamelCase__		:				List[Any]    =  naive_cut_rod_recursive(_A    ,					_A						)

      assert expected_max_revenue == max_rev_top_down
      assert max_rev_top_down == max_rev_bottom_up
      assert max_rev_bottom_up == max_rev_naive


if __name__ == "__main__":
    main()


