code: 
  
  
  
  from __future__ import annotations
  
  from queue import Queue
  def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					int			)			->  tuple[int, int]:
     a ^= b
     b ^= a
     a ^= b
     return a, b
  def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					list[list[int]]			)			->  list[list[int]]:
     UpperCamelCase					:						Optional[int]					=			1
     while (1 << j) < max_node:
        for i in range(1 ,  max_node + 1			):
           UpperCamelCase					:						Any					=			parent[j - 1][parent[j - 1][i]]
        j += 1
     return parent
  def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					int ,  snake_case__ :					list[int] ,  snake_case__ :					list[list[int]]			)			->  int:
     # u must be deeper in the tree than v
     if level[u] < level[v]:
        UpperCamelCase			,  UpperCamelCase					:						Dict					=			swap(snake_case__ ,  snake_case__			)
     # making depth of u same as depth of v
     for i in range(18 ,  -1 ,  -1			):
        if level[u] - (1 << i) >= level[v]:
           UpperCamelCase					:						Dict					=			parent[i][u]
      # at the same depth if u==v that mean lca is found
     if u == v:
        return u
     # moving both nodes upwards till lca in found
     for i in range(18 ,  -1 ,  -1			):
        if parent[i][u] not in [0, parent[i][v]]:
           UpperCamelCase			,  UpperCamelCase					:						Dict					=			parent[i][u], parent[i][v]
      # returning longest common ancestor of u,v
     return parent[0][u]
  def 	UpperCamelCase			(     snake_case__ :					list[int] ,  snake_case__ :					list[list[int]] ,  snake_case__ :					int ,  snake_case__ :					dict[int, list[int]] ,  snake_case__ :					int = 1 ,  )			->  tuple[list[int], list[list[int]]]:
     UpperCamelCase					:						List[Any]					=			0
     UpperCamelCase					:						Queue[int]					=			Queue(maxsize=snake_case__			)
     q.put(snake_case__			)
     while q.qsize() != 0:
        UpperCamelCase					:						int					=			q.get()
        for v in graph[u]:
           if level[v] == -1:
              UpperCamelCase					:						Union[str, Any]					=			level[u] + 1
              q.put(snake_case__			)
              UpperCamelCase					:						Any					=			u
     return level, parent
  def 	UpperCamelCase			(     )			->  None:
     UpperCamelCase					:						Tuple					=			13
     # initializing with 0
     UpperCamelCase					:						Any					=			[[0 for _ in range(max_node + 10			)] for _ in range(20			)]
     # initializing with -1 which means every node is unvisited
     UpperCamelCase					:						List[str]					=			[-1 for _ in range(max_node + 10			)]
     UpperCamelCase					:						dict[int, list[int]]					=			{
         1: [2, 3, 4],
         2: [5],
         3: [6, 7],
         4: [8],
         5: [9, 10],
         6: [11],
         7: [],
         8: [12, 13],
         9: [],
         10: [],
         11: [],
         12: [],
         13: [],
     }
     UpperCamelCase			,  UpperCamelCase					:						List[str]					=			breadth_first_search(snake_case__ ,  snake_case__ ,  snake_case__ ,  snake_case__ ,  1			)
     UpperCamelCase					:						Tuple					=			create_sparse(snake_case__ ,  snake_case__			)
     print('LCA of node 1 and 3 is: ' ,  lowest_common_ancestor(1 ,  3 ,  snake_case__ ,  snake_case__			)			)
     print('LCA of node 5 and 6 is: ' ,  lowest_common_ancestor(5 ,  6 ,  snake_case__ ,  snake_case__			)			)
     print('LCA of node 7 and 11 is: ' ,  lowest_common_ancestor(7 ,  11 ,  snake_case__ ,  snake_case__			)			)
     print('LCA of node 6 and 7 is: ' ,  lowest_common_ancestor(6 ,  7 ,  snake_case__ ,  snake_case__			)			)
     print('LCA of node 4 and 12 is: ' ,  lowest_common_ancestor(4 ,  12 ,  snake_case__ ,  snake_case__			)			)
     print('LCA of node 8 and 8 is: ' ,  lowest_common_ancestor(8 ,  8 ,  snake_case__ ,  snake_case__			)			)
  
  
  if __name__ == "__main__":
      main()
  
  
  
  
