
def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     list[int]		,    _lowerCamelCase					:     int)   ->       bool:






							'''simple docstring'''





							__UpperCamelCase      :  List[Any]       =   len(_lowerCamelCase)
							__UpperCamelCase      :  Any       =   [[False] * (required_sum + 1) for _ in range(arr_len + 1)]

							# for each arr value, a sum of zero(0) can be formed by not taking any element
							# hence True/1
							for i in range(arr_len + 1):
														__UpperCamelCase      :  int       =   True

							# sum is not zero and set is empty then false
							for i in range(1		,    required_sum + 1):
														__UpperCamelCase      :  List[str]       =   False

							for i in range(1		,    arr_len + 1):
														for j in range(1		,    required_sum + 1):
																					if arr[i - 1] > j:
																												__UpperCamelCase      :  int       =   subset[i - 1][j]
																					if arr[i - 1] <= j:
																												__UpperCamelCase      :  List[str]       =   subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

							return subset[arr_len][required_sum]


if __name__ == "__main__":
		import doctest

		doctest.testmod()

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase    :   Tuple						=			{
    'configuration_luke': ['LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LukeConfig'],
    'tokenization_luke': ['LukeTokenizer'],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase    :   int						=			[
		    'LUKE_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'LukeForEntityClassification',
		    'LukeForEntityPairClassification',
		    'LukeForEntitySpanClassification',
		    'LukeForMultipleChoice',
		    'LukeForQuestionAnswering',
		    'LukeForSequenceClassification',
		    'LukeForTokenClassification',
		    'LukeForMaskedLM',
		    'LukeModel',
		    'LukePreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
		from .tokenization_luke import LukeTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_luke import (
				    LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
				    LukeForEntityClassification,
				    LukeForEntityPairClassification,
				    LukeForEntitySpanClassification,
				    LukeForMaskedLM,
				    LukeForMultipleChoice,
				    LukeForQuestionAnswering,
				    LukeForSequenceClassification,
				    LukeForTokenClassification,
				    LukeModel,
				    LukePreTrainedModel,
				)

else:
		import sys

		lowercase    :   Any						=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)