

def 			_A	(      SCREAMING_SNAKE_CASE      ):
	UpperCAmelCase__:	List[Any]									= hex_num.strip()
	if not hex_num:
		raise ValueError("No value was passed to the function"      )

	UpperCAmelCase__:	Dict									= hex_num[0] == "-"
	if is_negative:
		UpperCAmelCase__:	List[Any]									= hex_num[1:]

	try:
		UpperCAmelCase__:	Union[str, Any]									= int(SCREAMING_SNAKE_CASE	,1_6      )
	except ValueError:
		raise ValueError("Invalid value was passed to the function"      )

	UpperCAmelCase__:	Optional[int]									= ""
	while int_num > 0:
		UpperCAmelCase__:	Optional[Any]									= str(int_num % 2      ) + bin_str
		int_num >>= 1

	return int(("-" + bin_str) if is_negative else bin_str      )


if __name__ == "__main__":
					import doctest

					doctest.testmod()


from typing import Callable, Dict, Optional, Tuple

import torch
from torch import nn
from torch.distributions import (
    AffineTransform,
    Distribution,
    Independent,
    NegativeBinomial,
    Normal,
    StudentT,
    TransformedDistribution,
)

class __UpperCamelCase     (				_a		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__				,      lowerCamelCase__=None				,      lowerCamelCase__=None				,      lowerCamelCase__=0						):
						UpperCAmelCase__:	Any									= 1.0 if scale is None else scale
						UpperCAmelCase__:	int									= 0.0 if loc is None else loc

						super().__init__(lowerCamelCase__				,      [AffineTransform(loc=self.loc				,      scale=self.scale				,      event_dim=lowerCamelCase__						)]						)





					@property
					def    _UpperCAmelCase    (				self						):
						return self.base_dist.mean * self.scale + self.loc





					@property
					def    _UpperCAmelCase    (				self						):
						return self.base_dist.variance * self.scale**2





					@property
					def    _UpperCAmelCase    (				self						):
						return self.variance.sqrt()

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__				,      **lowerCamelCase__						):
						super().__init__(**lowerCamelCase__						)
						UpperCAmelCase__:	Any									= args_dim
						UpperCAmelCase__:	List[str]									= nn.ModuleList([nn.Linear(lowerCamelCase__				,      lowerCamelCase__						) for dim in args_dim.values()]						)
						UpperCAmelCase__:	Any									= domain_map





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						UpperCAmelCase__:	str									= [proj(lowerCamelCase__						) for proj in self.proj]

						return self.domain_map(*lowerCamelCase__						)

class __UpperCamelCase     (				nn.Module		):






					'''simple docstring'''



					def __init__(				self				,      lowerCamelCase__						):
						super().__init__()
						UpperCAmelCase__:	str									= function





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      *lowerCamelCase__						):
						return self.function(lowerCamelCase__				,      *lowerCamelCase__						)

class __UpperCamelCase     :






					'''simple docstring'''



					__magic_name__        =   42
					__magic_name__        =   42
					__magic_name__        =   42





					def __init__(				self				,      lowerCamelCase__ = 1						):
						UpperCAmelCase__:	str									= dim
						UpperCAmelCase__:	Any									= {k: dim * self.args_dim[k] for k in self.args_dim}





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						if self.dim == 1:
							return self.distribution_class(*lowerCamelCase__						)
						else:
							return Independent(self.distribution_class(*lowerCamelCase__						)				,      1						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None				,      ):
						UpperCAmelCase__:	Optional[Any]									= self._base_distribution(lowerCamelCase__						)
						if loc is None and scale is None:
							return distr
						else:
							return AffineTransformed(lowerCamelCase__				,      loc=lowerCamelCase__				,      scale=lowerCamelCase__				,      event_dim=self.event_dim						)





					@property
					def    _UpperCAmelCase    (				self						):
						return () if self.dim == 1 else (self.dim,)





					@property
					def    _UpperCAmelCase    (				self						):
						return len(self.event_shape						)





					@property
					def    _UpperCAmelCase    (				self						):
						return 0.0





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						return ParameterProjection(
						    in_features=lowerCamelCase__				,      args_dim=self.args_dim				,      domain_map=LambdaLayer(self.domain_map						)				,      )





					def    _UpperCAmelCase    (				self				,      *lowerCamelCase__						):
						raise NotImplementedError()





					@staticmethod
					def    _UpperCAmelCase    (				lowerCamelCase__						):
						return (x + torch.sqrt(torch.square(lowerCamelCase__						) + 4.0						)) / 2.0

class __UpperCamelCase     (				_a		):






					'''simple docstring'''



					__magic_name__        =   {"df": 1, "loc": 1, "scale": 1}
					__magic_name__        =   StudentT





					@classmethod
					def    _UpperCAmelCase    (				cls				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
						UpperCAmelCase__:	Dict									= cls.squareplus(lowerCamelCase__						).clamp_min(torch.finfo(scale.dtype						).eps						)
						UpperCAmelCase__:	List[Any]									= 2.0 + cls.squareplus(lowerCamelCase__						)
						return df.squeeze(-1						), loc.squeeze(-1						), scale.squeeze(-1						)

class __UpperCamelCase     (				_a		):






					'''simple docstring'''



					__magic_name__        =   {"loc": 1, "scale": 1}
					__magic_name__        =   Normal





					@classmethod
					def    _UpperCAmelCase    (				cls				,      lowerCamelCase__				,      lowerCamelCase__						):
						UpperCAmelCase__:	str									= cls.squareplus(lowerCamelCase__						).clamp_min(torch.finfo(scale.dtype						).eps						)
						return loc.squeeze(-1						), scale.squeeze(-1						)

class __UpperCamelCase     (				_a		):






					'''simple docstring'''



					__magic_name__        =   {"total_count": 1, "logits": 1}
					__magic_name__        =   NegativeBinomial





					@classmethod
					def    _UpperCAmelCase    (				cls				,      lowerCamelCase__				,      lowerCamelCase__						):
						UpperCAmelCase__:	Dict									= cls.squareplus(lowerCamelCase__						)
						return total_count.squeeze(-1						), logits.squeeze(-1						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						UpperCAmelCase__							,						UpperCAmelCase__:	str									= distr_args
						if self.dim == 1:
							return self.distribution_class(total_count=lowerCamelCase__				,      logits=lowerCamelCase__						)
						else:
							return Independent(self.distribution_class(total_count=lowerCamelCase__				,      logits=lowerCamelCase__						)				,      1						)





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__ = None				,      lowerCamelCase__ = None						):
						UpperCAmelCase__							,						UpperCAmelCase__:	List[str]									= distr_args

						if scale is not None:
							# See scaling property of Gamma.
							logits += scale.log()

						return self._base_distribution((total_count, logits)						)