



import math
from typing import Optional

import numpy as np
import torch
from torch import nn

from .activations import get_activation






def 			__lowercase     (				a__							,     a__							,     a__ = False							,     a__ = 1							,     a__ = 1							,     a__ = 1_00_00							,     )       ->				Optional[int]:
							assert len(timesteps.shape     ) == 1, "Timesteps should be a 1d-array"

							__SCREAMING_SNAKE_CASE								=      embedding_dim // 2
							__SCREAMING_SNAKE_CASE								=      -math.log(a__     ) * torch.arange(
							    start=0							,     end=a__							,     dtype=torch.floataa							,     device=timesteps.device     )
							__SCREAMING_SNAKE_CASE								=      exponent / (half_dim - downscale_freq_shift)

							__SCREAMING_SNAKE_CASE								=      torch.exp(a__     )
							__SCREAMING_SNAKE_CASE								=      timesteps[:, None].float() * emb[None, :]

							# scale embeddings
							__SCREAMING_SNAKE_CASE								=      scale * emb

							# concat sine and cosine embeddings
							__SCREAMING_SNAKE_CASE								=      torch.cat([torch.sin(a__     ), torch.cos(a__     )]							,     dim=-1     )

							# flip sine and cosine embeddings
							if flip_sin_to_cos:
														__SCREAMING_SNAKE_CASE								=      torch.cat([emb[:, half_dim:], emb[:, :half_dim]]							,     dim=-1     )

							# zero pad
							if embedding_dim % 2 == 1:
														__SCREAMING_SNAKE_CASE								=      torch.nn.functional.pad(a__							,     (0, 1, 0, 0)     )
							return emb






def 			__lowercase     (				a__							,     a__							,     a__=False							,     a__=0     )       ->				int:
							__SCREAMING_SNAKE_CASE								=      np.arange(a__							,     dtype=np.floataa     )
							__SCREAMING_SNAKE_CASE								=      np.arange(a__							,     dtype=np.floataa     )
							__SCREAMING_SNAKE_CASE								=      np.meshgrid(a__							,     a__     )  # here w goes first
							__SCREAMING_SNAKE_CASE								=      np.stack(a__							,     axis=0     )

							__SCREAMING_SNAKE_CASE								=      grid.reshape([2, 1, grid_size, grid_size]     )
							__SCREAMING_SNAKE_CASE								=      get_ad_sincos_pos_embed_from_grid(a__							,     a__     )
							if cls_token and extra_tokens > 0:
														__SCREAMING_SNAKE_CASE								=      np.concatenate([np.zeros([extra_tokens, embed_dim]     ), pos_embed]							,     axis=0     )
							return pos_embed






