


'''simple docstring'''





from dataclasses import dataclass
from typing import Dict, Optional, Union

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
from .attention_processor import AttentionProcessor, AttnProcessor
from .embeddings import TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin






@dataclass
class 	lowerCAmelCase_(    A__					):
  '''simple docstring'''




  __lowercase							:				torch.FloatTensor







class 	lowerCAmelCase_(    A__						,			A__					):
  '''simple docstring'''




  @register_to_config
  def __init__(   self  ,__UpperCAmelCase = 32  ,__UpperCAmelCase = 64  ,__UpperCAmelCase = 20  ,__UpperCAmelCase = 768  ,__UpperCAmelCase=77  ,__UpperCAmelCase=4  ,__UpperCAmelCase = 0.0  ,__UpperCAmelCase = "silu"  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None  ,__UpperCAmelCase = "linear"  ,__UpperCAmelCase = "prd"  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None  ,)   ->		Tuple:
      super().__init__()
      lowerCAmelCase__			:  Union[str, Any]											= num_attention_heads
      lowerCAmelCase__			:  Optional[int]											= attention_head_dim
      lowerCAmelCase__			:  Optional[int]											= num_attention_heads * attention_head_dim
      lowerCAmelCase__			:  List[Any]											= additional_embeddings

      lowerCAmelCase__			:  int											= time_embed_dim or inner_dim
      lowerCAmelCase__			:  int											= embedding_proj_dim or embedding_dim
      lowerCAmelCase__			:  List[Any]											= clip_embed_dim or embedding_dim

      lowerCAmelCase__			:  int											= Timesteps(lowerCamelCase__  ,lowerCamelCase__  ,0				)
      lowerCAmelCase__			:  List[str]											= TimestepEmbedding(lowerCamelCase__  ,lowerCamelCase__  ,out_dim=lowerCamelCase__  ,act_fn=lowerCamelCase__				)

      lowerCAmelCase__			:  Tuple											= nn.Linear(lowerCamelCase__  ,lowerCamelCase__				)

      if embedding_proj_norm_type is None:
          lowerCAmelCase__			:  Any											= None
      elif embedding_proj_norm_type == "layer":
          lowerCAmelCase__			:  Any											= nn.LayerNorm(lowerCamelCase__				)
      else:
          raise ValueError(F"""unsupported embedding_proj_norm_type: {embedding_proj_norm_type}"""				)

      lowerCAmelCase__			:  List[Any]											= nn.Linear(lowerCamelCase__  ,lowerCamelCase__				)

      if encoder_hid_proj_type is None:
          lowerCAmelCase__			:  Optional[int]											= None
      elif encoder_hid_proj_type == "linear":
          lowerCAmelCase__			:  int											= nn.Linear(lowerCamelCase__  ,lowerCamelCase__				)
      else:
          raise ValueError(F"""unsupported encoder_hid_proj_type: {encoder_hid_proj_type}"""				)

      lowerCAmelCase__			:  str											= nn.Parameter(torch.zeros(1  ,num_embeddings + additional_embeddings  ,lowerCamelCase__				)				)

      if added_emb_type == "prd":
          lowerCAmelCase__			:  List[Any]											= nn.Parameter(torch.zeros(1  ,1  ,lowerCamelCase__				)				)
      elif added_emb_type is None:
          lowerCAmelCase__			:  str											= None
      else:
          raise ValueError(
              F"""`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `'prd'` or `None`."""				)

      lowerCAmelCase__			:  Optional[Any]											= nn.ModuleList(
          [
              BasicTransformerBlock(
                  lowerCamelCase__  ,lowerCamelCase__  ,lowerCamelCase__  ,dropout=lowerCamelCase__  ,activation_fn="""gelu"""  ,attention_bias=lowerCamelCase__  ,)
              for d in range(lowerCamelCase__				)
          ]				)

      if norm_in_type == "layer":
          lowerCAmelCase__			:  Tuple											= nn.LayerNorm(lowerCamelCase__				)
      elif norm_in_type is None:
          lowerCAmelCase__			:  Optional[int]											= None
      else:
          raise ValueError(F"""Unsupported norm_in_type: {norm_in_type}."""				)

      lowerCAmelCase__			:  str											= nn.LayerNorm(lowerCamelCase__				)

      lowerCAmelCase__			:  Optional[int]											= nn.Linear(lowerCamelCase__  ,lowerCamelCase__				)

      lowerCAmelCase__			:  Optional[Any]											= torch.full(
          [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings]  ,-1_0000.0				)
      causal_attention_mask.triu_(1				)
      lowerCAmelCase__			:  Optional[Any]											= causal_attention_mask[None, ...]
      self.register_buffer("""causal_attention_mask"""  ,lowerCamelCase__  ,persistent=lowerCamelCase__				)

      lowerCAmelCase__			:  Optional[int]											= nn.Parameter(torch.zeros(1  ,lowerCamelCase__				)				)
      lowerCAmelCase__			:  Dict											= nn.Parameter(torch.zeros(1  ,lowerCamelCase__				)				)




  @property
  # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
  def 							UpperCAmelCase_     (   self				)   ->		str:
      lowerCAmelCase__			:  List[Any]											= {}

      def fn_recursive_add_processors(__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase				):
          if hasattr(lowerCamelCase__  ,"""set_processor"""				):
              lowerCAmelCase__			:  Optional[int]											= module.processor

          for sub_name, child in module.named_children():
              fn_recursive_add_processors(F"""{name}.{sub_name}"""  ,lowerCamelCase__  ,lowerCamelCase__				)

          return processors

      for name, module in self.named_children():
          fn_recursive_add_processors(lowerCamelCase__  ,lowerCamelCase__  ,lowerCamelCase__				)

      return processors




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		Optional[int]:
      lowerCAmelCase__			:  Union[str, Any]											= len(self.attn_processors.keys()				)

      if isinstance(lowerCamelCase__  ,lowerCamelCase__				) and len(lowerCamelCase__				) != count:
          raise ValueError(
              F"""A dict of processors was passed, but the number of processors {len(lowerCamelCase__				)} does not match the"""
              F""" number of attention layers: {count}. Please make sure to pass {count} processor classes."""				)

      def fn_recursive_attn_processor(__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase				):
          if hasattr(lowerCamelCase__  ,"""set_processor"""				):
              if not isinstance(lowerCamelCase__  ,lowerCamelCase__				):
                  module.set_processor(lowerCamelCase__				)
              else:
                  module.set_processor(processor.pop(F"""{name}.processor"""				)				)

          for sub_name, child in module.named_children():
              fn_recursive_attn_processor(F"""{name}.{sub_name}"""  ,lowerCamelCase__  ,lowerCamelCase__				)

      for name, module in self.named_children():
          fn_recursive_attn_processor(lowerCamelCase__  ,lowerCamelCase__  ,lowerCamelCase__				)




  def 							UpperCAmelCase_     (   self				)   ->		Tuple:
      self.set_attn_processor(AttnProcessor()				)




  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase  ,__UpperCAmelCase = None  ,__UpperCAmelCase = None  ,__UpperCAmelCase = True  ,)   ->		Any:
      lowerCAmelCase__			:  Tuple											= hidden_states.shape[0]

      lowerCAmelCase__			:  Union[str, Any]											= timestep
      if not torch.is_tensor(lowerCamelCase__				):
          lowerCAmelCase__			:  Optional[Any]											= torch.tensor([timesteps]  ,dtype=torch.long  ,device=hidden_states.device				)
      elif torch.is_tensor(lowerCamelCase__				) and len(timesteps.shape				) == 0:
          lowerCAmelCase__			:  Union[str, Any]											= timesteps[None].to(hidden_states.device				)

      # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
      lowerCAmelCase__			:  Any											= timesteps * torch.ones(lowerCamelCase__  ,dtype=timesteps.dtype  ,device=timesteps.device				)

      lowerCAmelCase__			:  Optional[int]											= self.time_proj(lowerCamelCase__				)

      # timesteps does not contain any weights and will always return f32 tensors
      # but time_embedding might be fp16, so we need to cast here.
      lowerCAmelCase__			:  Dict											= timesteps_projected.to(dtype=self.dtype				)
      lowerCAmelCase__			:  List[str]											= self.time_embedding(lowerCamelCase__				)

      if self.embedding_proj_norm is not None:
          lowerCAmelCase__			:  List[Any]											= self.embedding_proj_norm(lowerCamelCase__				)

      lowerCAmelCase__			:  Optional[int]											= self.embedding_proj(lowerCamelCase__				)
      if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None:
          lowerCAmelCase__			:  Optional[int]											= self.encoder_hidden_states_proj(lowerCamelCase__				)
      elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None:
          raise ValueError("""`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set"""				)

      lowerCAmelCase__			:  Any											= self.proj_in(lowerCamelCase__				)

      lowerCAmelCase__			:  List[str]											= self.positional_embedding.to(hidden_states.dtype				)

      lowerCAmelCase__			:  Union[str, Any]											= []
      lowerCAmelCase__			:  str											= 0

      if encoder_hidden_states is not None:
          additional_embeds.append(lowerCamelCase__				)
          additional_embeddings_len += encoder_hidden_states.shape[1]

      if len(proj_embeddings.shape				) == 2:
          lowerCAmelCase__			:  int											= proj_embeddings[:, None, :]

      if len(hidden_states.shape				) == 2:
          lowerCAmelCase__			:  Union[str, Any]											= hidden_states[:, None, :]

      lowerCAmelCase__			:  Optional[int]											= additional_embeds + [
          proj_embeddings,
          time_embeddings[:, None, :],
          hidden_states,
      ]

      if self.prd_embedding is not None:
          lowerCAmelCase__			:  Tuple											= self.prd_embedding.to(hidden_states.dtype				).expand(lowerCamelCase__  ,-1  ,-1				)
          additional_embeds.append(lowerCamelCase__				)

      lowerCAmelCase__			:  Optional[int]											= torch.cat(
          lowerCamelCase__  ,dim=1  ,)

      # Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens
      lowerCAmelCase__			:  List[Any]											= additional_embeddings_len + proj_embeddings.shape[1] + 1
      if positional_embeddings.shape[1] < hidden_states.shape[1]:
          lowerCAmelCase__			:  Any											= F.pad(
              lowerCamelCase__  ,(
                  0,
                  0,
                  additional_embeddings_len,
                  self.prd_embedding.shape[1] if self.prd_embedding is not None else 0,
              )  ,value=0.0  ,)

      lowerCAmelCase__			:  int											= hidden_states + positional_embeddings

      if attention_mask is not None:
          lowerCAmelCase__			:  Optional[Any]											= (1 - attention_mask.to(hidden_states.dtype				)) * -1_0000.0
          lowerCAmelCase__			:  Optional[int]											= F.pad(lowerCamelCase__  ,(0, self.additional_embeddings)  ,value=0.0				)
          lowerCAmelCase__			:  Tuple											= (attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype				)
          lowerCAmelCase__			:  Dict											= attention_mask.repeat_interleave(self.config.num_attention_heads  ,dim=0				)

      if self.norm_in is not None:
          lowerCAmelCase__			:  str											= self.norm_in(lowerCamelCase__				)

      for block in self.transformer_blocks:
          lowerCAmelCase__			:  Any											= block(lowerCamelCase__  ,attention_mask=lowerCamelCase__				)

      lowerCAmelCase__			:  List[str]											= self.norm_out(lowerCamelCase__				)

      if self.prd_embedding is not None:
          lowerCAmelCase__			:  List[str]											= hidden_states[:, -1]
      else:
          lowerCAmelCase__			:  int											= hidden_states[:, additional_embeddings_len:]

      lowerCAmelCase__			:  Union[str, Any]											= self.proj_to_clip_embeddings(lowerCamelCase__				)

      if not return_dict:
          return (predicted_image_embedding,)

      return PriorTransformerOutput(predicted_image_embedding=lowerCamelCase__				)






  def 							UpperCAmelCase_     (   self  ,__UpperCAmelCase				)   ->		Optional[Any]:
      lowerCAmelCase__			:  List[str]											= (prior_latents * self.clip_std) + self.clip_mean
      return prior_latents







'''simple docstring'''





from ..utils import DummyObject, requires_backends






class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				int           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Optional[int]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		str:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				str           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Optional[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Union[str, Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				int           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Tuple:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Dict           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Dict:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[str]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Dict           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Any:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Tuple           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Union[str, Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[int]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[str]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Union[str, Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[int]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[str]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				List[str]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Any:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Tuple           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[str]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Dict           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Union[str, Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Tuple           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		str:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				List[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Optional[int]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				int           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Optional[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Tuple           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Dict:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				str           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Union[str, Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				List[str]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Any:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Optional[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[int]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		str:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Any           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		int:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				List[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[str]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Tuple           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		str:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				Optional[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		Optional[int]:
      requires_backends(self  ,["""sentencepiece"""]				)







class 	lowerCAmelCase_(    metaclass=SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  __lowercase							:				List[Any]           =				['''sentencepiece''']




  def __init__(   self  ,*__UpperCAmelCase  ,**__UpperCAmelCase				)   ->		List[Any]:
      requires_backends(self  ,["""sentencepiece"""]				)


