

import numpy as np
import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel

from ...utils import logging


_lowerCamelCase							=logging.get_logger(__name__)







def      snake_case__							(  lowerCAmelCase_,       lowerCAmelCase_     ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE 		=nn.functional.normalize(lowerCAmelCase_     )
     SCREAMING_SNAKE_CASE 		=nn.functional.normalize(lowerCAmelCase_     )
     return torch.mm(lowerCAmelCase_,       normalized_text_embeds.t()     )



class 						a_			(				lowerCamelCase_	):



      """simple docstring"""







      __UpperCAmelCase     						= CLIPConfig

      __UpperCAmelCase     						= ['CLIPEncoderLayer']
      def __init__( self	:				str     ,snake_case	:				CLIPConfig							):
           super().__init__(snake_case							)

           SCREAMING_SNAKE_CASE 		=CLIPVisionModel(config.vision_config							)
           SCREAMING_SNAKE_CASE 		=nn.Linear(config.vision_config.hidden_size     ,config.projection_dim     ,bias=snake_case							)

           SCREAMING_SNAKE_CASE 		=nn.Parameter(torch.ones(17     ,config.projection_dim							)     ,requires_grad=snake_case							)
           SCREAMING_SNAKE_CASE 		=nn.Parameter(torch.ones(3     ,config.projection_dim							)     ,requires_grad=snake_case							)

           SCREAMING_SNAKE_CASE 		=nn.Parameter(torch.ones(17							)     ,requires_grad=snake_case							)
           SCREAMING_SNAKE_CASE 		=nn.Parameter(torch.ones(3							)     ,requires_grad=snake_case							)
      @torch.no_grad()
      def 			_lowerCAmelCase	( self	:				Optional[Any]     ,snake_case	:				List[str]     ,snake_case	:				Dict							):
           SCREAMING_SNAKE_CASE 		=self.vision_model(snake_case							)[1]  # pooled_output
           SCREAMING_SNAKE_CASE 		=self.visual_projection(snake_case							)

           # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
           SCREAMING_SNAKE_CASE 		=cosine_distance(snake_case     ,self.special_care_embeds							).cpu().float().numpy()
           SCREAMING_SNAKE_CASE 		=cosine_distance(snake_case     ,self.concept_embeds							).cpu().float().numpy()

           SCREAMING_SNAKE_CASE 		=[]
           SCREAMING_SNAKE_CASE 		=image_embeds.shape[0]
           for i in range(snake_case							):
                SCREAMING_SNAKE_CASE 		={'special_scores': {}, 'special_care': [], 'concept_scores': {}, 'bad_concepts': []}

                # increase this value to create a stronger `nfsw` filter
                # at the cost of increasing the possibility of filtering benign images
                SCREAMING_SNAKE_CASE 		=0.0

                for concept_idx in range(len(special_cos_dist[0]							)							):
                     SCREAMING_SNAKE_CASE 		=special_cos_dist[i][concept_idx]
                     SCREAMING_SNAKE_CASE 		=self.special_care_embeds_weights[concept_idx].item()
                     SCREAMING_SNAKE_CASE 		=round(concept_cos - concept_threshold + adjustment     ,3							)
                     if result_img["special_scores"][concept_idx] > 0:
                          result_img["special_care"].append({concept_idx, result_img['special_scores'][concept_idx]}							)
                          SCREAMING_SNAKE_CASE 		=0.01

                for concept_idx in range(len(cos_dist[0]							)							):
                     SCREAMING_SNAKE_CASE 		=cos_dist[i][concept_idx]
                     SCREAMING_SNAKE_CASE 		=self.concept_embeds_weights[concept_idx].item()
                     SCREAMING_SNAKE_CASE 		=round(concept_cos - concept_threshold + adjustment     ,3							)
                     if result_img["concept_scores"][concept_idx] > 0:
                          result_img["bad_concepts"].append(snake_case							)

                result.append(snake_case							)

           SCREAMING_SNAKE_CASE 		=[len(res['bad_concepts']							) > 0 for res in result]

           for idx, has_nsfw_concept in enumerate(snake_case							):
                if has_nsfw_concept:
                     if torch.is_tensor(snake_case							) or torch.is_tensor(images[0]							):
                          SCREAMING_SNAKE_CASE 		=torch.zeros_like(images[idx]							)  # black image
                     else:
                          SCREAMING_SNAKE_CASE 		=np.zeros(images[idx].shape							)  # black image

           if any(snake_case							):
                logger.warning(
                    'Potential NSFW content was detected in one or more images. A black image will be returned instead.'
                    ' Try again with a different prompt and/or seed.'							)

           return images, has_nsfw_concepts


      @torch.no_grad()
      def 			_lowerCAmelCase	( self	:				str     ,snake_case	:				torch.FloatTensor     ,snake_case	:				torch.FloatTensor							):
           SCREAMING_SNAKE_CASE 		=self.vision_model(snake_case							)[1]  # pooled_output
           SCREAMING_SNAKE_CASE 		=self.visual_projection(snake_case							)

           SCREAMING_SNAKE_CASE 		=cosine_distance(snake_case     ,self.special_care_embeds							)
           SCREAMING_SNAKE_CASE 		=cosine_distance(snake_case     ,self.concept_embeds							)

           # increase this value to create a stronger `nsfw` filter
           # at the cost of increasing the possibility of filtering benign images
           SCREAMING_SNAKE_CASE 		=0.0

           SCREAMING_SNAKE_CASE 		=special_cos_dist - self.special_care_embeds_weights + adjustment
           # special_scores = special_scores.round(decimals=3)
           SCREAMING_SNAKE_CASE 		=torch.any(special_scores > 0     ,dim=1							)
           SCREAMING_SNAKE_CASE 		=special_care * 0.01
           SCREAMING_SNAKE_CASE 		=special_adjustment.unsqueeze(1							).expand(-1     ,cos_dist.shape[1]							)

           SCREAMING_SNAKE_CASE 		=(cos_dist - self.concept_embeds_weights) + special_adjustment
           # concept_scores = concept_scores.round(decimals=3)
           SCREAMING_SNAKE_CASE 		=torch.any(concept_scores > 0     ,dim=1							)

           SCREAMING_SNAKE_CASE 		=0.0  # black image

           return images, has_nsfw_concepts




def      snake_case__							(  lowerCAmelCase_ = 100     ):





     """simple docstring"""







     SCREAMING_SNAKE_CASE 		=[[0 for _ in range(lowerCAmelCase_     )] for _ in range(m + 1     )]
     for i in range(m + 1     ):
          SCREAMING_SNAKE_CASE 		=1

     for n in range(m + 1     ):
          for k in range(1,       lowerCAmelCase_     ):
               memo[n][k] += memo[n][k - 1]
               if n > k:
                    memo[n][k] += memo[n - k - 1][k]

     return memo[m][m - 1] - 1


if __name__ == "__main__":
 print(solution(int(input("Enter a number: ").strip())))

