





def 				SCREAMING_SNAKE_CASE__							(       UpperCamelCase__:							str    ):

		# bit count represents no. of bits in the gray code
		if bit_count < 0:
				raise ValueError("""The given input must be positive"""    )

		# get the generated string sequence
		SCREAMING_SNAKE_CASE__			=      gray_code_sequence_string(SCREAMING_SNAKE_CASE_    )
		#
		# convert them to integers
		for i in range(len(SCREAMING_SNAKE_CASE_    )    ):
				SCREAMING_SNAKE_CASE__			=      int(sequence[i]					,   2    )

		return sequence






def 				SCREAMING_SNAKE_CASE__							(       UpperCamelCase__:							Union[str, Any]    ):

		# The approach is a recursive one
		# Base case achieved when either n = 0 or n=1
		if bit_count == 0:
				return ["0"]

		if bit_count == 1:
				return ["0", "1"]

		SCREAMING_SNAKE_CASE__			=      1 << bit_count  # defines the length of the sequence
		# 1<< n is equivalent to 2^n

		# recursive answer will generate answer for n-1 bits
		SCREAMING_SNAKE_CASE__			=      gray_code_sequence_string(bit_count - 1    )

		SCREAMING_SNAKE_CASE__			=      []

		# append 0 to first half of the smaller sequence generated
		for i in range(seq_len // 2    ):
				SCREAMING_SNAKE_CASE__			=      """0""" + smaller_sequence[i]
				sequence.append(SCREAMING_SNAKE_CASE_    )

		# append 1 to second half ... start from the end of the list
		for i in reversed(range(seq_len // 2    )    ):
				SCREAMING_SNAKE_CASE__			=      """1""" + smaller_sequence[i]
				sequence.append(SCREAMING_SNAKE_CASE_    )

		return sequence


if __name__ == "__main__":
	import doctest

	doctest.testmod()











from math import pow, sqrt






def 				SCREAMING_SNAKE_CASE__							(       *UpperCamelCase__:							float    ):
		SCREAMING_SNAKE_CASE__			=      len(UpperCamelCase__    ) > 0 and all(value > 0.0 for value in values    )
		return result






def 				SCREAMING_SNAKE_CASE__							(       UpperCamelCase__:							float					,   UpperCamelCase__:							float    ):
		return (
		    round(sqrt(molar_mass_a / molar_mass_a    )					,   6    )
		    if validate(UpperCamelCase__					,   UpperCamelCase__    )
		    else ValueError("""Input Error: Molar mass values must greater than 0."""    )
		)






def 				SCREAMING_SNAKE_CASE__							(       UpperCamelCase__:							float					,   UpperCamelCase__:							float					,   UpperCamelCase__:							float    ):
		return (
		    round(effusion_rate * sqrt(molar_mass_a / molar_mass_a    )					,   6    )
		    if validate(UpperCamelCase__					,   UpperCamelCase__					,   UpperCamelCase__    )
		    else ValueError(
		        """Input Error: Molar mass and effusion rate values must greater than 0."""    )
		)






def 				SCREAMING_SNAKE_CASE__							(       UpperCamelCase__:							float					,   UpperCamelCase__:							float					,   UpperCamelCase__:							float    ):
		return (
		    round(effusion_rate / sqrt(molar_mass_a / molar_mass_a    )					,   6    )
		    if validate(UpperCamelCase__					,   UpperCamelCase__					,   UpperCamelCase__    )
		    else ValueError(
		        """Input Error: Molar mass and effusion rate values must greater than 0."""    )
		)






def 				SCREAMING_SNAKE_CASE__							(       UpperCamelCase__:							float					,   UpperCamelCase__:							float					,   UpperCamelCase__:							float    ):
		return (
		    round(molar_mass / pow(effusion_rate_a / effusion_rate_a					,   2    )					,   6    )
		    if validate(UpperCamelCase__					,   UpperCamelCase__					,   UpperCamelCase__    )
		    else ValueError(
		        """Input Error: Molar mass and effusion rate values must greater than 0."""    )
		)






def 				SCREAMING_SNAKE_CASE__							(       UpperCamelCase__:							float					,   UpperCamelCase__:							float					,   UpperCamelCase__:							float    ):
		return (
		    round(pow(effusion_rate_a / effusion_rate_a					,   2    ) / molar_mass					,   6    )
		    if validate(UpperCamelCase__					,   UpperCamelCase__					,   UpperCamelCase__    )
		    else ValueError(
		        """Input Error: Molar mass and effusion rate values must greater than 0."""    )
		)