style_context: 
  
  
  
  import numpy as np
  import torch
  import torch.nn as nn
  from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel
  
  from ...utils import logging
  
  
  __UpperCAmelCase      = logging.get_logger(__name__)
  def 	UpperCamelCase			(     snake_case__ :					List[str] ,  snake_case__ :					str			)			->  Dict:
     UpperCamelCase					:						int					=			nn.functional.normalize(snake_case__			)
     UpperCamelCase					:						Union[str, Any]					=			nn.functional.normalize(snake_case__			)
     return torch.mm(snake_case__ ,  normalized_text_embeds.t()			)
  
  
  
  class        lowerCAmelCase_	(						a__							):
         UpperCAmelCase__       :      int       =						CLIPConfig
  
         UpperCAmelCase__       :      Union[str, Any]       =						["CLIPEncoderLayer"]
         def __init__(    self,    SCREAMING_SNAKE_CASE_ )  ->	List[str]:
            super().__init__(SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						int					=			CLIPVisionModel(config.vision_config )
            UpperCamelCase					:						int					=			nn.Linear(config.vision_config.hidden_size,    config.projection_dim,    bias=SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						List[Any]					=			nn.Parameter(torch.ones(17,    config.projection_dim ),    requires_grad=SCREAMING_SNAKE_CASE_ )
            UpperCamelCase					:						str					=			nn.Parameter(torch.ones(3,    config.projection_dim ),    requires_grad=SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						Dict					=			nn.Parameter(torch.ones(17 ),    requires_grad=SCREAMING_SNAKE_CASE_ )
            UpperCamelCase					:						Optional[Any]					=			nn.Parameter(torch.ones(3 ),    requires_grad=SCREAMING_SNAKE_CASE_ )
         @torch.no_grad()
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Union[str, Any]:
            UpperCamelCase					:						Optional[int]					=			self.vision_model(SCREAMING_SNAKE_CASE_ )[1]  # pooled_output
            UpperCamelCase					:						int					=			self.visual_projection(SCREAMING_SNAKE_CASE_ )
  
            # we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
            UpperCamelCase					:						Optional[Any]					=			cosine_distance(SCREAMING_SNAKE_CASE_,    self.special_care_embeds ).cpu().float().numpy()
            UpperCamelCase					:						Any					=			cosine_distance(SCREAMING_SNAKE_CASE_,    self.concept_embeds ).cpu().float().numpy()
  
            UpperCamelCase					:						str					=			[]
            UpperCamelCase					:						int					=			image_embeds.shape[0]
            for i in range(SCREAMING_SNAKE_CASE_ ):
               UpperCamelCase					:						Optional[int]					=			{'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
               UpperCamelCase					:						Optional[Any]					=			0.0
  
               for concept_idx in range(len(special_cos_dist[0] ) ):
                  UpperCamelCase					:						Union[str, Any]					=			special_cos_dist[i][concept_idx]
                  UpperCamelCase					:						Optional[Any]					=			self.special_care_embeds_weights[concept_idx].item()
                  UpperCamelCase					:						str					=			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]} )
                     UpperCamelCase					:						Dict					=			0.01
  
               for concept_idx in range(len(cos_dist[0] ) ):
                  UpperCamelCase					:						List[Any]					=			cos_dist[i][concept_idx]
                  UpperCamelCase					:						Optional[int]					=			self.concept_embeds_weights[concept_idx].item()
                  UpperCamelCase					:						Union[str, Any]					=			round(concept_cos - concept_threshold + adjustment,    3 )
                  if result_img["concept_scores"][concept_idx] > 0:
                     result_img["bad_concepts"].append(SCREAMING_SNAKE_CASE_ )
  
               result.append(SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						int					=			[len(res['bad_concepts'] ) > 0 for res in result]
  
            for idx, has_nsfw_concept in enumerate(SCREAMING_SNAKE_CASE_ ):
               if has_nsfw_concept:
                  if torch.is_tensor(SCREAMING_SNAKE_CASE_ ) or torch.is_tensor(images[0] ):
                     UpperCamelCase					:						List[str]					=			torch.zeros_like(images[idx] )  # black image
                  else:
                     UpperCamelCase					:						int					=			np.zeros(images[idx].shape )  # black image
  
            if any(SCREAMING_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       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	Optional[int]:
            UpperCamelCase					:						Union[str, Any]					=			self.vision_model(SCREAMING_SNAKE_CASE_ )[1]  # pooled_output
            UpperCamelCase					:						str					=			self.visual_projection(SCREAMING_SNAKE_CASE_ )
  
            UpperCamelCase					:						str					=			cosine_distance(SCREAMING_SNAKE_CASE_,    self.special_care_embeds )
            UpperCamelCase					:						Any					=			cosine_distance(SCREAMING_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
            UpperCamelCase					:						Dict					=			0.0
  
            UpperCamelCase					:						str					=			special_cos_dist - self.special_care_embeds_weights + adjustment
            # special_scores = special_scores.round(decimals=3)
            UpperCamelCase					:						List[str]					=			torch.any(special_scores > 0,    dim=1 )
            UpperCamelCase					:						List[Any]					=			special_care * 0.01
            UpperCamelCase					:						List[Any]					=			special_adjustment.unsqueeze(1 ).expand(-1,    cos_dist.shape[1] )
  
            UpperCamelCase					:						List[str]					=			(cos_dist - self.concept_embeds_weights) + special_adjustment
            # concept_scores = concept_scores.round(decimals=3)
            UpperCamelCase					:						Tuple					=			torch.any(concept_scores > 0,    dim=1 )
  
            UpperCamelCase					:						Any					=			0.0  # black image
  
            return images, has_nsfw_concepts
  
  
  
  