code: 
  
  
  '''simple docstring'''
  
  
  
  
  
  from __future__ import annotations
  
  from collections import deque
  from enum import Enum
  from math import atana, degrees
  from sys import maxsize
  
  
  class 		_SCREAMING_SNAKE_CASE    (	A__    ):
       __SCREAMING_SNAKE_CASE    				=						1
       __SCREAMING_SNAKE_CASE    				=						2
       __SCREAMING_SNAKE_CASE    				=						3
  
  
       def __repr__(     self						):
         return F'''{self.__class__.__name__}.{self.name}'''
  
  
  
  
  def       a__						(		snake_case__				:       List[str]	,      snake_case__				:       Optional[Any]	,      snake_case__				:       List[str]    ):
    _UpperCAmelCase		:       Any       =    point
    return degrees(atana(y - miny	,      x - minx    )    )
  
  
  
  
  def       a__						(		snake_case__				:       str	,      snake_case__				:       Union[str, Any]	,      snake_case__				:       Tuple    ):
    _UpperCAmelCase		:       Optional[Any]       =    starting
    _UpperCAmelCase		:       Tuple       =    via
    _UpperCAmelCase		:       Optional[Any]       =    target
    _UpperCAmelCase		:       List[str]       =    degrees(atana(ya - ya	,      xa - xa    )    )
    via_angle %= 360
    _UpperCAmelCase		:       int       =    degrees(atana(ya - ya	,      xa - xa    )    )
    target_angle %= 360
    # t-
    #  \ \
    #   \ v
    #    \|
    #     s
    # via_angle is always lower than target_angle, if direction is left.
    # If they are same, it means they are on a same line of convex hull.
    if target_angle > via_angle:
      return Direction.left
    elif target_angle == via_angle:
      return Direction.straight
    else:
      return Direction.right
  
  
  
  
  
  def       a__						(		snake_case__				:       str    ):
  
    if len(__lowerCAmelCase    ) <= 2:
      # There is no convex hull
      raise ValueError("""graham_scan: argument must contain more than 3 points."""    )
    if len(__lowerCAmelCase    ) == 3:
      return points
    # find the lowest and the most left point
    _UpperCAmelCase		:       Any       =    0
    _UpperCAmelCase		:       Optional[int]       =    maxsize, maxsize
    for i, point in enumerate(__lowerCAmelCase    ):
      _UpperCAmelCase		:       List[str]       =    point[0]
      _UpperCAmelCase		:       Any       =    point[1]
      if y < miny:
        _UpperCAmelCase		:       str       =    y
        _UpperCAmelCase		:       int       =    x
        _UpperCAmelCase		:       List[str]       =    i
      if y == miny and x < minx:
        _UpperCAmelCase		:       Any       =    x
        _UpperCAmelCase		:       Union[str, Any]       =    i
  
      # remove the lowest and the most left point from points for preparing for sort
    points.pop(__lowerCAmelCase    )
  
    _UpperCAmelCase		:       List[Any]       =    sorted(__lowerCAmelCase	,      key=lambda snake_case__    : angle_comparer(__lowerCAmelCase	,      __lowerCAmelCase	,      __lowerCAmelCase    )    )
    # This insert actually costs complexity,
    # and you should instead add (minx, miny) into stack later.
    # I'm using insert just for easy understanding.
    sorted_points.insert(0	,      (minx, miny)    )
  
    _UpperCAmelCase		:       deque[tuple[int, int]]       =    deque()
    stack.append(sorted_points[0]    )
    stack.append(sorted_points[1]    )
    stack.append(sorted_points[2]    )
    # In any ways, the first 3 points line are towards left.
    # Because we sort them the angle from minx, miny.
    _UpperCAmelCase		:       Dict       =    Direction.left
  
    for i in range(3	,      len(__lowerCAmelCase    )    ):
      while True:
        _UpperCAmelCase		:       Dict       =    stack[-2]
        _UpperCAmelCase		:       List[str]       =    stack[-1]
        _UpperCAmelCase		:       List[str]       =    sorted_points[i]
        _UpperCAmelCase		:       Optional[int]       =    check_direction(__lowerCAmelCase	,      __lowerCAmelCase	,      __lowerCAmelCase    )
  
        if next_direction == Direction.left:
          _UpperCAmelCase		:       Dict       =    Direction.left
          break
        if next_direction == Direction.straight:
          if current_direction == Direction.left:
            # We keep current_direction as left.
            # Because if the straight line keeps as straight,
            # we want to know if this straight line is towards left.
            break
          elif current_direction == Direction.right:
            # If the straight line is towards right,
            # every previous points on those straigh line is not convex hull.
            stack.pop()
        if next_direction == Direction.right:
          stack.pop()
      stack.append(sorted_points[i]    )
    return list(__lowerCAmelCase    )
  
  
  
  
  
  
style_context: 
  
  
  from dataclasses import dataclass
  from enum import Enum
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  @dataclass
  class 		_SCREAMING_SNAKE_CASE    (	A    ):
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 1_5,
           '''sld_guidance_scale''': 2_0,
           '''sld_threshold''': 0.0,
           '''sld_momentum_scale''': 0.0,
           '''sld_mom_beta''': 0.0,
       }
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 1_0,
           '''sld_guidance_scale''': 1_0_0_0,
           '''sld_threshold''': 0.01,
           '''sld_momentum_scale''': 0.3,
           '''sld_mom_beta''': 0.4,
       }
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 7,
           '''sld_guidance_scale''': 2_0_0_0,
           '''sld_threshold''': 0.025,
           '''sld_momentum_scale''': 0.5,
           '''sld_mom_beta''': 0.7,
       }
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 0,
           '''sld_guidance_scale''': 5_0_0_0,
           '''sld_threshold''': 1.0,
           '''sld_momentum_scale''': 0.5,
           '''sld_mom_beta''': 0.7,
       }
  
  
  @dataclass
  class 		_SCREAMING_SNAKE_CASE    (	A    ):
       __SCREAMING_SNAKE_CASE    				=						42
       __SCREAMING_SNAKE_CASE    				=						42
       __SCREAMING_SNAKE_CASE    				=						42
       __SCREAMING_SNAKE_CASE    				=						42
  
  
  if is_transformers_available() and is_torch_available():
   from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
   from .safety_checker import SafeStableDiffusionSafetyChecker
  
  
  
  
  
  