code: 
  
  
  """simple docstring"""
  
  
  
  
  
  
  import inspect
  import warnings
  
  import torch
  
  from .state import AcceleratorState, GradientState
  from .utils import DistributedType, honor_type, is_tpu_available
  
  
  if is_tpu_available(check_device=False):
      import torch_xla.core.xla_model as xm
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     if isinstance(_UpperCAmelCase    ,       (list, tuple)			):
        return honor_type(_UpperCAmelCase    ,       (move_to_device(_UpperCAmelCase    ,       _UpperCAmelCase			) for t in state)			)
     elif isinstance(_UpperCAmelCase    ,       _UpperCAmelCase			):
        return type(_UpperCAmelCase			)({k: move_to_device(_UpperCAmelCase    ,       _UpperCAmelCase			) for k, v in state.items()}			)
     elif isinstance(_UpperCAmelCase    ,       torch.Tensor			):
        return state.to(_UpperCAmelCase			)
     return state
  class 						__lowerCAmelCase   (			torch.optim.Optimizer       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    def __init__(      self:		int				,			UpperCamelCase_:		List[str]				,			UpperCamelCase_:		Tuple=True				,			UpperCamelCase_:		Tuple=None					):
       UpperCamelCase_     =optimizer
       UpperCamelCase_     =scaler
       UpperCamelCase_     =AcceleratorState()
       UpperCamelCase_     =GradientState()
       UpperCamelCase_     =device_placement
       UpperCamelCase_     =False
       UpperCamelCase_     =None
  
       # Handle device placement
       if device_placement:
          UpperCamelCase_     =self.optimizer.state_dict()
          if self.accelerator_state.distributed_type == DistributedType.TPU:
             xm.send_cpu_data_to_device(SCREAMING_SNAKE_CASE_				,			self.accelerator_state.device					)
          else:
             UpperCamelCase_     =move_to_device(SCREAMING_SNAKE_CASE_				,			self.accelerator_state.device					)
          self.optimizer.load_state_dict(SCREAMING_SNAKE_CASE_					)
    @property
    def 					UpperCamelCase__   (      self:		Union[str, Any]					):
       return self.optimizer.state
    @state.setter
    def 					UpperCamelCase__   (      self:		Optional[Any]				,			UpperCamelCase_:		List[str]					):
       UpperCamelCase_     =state
    @property
    def 					UpperCamelCase__   (      self:		List[str]					):
       return self.optimizer.param_groups
    @param_groups.setter
    def 					UpperCamelCase__   (      self:		int				,			UpperCamelCase_:		List[Any]					):
       UpperCamelCase_     =param_groups
    @property
    def 					UpperCamelCase__   (      self:		Dict					):
       return self.optimizer.defaults
    @defaults.setter
    def 					UpperCamelCase__   (      self:		Tuple				,			UpperCamelCase_:		Tuple					):
       UpperCamelCase_     =defaults
    def 					UpperCamelCase__   (      self:		Any				,			UpperCamelCase_:		Optional[Any]					):
       self.optimizer.add_param_group(SCREAMING_SNAKE_CASE_					)
    def 					UpperCamelCase__   (      self:		List[Any]				,			UpperCamelCase_:		Dict					):
       if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
          xm.send_cpu_data_to_device(SCREAMING_SNAKE_CASE_				,			self.accelerator_state.device					)
       self.optimizer.load_state_dict(SCREAMING_SNAKE_CASE_					)
    def 					UpperCamelCase__   (      self:		List[str]					):
       return self.optimizer.state_dict()
    def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		str=None					):
       if self.gradient_state.sync_gradients:
          UpperCamelCase_     ="set_to_none" in inspect.signature(self.optimizer.zero_grad					).parameters
          if accept_arg:
             if set_to_none is None:
                UpperCamelCase_     =False
             self.optimizer.zero_grad(set_to_none=SCREAMING_SNAKE_CASE_					)
          else:
             if set_to_none is not None:
                raise ValueError("`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer."					)
             self.optimizer.zero_grad()
    def 					UpperCamelCase__   (      self:		int				,			UpperCamelCase_:		List[Any]=None					):
       if self.gradient_state.sync_gradients:
          if self.accelerator_state.distributed_type == DistributedType.TPU:
             UpperCamelCase_     ={"closure": closure} if closure is not None else {}
             xm.optimizer_step(self.optimizer				,			optimizer_args=SCREAMING_SNAKE_CASE_					)
          elif self.scaler is not None:
             UpperCamelCase_     =False
             if self._last_scale is None:
                # `get_scale` is an async operation requiring full synchronization
                # on CPU and GPUs before finishing. As a result, we store away
                # the prior one to reduce the call overhead
                UpperCamelCase_     =self.scaler.get_scale()
                UpperCamelCase_     =True
             self.scaler.step(self.optimizer				,			SCREAMING_SNAKE_CASE_					)
             self.scaler.update()
             UpperCamelCase_     =self.scaler.get_scale()
             if not new_scale:
                # If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
                UpperCamelCase_     =scale_after < self._last_scale
             UpperCamelCase_     =scale_after
  
          else:
             self.optimizer.step(SCREAMING_SNAKE_CASE_					)
    def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		Union[str, Any]					):
       for param_group in self.optimizer.param_groups:
          UpperCamelCase_     =[parameters_map.get(SCREAMING_SNAKE_CASE_				,			SCREAMING_SNAKE_CASE_					) for p in param_group["params"]]
    @property
    def 					UpperCamelCase__   (      self:		Dict					):
       warnings.warn(
           "The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use "
           "`optimizer.step_was_skipped` instead."				,			SCREAMING_SNAKE_CASE_				,			)
       return self._is_overflow
    @property
    def 					UpperCamelCase__   (      self:		Tuple					):
       return self._is_overflow
    def __getstate__(      self:		Dict					):
       return self.__dict__.copy()
  
  
  
  
  
    def __setstate__(      self:		List[Any]				,			UpperCamelCase_:		Any					):
       self.__dict__.update(SCREAMING_SNAKE_CASE_					)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from __future__ import annotations
  
  from pathlib import Path
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     return pointa[0] * pointa[1] - pointa[1] * pointa[0]
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A    ,       A    ,       A    ,       A    ,       A			):
     UpperCamelCase_     =(xa, ya)
     UpperCamelCase_     =(xa - xa, ya - ya)
     UpperCamelCase_     =(xa - xa, ya - ya)
     UpperCamelCase_     =-vector_product(A    ,       A			) / vector_product(
         A    ,       A			)
     UpperCamelCase_     =+vector_product(A    ,       A			) / vector_product(
         A    ,       A			)
  
     return a > 0 and b > 0 and a + b < 1
  
  
  
  
  def 						_UpperCamelCase			(  A = "p102_triangles.txt"			):
     UpperCamelCase_     =Path(A			).parent.joinpath(A			).read_text(encoding="utf-8"			)
  
     UpperCamelCase_     =[]
     for line in data.strip().split("\n"			):
        triangles.append([int(A			) for number in line.split(","			)]			)
  
     UpperCamelCase_     =0
     UpperCamelCase_     =42
  
     for triangle in triangles:
        ret += contains_origin(*A			)
  
     return ret
  
  
  if __name__ == "__main__":
      print(f'''{solution() = }''')
  