def 			__lowercase     (				a__							,     a__     )       ->				List[Any]:
							if embed_dim % 2 != 0:
														raise ValueError('embed_dim must be divisible by 2'     )

							# use half of dimensions to encode grid_h
							__SCREAMING_SNAKE_CASE								=      get_ad_sincos_pos_embed_from_grid(embed_dim // 2							,     grid[0]     )  # (H*W, D/2)
							__SCREAMING_SNAKE_CASE								=      get_ad_sincos_pos_embed_from_grid(embed_dim // 2							,     grid[1]     )  # (H*W, D/2)

							__SCREAMING_SNAKE_CASE								=      np.concatenate([emb_h, emb_w]							,     axis=1     )  # (H*W, D)
							return emb






def 			__lowercase     (				a__							,     a__     )       ->				Optional[Any]:
							if embed_dim % 2 != 0:
														raise ValueError('embed_dim must be divisible by 2'     )

							__SCREAMING_SNAKE_CASE								=      np.arange(embed_dim // 2							,     dtype=np.floataa     )
							omega /= embed_dim / 2.0
							__SCREAMING_SNAKE_CASE								=      1.0 / 1_00_00**omega  # (D/2,)

							__SCREAMING_SNAKE_CASE								=      pos.reshape(-1     )  # (M,)
							__SCREAMING_SNAKE_CASE								=      np.einsum('m,d->md'							,     a__							,     a__     )  # (M, D/2), outer product

							__SCREAMING_SNAKE_CASE								=      np.sin(a__     )  # (M, D/2)
							__SCREAMING_SNAKE_CASE								=      np.cos(a__     )  # (M, D/2)

							__SCREAMING_SNAKE_CASE								=      np.concatenate([emb_sin, emb_cos]							,     axis=1     )  # (M, D)
							return emb

class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A=224   ,							_A=224   ,							_A=16   ,							_A=3   ,							_A=768   ,							_A=False   ,							_A=True   ,							_A=True   ,							):







													'''simple docstring'''

													super().__init__()

													__SCREAMING_SNAKE_CASE								=      (height // patch_size) * (width // patch_size)
													__SCREAMING_SNAKE_CASE								=      flatten
													__SCREAMING_SNAKE_CASE								=      layer_norm

													__SCREAMING_SNAKE_CASE								=      nn.Convad(
													    _A   ,							_A   ,							kernel_size=(patch_size, patch_size)   ,							stride=_A   ,							bias=_A	)
													if layer_norm:
																				__SCREAMING_SNAKE_CASE								=      nn.LayerNorm(_A   ,							elementwise_affine=_A   ,							eps=1e-6	)
													else:
																				__SCREAMING_SNAKE_CASE								=      None

													__SCREAMING_SNAKE_CASE								=      get_ad_sincos_pos_embed(_A   ,							int(num_patches**0.5	)	)
													self.register_buffer('pos_embed'   ,							torch.from_numpy(_A	).float().unsqueeze(0	)   ,							persistent=_A	)






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.proj(_A	)
													if self.flatten:
																				__SCREAMING_SNAKE_CASE								=      latent.flatten(2	).transpose(1   ,							2	)  # BCHW -> BNC
													if self.layer_norm:
																				__SCREAMING_SNAKE_CASE								=      self.norm(_A	)
													return latent + self.pos_embed







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A   ,							_A = "silu"   ,							_A = None   ,							_A = None   ,							_A=None   ,							):







													'''simple docstring'''

													super().__init__()

													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)

													if cond_proj_dim is not None:
																				__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A   ,							bias=_A	)
													else:
																				__SCREAMING_SNAKE_CASE								=      None

													__SCREAMING_SNAKE_CASE								=      get_activation(_A	)

													if out_dim is not None:
																				__SCREAMING_SNAKE_CASE								=      out_dim
													else:
																				__SCREAMING_SNAKE_CASE								=      time_embed_dim
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)

													if post_act_fn is None:
																				__SCREAMING_SNAKE_CASE								=      None
													else:
																				__SCREAMING_SNAKE_CASE								=      get_activation(_A	)






						def  _A			(					self   ,							_A   ,							_A=None	):







													'''simple docstring'''

													if condition is not None:
																				__SCREAMING_SNAKE_CASE								=      sample + self.cond_proj(_A	)
													__SCREAMING_SNAKE_CASE								=      self.linear_a(_A	)

													if self.act is not None:
																				__SCREAMING_SNAKE_CASE								=      self.act(_A	)

													__SCREAMING_SNAKE_CASE								=      self.linear_a(_A	)

													if self.post_act is not None:
																				__SCREAMING_SNAKE_CASE								=      self.post_act(_A	)
													return sample







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      num_channels
													__SCREAMING_SNAKE_CASE								=      flip_sin_to_cos
													__SCREAMING_SNAKE_CASE								=      downscale_freq_shift






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      get_timestep_embedding(
													    _A   ,							self.num_channels   ,							flip_sin_to_cos=self.flip_sin_to_cos   ,							downscale_freq_shift=self.downscale_freq_shift   ,							)
													return t_emb







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A = 256   ,							_A = 1.0   ,							_A=True   ,							_A=True   ,							_A=False	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      nn.Parameter(torch.randn(_A	) * scale   ,							requires_grad=_A	)
													__SCREAMING_SNAKE_CASE								=      log
													__SCREAMING_SNAKE_CASE								=      flip_sin_to_cos

													if set_W_to_weight:
																				# to delete later
																				__SCREAMING_SNAKE_CASE								=      nn.Parameter(torch.randn(_A	) * scale   ,							requires_grad=_A	)

																				__SCREAMING_SNAKE_CASE								=      self.W






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													if self.log:
																				__SCREAMING_SNAKE_CASE								=      torch.log(_A	)

													__SCREAMING_SNAKE_CASE								=      x[:, None] * self.weight[None, :] * 2 * np.pi

													if self.flip_sin_to_cos:
																				__SCREAMING_SNAKE_CASE								=      torch.cat([torch.cos(_A	), torch.sin(_A	)]   ,							dim=-1	)
													else:
																				__SCREAMING_SNAKE_CASE								=      torch.cat([torch.sin(_A	), torch.cos(_A	)]   ,							dim=-1	)
													return out







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A   ,							_A   ,							_A   ,							):







													'''simple docstring'''

													super().__init__()

													__SCREAMING_SNAKE_CASE								=      height
													__SCREAMING_SNAKE_CASE								=      width
													__SCREAMING_SNAKE_CASE								=      num_embed
													__SCREAMING_SNAKE_CASE								=      embed_dim

													__SCREAMING_SNAKE_CASE								=      nn.Embedding(self.num_embed   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      nn.Embedding(self.height   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      nn.Embedding(self.width   ,							_A	)






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.emb(_A	)

													__SCREAMING_SNAKE_CASE								=      self.height_emb(torch.arange(self.height   ,							device=index.device	).view(1   ,							self.height	)	)

													# 1 x H x D -> 1 x H x 1 x D
													__SCREAMING_SNAKE_CASE								=      height_emb.unsqueeze(2	)

													__SCREAMING_SNAKE_CASE								=      self.width_emb(torch.arange(self.width   ,							device=index.device	).view(1   ,							self.width	)	)

													# 1 x W x D -> 1 x 1 x W x D
													__SCREAMING_SNAKE_CASE								=      width_emb.unsqueeze(1	)

													__SCREAMING_SNAKE_CASE								=      height_emb + width_emb

													# 1 x H x W x D -> 1 x L xD
													__SCREAMING_SNAKE_CASE								=      pos_emb.view(1   ,							self.height * self.width   ,							-1	)

													__SCREAMING_SNAKE_CASE								=      emb + pos_emb[:, : emb.shape[1], :]

													return emb







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A   ,							_A	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      dropout_prob > 0
													__SCREAMING_SNAKE_CASE								=      nn.Embedding(num_classes + use_cfg_embedding   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      num_classes
													__SCREAMING_SNAKE_CASE								=      dropout_prob






						def  _A			(					self   ,							_A   ,							_A=None	):







													'''simple docstring'''

													if force_drop_ids is None:
																				__SCREAMING_SNAKE_CASE								=      torch.rand(labels.shape[0]   ,							device=labels.device	) < self.dropout_prob
													else:
																				__SCREAMING_SNAKE_CASE								=      torch.tensor(force_drop_ids == 1	)
													__SCREAMING_SNAKE_CASE								=      torch.where(_A   ,							self.num_classes   ,							_A	)
													return labels






						def  _A			(					self   ,							_A   ,							_A=None	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.dropout_prob > 0
													if (self.training and use_dropout) or (force_drop_ids is not None):
																				__SCREAMING_SNAKE_CASE								=      self.token_drop(_A   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      self.embedding_table(_A	)
													return embeddings







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A = 1_024   ,							_A = 768   ,							_A = 768   ,							_A = 10   ,							):







													'''simple docstring'''

													super().__init__()

													__SCREAMING_SNAKE_CASE								=      num_image_text_embeds
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							self.num_image_text_embeds * cross_attention_dim	)
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)






						def  _A			(					self   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      text_embeds.shape[0]

													# image
													__SCREAMING_SNAKE_CASE								=      self.image_embeds(_A	)
													__SCREAMING_SNAKE_CASE								=      image_text_embeds.reshape(_A   ,							self.num_image_text_embeds   ,							-1	)

													# text
													__SCREAMING_SNAKE_CASE								=      self.text_proj(_A	)

													return torch.cat([image_text_embeds, text_embeds]   ,							dim=1	)







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A = 768   ,							_A = 768   ,							_A = 32   ,							):







													'''simple docstring'''

													super().__init__()

													__SCREAMING_SNAKE_CASE								=      num_image_text_embeds
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							self.num_image_text_embeds * cross_attention_dim	)
													__SCREAMING_SNAKE_CASE								=      nn.LayerNorm(_A	)






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      image_embeds.shape[0]

													# image
													__SCREAMING_SNAKE_CASE								=      self.image_embeds(_A	)
													__SCREAMING_SNAKE_CASE								=      image_embeds.reshape(_A   ,							self.num_image_text_embeds   ,							-1	)
													__SCREAMING_SNAKE_CASE								=      self.norm(_A	)
													return image_embeds







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A   ,							_A=0.1	):







													'''simple docstring'''

													super().__init__()

													__SCREAMING_SNAKE_CASE								=      Timesteps(num_channels=256   ,							flip_sin_to_cos=_A   ,							downscale_freq_shift=1	)
													__SCREAMING_SNAKE_CASE								=      TimestepEmbedding(in_channels=256   ,							time_embed_dim=_A	)
													__SCREAMING_SNAKE_CASE								=      LabelEmbedding(_A   ,							_A   ,							_A	)






						def  _A			(					self   ,							_A   ,							_A   ,							_A=None	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.time_proj(_A	)
													__SCREAMING_SNAKE_CASE								=      self.timestep_embedder(timesteps_proj.to(dtype=_A	)	)  # (N, D)

													__SCREAMING_SNAKE_CASE								=      self.class_embedder(_A	)  # (N, D)

													__SCREAMING_SNAKE_CASE								=      timesteps_emb + class_labels  # (N, D)

													return conditioning







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A   ,							_A = 64	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      nn.LayerNorm(_A	)
													__SCREAMING_SNAKE_CASE								=      AttentionPooling(_A   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      nn.LayerNorm(_A	)






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.norma(_A	)
													__SCREAMING_SNAKE_CASE								=      self.pool(_A	)
													__SCREAMING_SNAKE_CASE								=      self.proj(_A	)
													__SCREAMING_SNAKE_CASE								=      self.norma(_A	)
													return hidden_states







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A = 768   ,							_A = 768   ,							_A = 1_536	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      nn.LayerNorm(_A	)
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)






						def  _A			(					self   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.text_proj(_A	)
													__SCREAMING_SNAKE_CASE								=      self.text_norm(_A	)

													# image
													__SCREAMING_SNAKE_CASE								=      self.image_proj(_A	)

													return time_image_embeds + time_text_embeds







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A = 768   ,							_A = 1_536	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      nn.LayerNorm(_A	)






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.image_proj(_A	)
													__SCREAMING_SNAKE_CASE								=      self.image_norm(_A	)
													return time_image_embeds







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A = 768   ,							_A = 1_536	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A	)
													__SCREAMING_SNAKE_CASE								=      nn.LayerNorm(_A	)
													__SCREAMING_SNAKE_CASE								=      nn.Sequential(
													    nn.Convad(3   ,							16   ,							3   ,							padding=1	)   ,							nn.SiLU()   ,							nn.Convad(16   ,							16   ,							3   ,							padding=1	)   ,							nn.SiLU()   ,							nn.Convad(16   ,							32   ,							3   ,							padding=1   ,							stride=2	)   ,							nn.SiLU()   ,							nn.Convad(32   ,							32   ,							3   ,							padding=1	)   ,							nn.SiLU()   ,							nn.Convad(32   ,							96   ,							3   ,							padding=1   ,							stride=2	)   ,							nn.SiLU()   ,							nn.Convad(96   ,							96   ,							3   ,							padding=1	)   ,							nn.SiLU()   ,							nn.Convad(96   ,							256   ,							3   ,							padding=1   ,							stride=2	)   ,							nn.SiLU()   ,							nn.Convad(256   ,							4   ,							3   ,							padding=1	)   ,							)






						def  _A			(					self   ,							_A   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE								=      self.image_proj(_A	)
													__SCREAMING_SNAKE_CASE								=      self.image_norm(_A	)
													__SCREAMING_SNAKE_CASE								=      self.input_hint_block(_A	)
													return time_image_embeds, hint







class      UpperCAmelCase_						(     nn.Module ):

						'''simple docstring'''




						def __init__(					self   ,							_A   ,							_A   ,							_A=None	):







													'''simple docstring'''

													super().__init__()
													__SCREAMING_SNAKE_CASE								=      dtype
													__SCREAMING_SNAKE_CASE								=      nn.Parameter(torch.randn(1   ,							_A	) / embed_dim**0.5	)
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A   ,							dtype=self.dtype	)
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A   ,							dtype=self.dtype	)
													__SCREAMING_SNAKE_CASE								=      nn.Linear(_A   ,							_A   ,							dtype=self.dtype	)
													__SCREAMING_SNAKE_CASE								=      num_heads
													__SCREAMING_SNAKE_CASE								=      embed_dim // self.num_heads






						def  _A			(					self   ,							_A	):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE							, __SCREAMING_SNAKE_CASE								=      x.size()

													def shape(_A	):
																				# (bs, length, width) --> (bs, length, n_heads, dim_per_head)
																				__SCREAMING_SNAKE_CASE								=      x.view(_A   ,							-1   ,							self.num_heads   ,							self.dim_per_head	)
																				# (bs, length, n_heads, dim_per_head) --> (bs, n_heads, length, dim_per_head)
																				__SCREAMING_SNAKE_CASE								=      x.transpose(1   ,							2	)
																				# (bs, n_heads, length, dim_per_head) --> (bs*n_heads, length, dim_per_head)
																				__SCREAMING_SNAKE_CASE								=      x.reshape(bs * self.num_heads   ,							-1   ,							self.dim_per_head	)
																				# (bs*n_heads, length, dim_per_head) --> (bs*n_heads, dim_per_head, length)
																				__SCREAMING_SNAKE_CASE								=      x.transpose(1   ,							2	)
																				return x

													__SCREAMING_SNAKE_CASE								=      x.mean(dim=1   ,							keepdim=_A	) + self.positional_embedding.to(x.dtype	)
													__SCREAMING_SNAKE_CASE								=      torch.cat([class_token, x]   ,							dim=1	)  # (bs, length+1, width)

													# (bs*n_heads, class_token_length, dim_per_head)
													__SCREAMING_SNAKE_CASE								=      shape(self.q_proj(_A	)	)
													# (bs*n_heads, length+class_token_length, dim_per_head)
													__SCREAMING_SNAKE_CASE								=      shape(self.k_proj(_A	)	)
													__SCREAMING_SNAKE_CASE								=      shape(self.v_proj(_A	)	)

													# (bs*n_heads, class_token_length, length+class_token_length):
													__SCREAMING_SNAKE_CASE								=      1 / math.sqrt(math.sqrt(self.dim_per_head	)	)
													__SCREAMING_SNAKE_CASE								=      torch.einsum('bct,bcs->bts'   ,							q * scale   ,							k * scale	)  # More stable with f16 than dividing afterwards
													__SCREAMING_SNAKE_CASE								=      torch.softmax(weight.float()   ,							dim=-1	).type(weight.dtype	)

													# (bs*n_heads, dim_per_head, class_token_length)
													__SCREAMING_SNAKE_CASE								=      torch.einsum('bts,bcs->bct'   ,							_A   ,							_A	)

													# (bs, length+1, width)
													__SCREAMING_SNAKE_CASE								=      a.reshape(_A   ,							-1   ,							1	).transpose(1   ,							2	)

													return a[:, 0, :]  # cls_token











from itertools import combinations, product






def 			__lowercase     (				a__							,     a__							,     a__							,     a__     )       ->				bool:
							if xa == ya == 0 or xa == ya == 0:
														return False
							__SCREAMING_SNAKE_CASE								=      xa * xa + ya * ya
							__SCREAMING_SNAKE_CASE								=      xa * xa + ya * ya
							__SCREAMING_SNAKE_CASE								=      (xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
							return (
							    a_square + b_square == c_square
							    or a_square + c_square == b_square
							    or b_square + c_square == a_square
							)






def 			__lowercase     (				a__ = 50     )       ->				int:
							return sum(
							    1
							    for pta, pta in combinations(product(range(limit + 1     )							,     repeat=2     )							,     2     )
							    if is_right(*a__							,     *a__     )     )


if __name__ == "__main__":
			print(F'''{solution() = }''')






