






import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class 			_lowercase ( _UpperCamelCase    ,					_UpperCamelCase    ,					unittest.TestCase    ):
      _a				:    Optional[Any]				      =				StableDiffusionXLImgaImgPipeline
      _a				:    Optional[Any]				      =				TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''height''', '''width'''}
      _a				:    Union[str, Any]				      =				PipelineTesterMixin.required_optional_params - {'''latents'''}
      _a				:    int				      =				TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
      _a				:    Optional[int]				      =				IMAGE_TO_IMAGE_IMAGE_PARAMS
      _a				:    List[Any]				      =				IMAGE_TO_IMAGE_IMAGE_PARAMS
      def     lowercase__       (  self ):
       torch.manual_seed(0 )
       snake_case__	:     Optional[Any]											=UNetaDConditionModel(
           block_out_channels=(3_2, 6_4)					,      layers_per_block=2					,      sample_size=3_2					,      in_channels=4					,      out_channels=4					,      down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")					,      up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")					,      attention_head_dim=(2, 4)					,      use_linear_projection=lowercase__					,      addition_embed_type="""text_time"""					,      addition_time_embed_dim=8					,      transformer_layers_per_block=(1, 2)					,      projection_class_embeddings_input_dim=8_0					,      cross_attention_dim=6_4					,      )
       snake_case__	:     Union[str, Any]											=EulerDiscreteScheduler(
           beta_start=0.00085					,      beta_end=0.012					,      steps_offset=1					,      beta_schedule="""scaled_linear"""					,      timestep_spacing="""leading"""					,      )
       torch.manual_seed(0 )
       snake_case__	:     Union[str, Any]											=AutoencoderKL(
           block_out_channels=[3_2, 6_4]					,      in_channels=3					,      out_channels=3					,      down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]					,      up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]					,      latent_channels=4					,      sample_size=1_2_8					,      )
       torch.manual_seed(0 )
       snake_case__	:     Dict											=CLIPTextConfig(
           bos_token_id=0					,      eos_token_id=2					,      hidden_size=3_2					,      intermediate_size=3_7					,      layer_norm_eps=1e-05					,      num_attention_heads=4					,      num_hidden_layers=5					,      pad_token_id=1					,      vocab_size=1_0_0_0					,      hidden_act="""gelu"""					,      projection_dim=3_2					,      )
       snake_case__	:     str											=CLIPTextModel(lowercase__ )
       snake_case__	:     str											=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					,      local_files_only=lowercase__ )

       snake_case__	:     Tuple											=CLIPTextModelWithProjection(lowercase__ )
       snake_case__	:     str											=CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					,      local_files_only=lowercase__ )

       snake_case__	:     Dict											={
           '''unet''': unet,
           '''scheduler''': scheduler,
           '''vae''': vae,
           '''text_encoder''': text_encoder,
           '''tokenizer''': tokenizer,
           '''text_encoder_2''': text_encoder_a,
           '''tokenizer_2''': tokenizer_a,
           # "safety_checker": None,
           # "feature_extractor": None,
       }
       return components
      def     lowercase__       (  self					,      a					,      a=0 ):
       snake_case__	:     str											=floats_tensor((1, 3, 3_2, 3_2)					,      rng=random.Random(lowercase__ ) ).to(lowercase__ )
       snake_case__	:     List[Any]											=image / 2 + 0.5
       if str(lowercase__ ).startswith("""mps""" ):
        snake_case__	:     List[str]											=torch.manual_seed(lowercase__ )
       else:
        snake_case__	:     List[str]											=torch.Generator(device=lowercase__ ).manual_seed(lowercase__ )
       snake_case__	:     Tuple											={
           '''prompt''': '''A painting of a squirrel eating a burger''',
           '''image''': image,
           '''generator''': generator,
           '''num_inference_steps''': 2,
           '''guidance_scale''': 5.0,
           '''output_type''': '''numpy''',
           '''strength''': 0.75,
       }
       return inputs
      def     lowercase__       (  self ):
       snake_case__	:     Tuple											='''cpu'''  # ensure determinism for the device-dependent torch.Generator
       snake_case__	:     List[Any]											=self.get_dummy_components()
       snake_case__	:     Tuple											=StableDiffusionXLImgaImgPipeline(**lowercase__ )
       snake_case__	:     str											=sd_pipe.to(lowercase__ )
       sd_pipe.set_progress_bar_config(disable=lowercase__ )

       snake_case__	:     Any											=self.get_dummy_inputs(lowercase__ )
       snake_case__	:     List[Any]											=sd_pipe(**lowercase__ ).images
       snake_case__	:     List[str]											=image[0, -3:, -3:, -1]

       assert image.shape == (1, 3_2, 3_2, 3)

       snake_case__	:     Any											=np.array([0.4656, 0.4840, 0.4439, 0.6698, 0.5574, 0.4524, 0.5799, 0.5943, 0.5165] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1e-2
      def     lowercase__       (  self ):
       super().test_attention_slicing_forward_pass(expected_max_diff=3e-3 )
      def     lowercase__       (  self ):
       super().test_inference_batch_single_identical(expected_max_diff=3e-3 )
      def     lowercase__       (  self ):
       pass



      def     lowercase__       (  self ):
       snake_case__	:     int											=self.get_dummy_components()
       snake_case__	:     List[str]											=StableDiffusionXLImgaImgPipeline(**lowercase__ )
       snake_case__	:     List[Any]											=sd_pipe.to(lowercase__ )
       snake_case__	:     Dict											=sd_pipe.to(lowercase__ )
       sd_pipe.set_progress_bar_config(disable=lowercase__ )

       # forward without prompt embeds
       snake_case__	:     Any											=self.get_dummy_inputs(lowercase__ )
       snake_case__	:     Optional[Any]											=3 * ['''this is a negative prompt''']
       snake_case__	:     Optional[Any]											=negative_prompt
       snake_case__	:     str											=3 * [inputs['''prompt''']]

       snake_case__	:     Optional[Any]											=sd_pipe(**lowercase__ )
       snake_case__	:     Union[str, Any]											=output.images[0, -3:, -3:, -1]

       # forward with prompt embeds
       snake_case__	:     List[Any]											=self.get_dummy_inputs(lowercase__ )
       snake_case__	:     str											=3 * ['''this is a negative prompt''']
       snake_case__	:     int											=3 * [inputs.pop("""prompt""" )]

       (
           snake_case__      
       )	:     int											=sd_pipe.encode_prompt(lowercase__					,      negative_prompt=lowercase__ )

       snake_case__	:     Optional[Any]											=sd_pipe(
           **lowercase__					,      prompt_embeds=lowercase__					,      negative_prompt_embeds=lowercase__					,      pooled_prompt_embeds=lowercase__					,      negative_pooled_prompt_embeds=lowercase__					,      )
       snake_case__	:     Optional[int]											=output.images[0, -3:, -3:, -1]

       # make sure that it's equal
       assert np.abs(image_slice_a.flatten() - image_slice_a.flatten() ).max() < 1e-4







@slow
@require_torch_gpu
class 			_lowercase ( unittest.TestCase    ):
      def     lowercase__       (  self ):
       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
      def     lowercase__       (  self					,      a					,      a="cpu"					,      a=torch.floataa					,      a=0 ):
       snake_case__	:     List[Any]											=torch.Generator(device=lowercase__ ).manual_seed(lowercase__ )
       snake_case__	:     Optional[Any]											=np.random.RandomState(lowercase__ ).standard_normal((1, 4, 6_4, 6_4) )
       snake_case__	:     Any											=torch.from_numpy(lowercase__ ).to(device=lowercase__					,      dtype=lowercase__ )
       snake_case__	:     Tuple											={
           '''prompt''': '''a photograph of an astronaut riding a horse''',
           '''latents''': latents,
           '''generator''': generator,
           '''num_inference_steps''': 3,
           '''guidance_scale''': 7.5,
           '''output_type''': '''numpy''',
       }
       return inputs



      def     lowercase__       (  self ):
       snake_case__	:     Tuple											=DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base""" )
       pipe.to(lowercase__ )
       pipe.set_progress_bar_config(disable=lowercase__ )

       snake_case__	:     Union[str, Any]											=self.get_inputs(lowercase__ )
       snake_case__	:     Optional[Any]											=pipe(**lowercase__ ).images
       snake_case__	:     List[str]											=image[0, -3:, -3:, -1].flatten()

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       snake_case__	:     str											=np.array([0.49493, 0.47896, 0.40798, 0.54214, 0.53212, 0.48202, 0.47656, 0.46329, 0.48506] )
       assert np.abs(image_slice - expected_slice ).max() < 7e-3









import json
import os
from functools import lru_cache
from typing import Dict, List, Optional, Tuple, Union

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...tokenization_utils_base import BatchEncoding, EncodedInput
from ...utils import PaddingStrategy, logging


lowerCAmelCase       		=    logging.get_logger(__name__)


lowerCAmelCase       		=    {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

# See all LED models at https://huggingface.co/models?filter=LED
lowerCAmelCase       		=    {
    """vocab_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/vocab.json""",
    },
    """merges_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/merges.txt""",
    },
    """tokenizer_file""": {
        """allenai/led-base-16384""": """https://huggingface.co/allenai/led-base-16384/resolve/main/tokenizer.json""",
    },
}

lowerCAmelCase       		=    {
    """allenai/led-base-16384""": 16_384,
}




@lru_cache()
# Copied from transformers.models.bart.tokenization_bart.bytes_to_unicode
def     __SCREAMING_SNAKE_CASE							(       )		->     Dict:




						'''simple docstring'''







						__UpperCAmelCase			:							Optional[int]	    =	(
						    list(range(ord('''!'''      )      ,       ord('''~'''      ) + 1      )      ) + list(range(ord('''¡'''      )      ,       ord('''¬'''      ) + 1      )      ) + list(range(ord('''®'''      )      ,       ord('''ÿ'''      ) + 1      )      )
						)
						__UpperCAmelCase			:							Tuple	    =	bs[:]
						__UpperCAmelCase			:							Dict	    =	0
						for b in range(2**8      ):
												if b not in bs:
																		bs.append(lowercase_      )
																		cs.append(2**8 + n      )
																		n += 1
						__UpperCAmelCase			:							Union[str, Any]	    =	[chr(lowercase_      ) for n in cs]
						return dict(zip(lowercase_      ,       lowercase_      )      )




def     __SCREAMING_SNAKE_CASE							(       lowercase_      )		->     Optional[Any]:




						'''simple docstring'''







						__UpperCAmelCase			:							Any	    =	set()
						__UpperCAmelCase			:							Tuple	    =	word[0]
						for char in word[1:]:
												pairs.add((prev_char, char)      )
												__UpperCAmelCase			:							Tuple	    =	char
						return pairs





class 							lowerCamelCase   (  _UpperCamelCase ):
	_lowerCAmelCase     :		List[Any]										=						VOCAB_FILES_NAMES
	_lowerCAmelCase     :		int										=						PRETRAINED_VOCAB_FILES_MAP
	_lowerCAmelCase     :		Union[str, Any]										=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	_lowerCAmelCase     :		int										=						['''input_ids''', '''attention_mask''']


	def __init__(    self				,     lowercase__				,     lowercase__				,     lowercase__="replace"				,     lowercase__="<s>"				,     lowercase__="</s>"				,     lowercase__="</s>"				,     lowercase__="<s>"				,     lowercase__="<unk>"				,     lowercase__="<pad>"				,     lowercase__="<mask>"				,     lowercase__=False				,     **lowercase__				,     ):
							__UpperCAmelCase			:							List[Any]	    =	AddedToken(lowercase__				,     lstrip=lowercase__				,     rstrip=lowercase__) if isinstance(lowercase__				,     lowercase__) else bos_token
							__UpperCAmelCase			:							int	    =	AddedToken(lowercase__				,     lstrip=lowercase__				,     rstrip=lowercase__) if isinstance(lowercase__				,     lowercase__) else eos_token
							__UpperCAmelCase			:							Optional[Any]	    =	AddedToken(lowercase__				,     lstrip=lowercase__				,     rstrip=lowercase__) if isinstance(lowercase__				,     lowercase__) else sep_token
							__UpperCAmelCase			:							Any	    =	AddedToken(lowercase__				,     lstrip=lowercase__				,     rstrip=lowercase__) if isinstance(lowercase__				,     lowercase__) else cls_token
							__UpperCAmelCase			:							Any	    =	AddedToken(lowercase__				,     lstrip=lowercase__				,     rstrip=lowercase__) if isinstance(lowercase__				,     lowercase__) else unk_token
							__UpperCAmelCase			:							List[str]	    =	AddedToken(lowercase__				,     lstrip=lowercase__				,     rstrip=lowercase__) if isinstance(lowercase__				,     lowercase__) else pad_token

							# Mask token behave like a normal word, i.e. include the space before it
							__UpperCAmelCase			:							Optional[Any]	    =	AddedToken(lowercase__				,     lstrip=lowercase__				,     rstrip=lowercase__) if isinstance(lowercase__				,     lowercase__) else mask_token

							super().__init__(
							    errors=lowercase__				,     bos_token=lowercase__				,     eos_token=lowercase__				,     unk_token=lowercase__				,     sep_token=lowercase__				,     cls_token=lowercase__				,     pad_token=lowercase__				,     mask_token=lowercase__				,     add_prefix_space=lowercase__				,     **lowercase__				,     )

							with open(lowercase__				,     encoding='''utf-8''') as vocab_handle:
													__UpperCAmelCase			:							Optional[int]	    =	json.load(lowercase__)
							__UpperCAmelCase			:							List[str]	    =	{v: k for k, v in self.encoder.items()}
							__UpperCAmelCase			:							Optional[Any]	    =	errors  # how to handle errors in decoding
							__UpperCAmelCase			:							str	    =	bytes_to_unicode()
							__UpperCAmelCase			:							List[str]	    =	{v: k for k, v in self.byte_encoder.items()}
							with open(lowercase__				,     encoding='''utf-8''') as merges_handle:
													__UpperCAmelCase			:							Optional[int]	    =	merges_handle.read().split('''\n''')[1:-1]
							__UpperCAmelCase			:							int	    =	[tuple(merge.split()) for merge in bpe_merges]
							__UpperCAmelCase			:							str	    =	dict(zip(lowercase__				,     range(len(lowercase__))))
							__UpperCAmelCase			:							Optional[int]	    =	{}
							__UpperCAmelCase			:							Optional[int]	    =	add_prefix_space

							# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
							__UpperCAmelCase			:							List[Any]	    =	re.compile(r'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+''')


	@property
	# Copied from transformers.models.bart.tokenization_bart.BartTokenizer.vocab_size
	def  A(    self):
							return len(self.encoder)


	def  A(    self):
							return dict(self.encoder				,     **self.added_tokens_encoder)


	def  A(    self				,     lowercase__):
							if token in self.cache:
													return self.cache[token]
							__UpperCAmelCase			:							int	    =	tuple(lowercase__)
							__UpperCAmelCase			:							int	    =	get_pairs(lowercase__)

							if not pairs:
													return token

							while True:
													__UpperCAmelCase			:							Union[str, Any]	    =	min(lowercase__				,     key=lambda lowercase__: self.bpe_ranks.get(lowercase__				,     float('''inf''')))
													if bigram not in self.bpe_ranks:
																			break
													__UpperCAmelCase    ,      __UpperCAmelCase			:							Tuple	    =	bigram
													__UpperCAmelCase			:							List[str]	    =	[]
													__UpperCAmelCase			:							List[str]	    =	0
													while i < len(lowercase__):
																			try:
																									__UpperCAmelCase			:							List[Any]	    =	word.index(lowercase__				,     lowercase__)
																			except ValueError:
																									new_word.extend(word[i:])
																									break
																			else:
																									new_word.extend(word[i:j])
																									__UpperCAmelCase			:							str	    =	j

																			if word[i] == first and i < len(lowercase__) - 1 and word[i + 1] == second:
																									new_word.append(first + second)
																									i += 2
																			else:
																									new_word.append(word[i])
																									i += 1
													__UpperCAmelCase			:							Union[str, Any]	    =	tuple(lowercase__)
													__UpperCAmelCase			:							Dict	    =	new_word
													if len(lowercase__) == 1:
																			break
													else:
																			__UpperCAmelCase			:							Optional[int]	    =	get_pairs(lowercase__)
							__UpperCAmelCase			:							List[Any]	    =	''' '''.join(lowercase__)
							__UpperCAmelCase			:							Tuple	    =	word
							return word


	def  A(    self				,     lowercase__):
							__UpperCAmelCase			:							str	    =	[]
							for token in re.findall(self.pat				,     lowercase__):
													__UpperCAmelCase			:							Dict	    =	''''''.join(
													    self.byte_encoder[b] for b in token.encode('''utf-8'''))  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
													bpe_tokens.extend(bpe_token for bpe_token in self.bpe(lowercase__).split(''' '''))
							return bpe_tokens


	def  A(    self				,     lowercase__):
							return self.encoder.get(lowercase__				,     self.encoder.get(self.unk_token))


	def  A(    self				,     lowercase__):
							return self.decoder.get(lowercase__)


	def  A(    self				,     lowercase__):
							__UpperCAmelCase			:							str	    =	''''''.join(lowercase__)
							__UpperCAmelCase			:							Optional[int]	    =	bytearray([self.byte_decoder[c] for c in text]).decode('''utf-8'''				,     errors=self.errors)
							return text


	def  A(    self				,     lowercase__				,     lowercase__ = None):
							if not os.path.isdir(lowercase__):
													logger.error(F"Vocabulary path ({save_directory}) should be a directory")
													return
							__UpperCAmelCase			:							List[Any]	    =	os.path.join(
							    lowercase__				,     (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''])
							__UpperCAmelCase			:							Optional[Any]	    =	os.path.join(
							    lowercase__				,     (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file'''])

							with open(lowercase__				,     '''w'''				,     encoding='''utf-8''') as f:
													f.write(json.dumps(self.encoder				,     indent=2				,     sort_keys=lowercase__				,     ensure_ascii=lowercase__) + '''\n''')

							__UpperCAmelCase			:							Tuple	    =	0
							with open(lowercase__				,     '''w'''				,     encoding='''utf-8''') as writer:
													writer.write('''#version: 0.2\n''')
													for bpe_tokens, token_index in sorted(self.bpe_ranks.items()				,     key=lambda lowercase__: kv[1]):
																			if index != token_index:
																									logger.warning(
																									    F"Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."
																									    ''' Please check that the tokenizer is not corrupted!''')
																									__UpperCAmelCase			:							Optional[int]	    =	token_index
																			writer.write(''' '''.join(lowercase__) + '''\n''')
																			index += 1

							return vocab_file, merge_file


	def  A(    self				,     lowercase__				,     lowercase__ = None):
							if token_ids_a is None:
													return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
							__UpperCAmelCase			:							Optional[Any]	    =	[self.cls_token_id]
							__UpperCAmelCase			:							Union[str, Any]	    =	[self.sep_token_id]
							return cls + token_ids_a + sep + sep + token_ids_a + sep


	def  A(    self				,     lowercase__				,     lowercase__ = None				,     lowercase__ = False):
							if already_has_special_tokens:
													return super().get_special_tokens_mask(
													    token_ids_a=lowercase__				,     token_ids_a=lowercase__				,     already_has_special_tokens=lowercase__)

							if token_ids_a is None:
													return [1] + ([0] * len(lowercase__)) + [1]
							return [1] + ([0] * len(lowercase__)) + [1, 1] + ([0] * len(lowercase__)) + [1]


	def  A(    self				,     lowercase__				,     lowercase__ = None):
							__UpperCAmelCase			:							List[Any]	    =	[self.sep_token_id]
							__UpperCAmelCase			:							List[Any]	    =	[self.cls_token_id]

							if token_ids_a is None:
													return len(cls + token_ids_a + sep) * [0]
							return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0]


	def  A(    self				,     lowercase__				,     lowercase__=False				,     **lowercase__):
							__UpperCAmelCase			:							List[Any]	    =	kwargs.pop('''add_prefix_space'''				,     self.add_prefix_space)
							if (is_split_into_words or add_prefix_space) and (len(lowercase__) > 0 and not text[0].isspace()):
													__UpperCAmelCase			:							List[Any]	    =	''' ''' + text
							return (text, kwargs)


	def  A(    self				,     lowercase__				,     lowercase__ = None				,     lowercase__ = PaddingStrategy.DO_NOT_PAD				,     lowercase__ = None				,     lowercase__ = None				,     ):
							__UpperCAmelCase			:							Optional[Any]	    =	super()._pad(
							    encoded_inputs=lowercase__				,     max_length=lowercase__				,     padding_strategy=lowercase__				,     pad_to_multiple_of=lowercase__				,     return_attention_mask=lowercase__				,     )

							# Load from model defaults
							if return_attention_mask is None:
													__UpperCAmelCase			:							Optional[Any]	    =	'''attention_mask''' in self.model_input_names

							if return_attention_mask and "global_attention_mask" in encoded_inputs:
													__UpperCAmelCase			:							Dict	    =	encoded_inputs[self.model_input_names[0]]
													# `global_attention_mask` need to have the same length as other (sequential) inputs.
													__UpperCAmelCase			:							int	    =	len(encoded_inputs['''global_attention_mask''']) != len(lowercase__)

													if needs_to_be_padded:
																			__UpperCAmelCase			:							Dict	    =	len(lowercase__) - len(encoded_inputs['''global_attention_mask'''])

																			if self.padding_side == "right":
																									# Use `-1` since `0` in `global_attention_mask` means `local attention` instead of `not to attend`
																									__UpperCAmelCase			:							Optional[Any]	    =	(
																									    encoded_inputs['''global_attention_mask'''] + [-1] * difference
																									)
																			elif self.padding_side == "left":
																									__UpperCAmelCase			:							int	    =	[-1] * difference + encoded_inputs[
																									    '''global_attention_mask'''
																									]
																			else:
																									raise ValueError('''Invalid padding strategy:''' + str(self.padding_side))

							return encoded_inputs

