





import json
import os
import unittest

from transformers import DebertaTokenizer, DebertaTokenizerFast
from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin






class 					__A    (    lowerCAmelCase			,				unittest.TestCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						DebertaTokenizer
			lowerCAmelCase_							     =						True
			lowerCAmelCase_							     =						DebertaTokenizerFast





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				super().setUp()

				# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
				lowerCamelCase__								=		[
				    '''l''',
				    '''o''',
				    '''w''',
				    '''e''',
				    '''r''',
				    '''s''',
				    '''t''',
				    '''i''',
				    '''d''',
				    '''n''',
				    '''\u0120''',
				    '''\u0120l''',
				    '''\u0120n''',
				    '''\u0120lo''',
				    '''\u0120low''',
				    '''er''',
				    '''\u0120lowest''',
				    '''\u0120newer''',
				    '''\u0120wider''',
				    '''[UNK]''',
				]
				lowerCamelCase__								=		dict(zip(__lowerCAmelCase       ,  range(len(__lowerCAmelCase							)							)							)							)
				lowerCamelCase__								=		['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
				lowerCamelCase__								=		{'''unk_token''': '''[UNK]'''}

				lowerCamelCase__								=		os.path.join(self.tmpdirname       ,  VOCAB_FILES_NAMES['''vocab_file''']							)
				lowerCamelCase__								=		os.path.join(self.tmpdirname       ,  VOCAB_FILES_NAMES['''merges_file''']							)
				with open(self.vocab_file       ,  '''w'''       ,  encoding='''utf-8'''							) as fp:
					fp.write(json.dumps(__lowerCAmelCase							) + '''\n'''							)
				with open(self.merges_file       ,  '''w'''       ,  encoding='''utf-8'''							) as fp:
					fp.write('''\n'''.join(__lowerCAmelCase							)							)





			def 		__lowerCamelCase				(    self       ,  **__lowerCAmelCase							):



				'''simple docstring'''







				kwargs.update(self.special_tokens_map							)
				return self.tokenizer_class.from_pretrained(self.tmpdirname       ,  **__lowerCAmelCase							)





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__								=		'''lower newer'''
				lowerCamelCase__								=		'''lower newer'''
				return input_text, output_text





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.get_tokenizer()
				lowerCamelCase__								=		'''lower newer'''
				lowerCamelCase__								=		['''l''', '''o''', '''w''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er''']
				lowerCamelCase__								=		tokenizer.tokenize(__lowerCAmelCase							)
				self.assertListEqual(__lowerCAmelCase       ,  __lowerCAmelCase							)

				lowerCamelCase__								=		tokens + [tokenizer.unk_token]
				lowerCamelCase__								=		[0, 1, 2, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
				self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCAmelCase							)       ,  __lowerCAmelCase							)





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.get_tokenizer()
				lowerCamelCase__								=		tokenizer('''Hello'''       ,  '''World'''							)
				lowerCamelCase__								=		[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
				self.assertListEqual(tokd['''token_type_ids''']       ,  __lowerCAmelCase							)





			@slow
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.tokenizer_class.from_pretrained('''microsoft/deberta-base'''							)

				lowerCamelCase__								=		tokenizer.encode('''sequence builders'''       ,  add_special_tokens=__lowerCAmelCase							)
				lowerCamelCase__								=		tokenizer.encode('''multi-sequence build'''       ,  add_special_tokens=__lowerCAmelCase							)

				lowerCamelCase__								=		tokenizer.encode(
				    '''sequence builders'''       ,  add_special_tokens=__lowerCAmelCase       ,  add_prefix_space=__lowerCAmelCase							)
				lowerCamelCase__								=		tokenizer.encode(
				    '''sequence builders'''       ,  '''multi-sequence build'''       ,  add_special_tokens=__lowerCAmelCase       ,  add_prefix_space=__lowerCAmelCase							)

				lowerCamelCase__								=		tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase							)
				lowerCamelCase__								=		tokenizer.build_inputs_with_special_tokens(__lowerCAmelCase       ,  __lowerCAmelCase							)

				assert encoded_sentence == encoded_text_from_decode
				assert encoded_pair == encoded_pair_from_decode





			@slow
			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		[self.tokenizer_class]
				if self.test_rust_tokenizer:
					tokenizer_classes.append(self.rust_tokenizer_class							)

				for tokenizer_class in tokenizer_classes:
					lowerCamelCase__								=		tokenizer_class.from_pretrained('''microsoft/deberta-base'''							)

					lowerCamelCase__								=		[
					    '''ALBERT: A Lite BERT for Self-supervised Learning of Language Representations''',
					    '''ALBERT incorporates two parameter reduction techniques''',
					    '''The first one is a factorized embedding parameterization. By decomposing the large vocabulary'''
					    ''' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'''
					    ''' vocabulary embedding.''',
					]

					lowerCamelCase__								=		tokenizer(__lowerCAmelCase       ,  padding=__lowerCAmelCase							)
					lowerCamelCase__								=		[tokenizer.decode(__lowerCAmelCase       ,  skip_special_tokens=__lowerCAmelCase							) for seq in encoding['''input_ids''']]

					# fmt: off
					lowerCamelCase__								=		{
					    '''input_ids''': [
					        [1, 2_1_1_8, 1_1_1_2_6, 5_6_5, 3_5, 8_3, 2_5_1_9_1, 1_6_3, 1_8_8_5_4, 1_3, 1_2_1_5_6, 1_2, 1_6_1_0_1, 2_5_3_7_6, 1_3_8_0_7, 9, 2_2_2_0_5, 2_7_8_9_3, 1_6_3_5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
					        [1, 2_1_1_8, 1_1_1_2_6, 5_6_5, 2_4_5_3_6, 8_0, 4_3_7_9_7, 4_8_7_8, 7_3_7_3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
					        [1, 1_3_3, 7_8, 6_5, 1_6, 1_0, 3_7_2_4, 1_5_3_8, 3_3_1_8_3, 1_1_3_0_3, 4_3_7_9_7, 1_9_3_8, 4, 8_7_0, 2_4_1_6_5, 2_9_1_0_5, 5, 7_3_9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 3_6_1_7_3, 8_8, 8_0, 6_5_0, 7_8_2_1, 4_5_9_4_0, 6, 5_2, 2_5_5_9, 5, 1_8_3_6, 9, 5, 7_3_9_7, 1_3_1_7_1, 3_1, 5, 1_8_3_6, 9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 4, 2]
					    ],
					    '''token_type_ids''': [
					        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
					        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
					        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
					    ],
					    '''attention_mask''': [
					        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
					        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
					        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
					    ]
					}
					# fmt: on

					lowerCamelCase__								=		[
					    '''ALBERT: A Lite BERT for Self-supervised Learning of Language Representations''',
					    '''ALBERT incorporates two parameter reduction techniques''',
					    '''The first one is a factorized embedding parameterization. By decomposing the large vocabulary'''
					    ''' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'''
					    ''' vocabulary embedding.''',
					]

					self.assertDictEqual(encoding.data       ,  __lowerCAmelCase							)

					for expected, decoded in zip(__lowerCAmelCase       ,  __lowerCAmelCase							):
						self.assertEqual(__lowerCAmelCase       ,  __lowerCAmelCase							)










from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)






@flax.struct.dataclass
class 					__A    (    lowerCAmelCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						42
			lowerCAmelCase_							     =						42






class 					__A    (    nn.Module ):

			'''simple docstring'''







			lowerCAmelCase_							     =						42
			lowerCAmelCase_							     =						(16, 32, 96, 256)
			lowerCAmelCase_							     =						jnp.floataa





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		nn.Conv(
				    self.block_out_channels[0]       ,  kernel_size=(3, 3)       ,  padding=((1, 1), (1, 1))       ,  dtype=self.dtype       ,  )

				lowerCamelCase__								=		[]
				for i in range(len(self.block_out_channels							) - 1							):
					lowerCamelCase__								=		self.block_out_channels[i]
					lowerCamelCase__								=		self.block_out_channels[i + 1]
					lowerCamelCase__								=		nn.Conv(
					    __lowerCAmelCase       ,  kernel_size=(3, 3)       ,  padding=((1, 1), (1, 1))       ,  dtype=self.dtype       ,  )
					blocks.append(__lowerCAmelCase							)
					lowerCamelCase__								=		nn.Conv(
					    __lowerCAmelCase       ,  kernel_size=(3, 3)       ,  strides=(2, 2)       ,  padding=((1, 1), (1, 1))       ,  dtype=self.dtype       ,  )
					blocks.append(__lowerCAmelCase							)
				lowerCamelCase__								=		blocks

				lowerCamelCase__								=		nn.Conv(
				    self.conditioning_embedding_channels       ,  kernel_size=(3, 3)       ,  padding=((1, 1), (1, 1))       ,  kernel_init=nn.initializers.zeros_init()       ,  bias_init=nn.initializers.zeros_init()       ,  dtype=self.dtype       ,  )





			def __call__(    self       ,  __lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__								=		self.conv_in(__lowerCAmelCase							)
				lowerCamelCase__								=		nn.silu(__lowerCAmelCase							)

				for block in self.blocks:
					lowerCamelCase__								=		block(__lowerCAmelCase							)
					lowerCamelCase__								=		nn.silu(__lowerCAmelCase							)

				lowerCamelCase__								=		self.conv_out(__lowerCAmelCase							)

				return embedding






@flax_register_to_config
class 					__A    (    nn.Module			,				lowerCAmelCase			,				lowerCAmelCase ):

			'''simple docstring'''







			lowerCAmelCase_							     =						32
			lowerCAmelCase_							     =						4
			lowerCAmelCase_							     =						(
			    "CrossAttnDownBlock2D",
			    "CrossAttnDownBlock2D",
			    "CrossAttnDownBlock2D",
			    "DownBlock2D",
			)
			lowerCAmelCase_							     =						False
			lowerCAmelCase_							     =						(320, 640, 1280, 1280)
			lowerCAmelCase_							     =						2
			lowerCAmelCase_							     =						8
			lowerCAmelCase_							     =						None
			lowerCAmelCase_							     =						1280
			lowerCAmelCase_							     =						0.0
			lowerCAmelCase_							     =						False
			lowerCAmelCase_							     =						jnp.floataa
			lowerCAmelCase_							     =						True
			lowerCAmelCase_							     =						0
			lowerCAmelCase_							     =						"rgb"
			lowerCAmelCase_							     =						(16, 32, 96, 256)





			def 		__lowerCamelCase				(    self       ,  __lowerCAmelCase							):



				'''simple docstring'''







				lowerCamelCase__								=		(1, self.in_channels, self.sample_size, self.sample_size)
				lowerCamelCase__								=		jnp.zeros(__lowerCAmelCase       ,  dtype=jnp.floataa							)
				lowerCamelCase__								=		jnp.ones((1,)       ,  dtype=jnp.intaa							)
				lowerCamelCase__								=		jnp.zeros((1, 1, self.cross_attention_dim)       ,  dtype=jnp.floataa							)
				lowerCamelCase__								=		(1, 3, self.sample_size * 8, self.sample_size * 8)
				lowerCamelCase__								=		jnp.zeros(__lowerCAmelCase       ,  dtype=jnp.floataa							)

				lowerCamelCase__				,	lowerCamelCase__								=		jax.random.split(__lowerCAmelCase							)
				lowerCamelCase__								=		{'''params''': params_rng, '''dropout''': dropout_rng}

				return self.init(__lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase							)["params"]





			def 		__lowerCamelCase				(    self							):



				'''simple docstring'''







				lowerCamelCase__								=		self.block_out_channels
				lowerCamelCase__								=		block_out_channels[0] * 4

				# If `num_attention_heads` is not defined (which is the case for most models)
				# it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
				# The reason for this behavior is to correct for incorrectly named variables that were introduced
				# when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
				# Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
				# which is why we correct for the naming here.
				lowerCamelCase__								=		self.num_attention_heads or self.attention_head_dim

				# input
				lowerCamelCase__								=		nn.Conv(
				    block_out_channels[0]       ,  kernel_size=(3, 3)       ,  strides=(1, 1)       ,  padding=((1, 1), (1, 1))       ,  dtype=self.dtype       ,  )

				# time
				lowerCamelCase__								=		FlaxTimesteps(
				    block_out_channels[0]       ,  flip_sin_to_cos=self.flip_sin_to_cos       ,  freq_shift=self.config.freq_shift							)
				lowerCamelCase__								=		FlaxTimestepEmbedding(__lowerCAmelCase       ,  dtype=self.dtype							)

				lowerCamelCase__								=		FlaxControlNetConditioningEmbedding(
				    conditioning_embedding_channels=block_out_channels[0]       ,  block_out_channels=self.conditioning_embedding_out_channels       ,  )

				lowerCamelCase__								=		self.only_cross_attention
				if isinstance(__lowerCAmelCase       ,  __lowerCAmelCase							):
					lowerCamelCase__								=		(only_cross_attention,) * len(self.down_block_types							)

				if isinstance(__lowerCAmelCase       ,  __lowerCAmelCase							):
					lowerCamelCase__								=		(num_attention_heads,) * len(self.down_block_types							)

				# down
				lowerCamelCase__								=		[]
				lowerCamelCase__								=		[]

				lowerCamelCase__								=		block_out_channels[0]

				lowerCamelCase__								=		nn.Conv(
				    __lowerCAmelCase       ,  kernel_size=(1, 1)       ,  padding='''VALID'''       ,  kernel_init=nn.initializers.zeros_init()       ,  bias_init=nn.initializers.zeros_init()       ,  dtype=self.dtype       ,  )
				controlnet_down_blocks.append(__lowerCAmelCase							)

				for i, down_block_type in enumerate(self.down_block_types							):
					lowerCamelCase__								=		output_channel
					lowerCamelCase__								=		block_out_channels[i]
					lowerCamelCase__								=		i == len(__lowerCAmelCase							) - 1

					if down_block_type == "CrossAttnDownBlock2D":
						lowerCamelCase__								=		FlaxCrossAttnDownBlockaD(
						    in_channels=__lowerCAmelCase       ,  out_channels=__lowerCAmelCase       ,  dropout=self.dropout       ,  num_layers=self.layers_per_block       ,  num_attention_heads=num_attention_heads[i]       ,  add_downsample=not is_final_block       ,  use_linear_projection=self.use_linear_projection       ,  only_cross_attention=only_cross_attention[i]       ,  dtype=self.dtype       ,  )
					else:
						lowerCamelCase__								=		FlaxDownBlockaD(
						    in_channels=__lowerCAmelCase       ,  out_channels=__lowerCAmelCase       ,  dropout=self.dropout       ,  num_layers=self.layers_per_block       ,  add_downsample=not is_final_block       ,  dtype=self.dtype       ,  )

					down_blocks.append(__lowerCAmelCase							)

					for _ in range(self.layers_per_block							):
						lowerCamelCase__								=		nn.Conv(
						    __lowerCAmelCase       ,  kernel_size=(1, 1)       ,  padding='''VALID'''       ,  kernel_init=nn.initializers.zeros_init()       ,  bias_init=nn.initializers.zeros_init()       ,  dtype=self.dtype       ,  )
						controlnet_down_blocks.append(__lowerCAmelCase							)

					if not is_final_block:
						lowerCamelCase__								=		nn.Conv(
						    __lowerCAmelCase       ,  kernel_size=(1, 1)       ,  padding='''VALID'''       ,  kernel_init=nn.initializers.zeros_init()       ,  bias_init=nn.initializers.zeros_init()       ,  dtype=self.dtype       ,  )
						controlnet_down_blocks.append(__lowerCAmelCase							)

				lowerCamelCase__								=		down_blocks
				lowerCamelCase__								=		controlnet_down_blocks

				# mid
				lowerCamelCase__								=		block_out_channels[-1]
				lowerCamelCase__								=		FlaxUNetMidBlockaDCrossAttn(
				    in_channels=__lowerCAmelCase       ,  dropout=self.dropout       ,  num_attention_heads=num_attention_heads[-1]       ,  use_linear_projection=self.use_linear_projection       ,  dtype=self.dtype       ,  )

				lowerCamelCase__								=		nn.Conv(
				    __lowerCAmelCase       ,  kernel_size=(1, 1)       ,  padding='''VALID'''       ,  kernel_init=nn.initializers.zeros_init()       ,  bias_init=nn.initializers.zeros_init()       ,  dtype=self.dtype       ,  )





			def __call__(    self       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase = 1.0       ,  __lowerCAmelCase = True       ,  __lowerCAmelCase = False       ,  ):



				'''simple docstring'''







				lowerCamelCase__								=		self.controlnet_conditioning_channel_order
				if channel_order == "bgr":
					lowerCamelCase__								=		jnp.flip(__lowerCAmelCase       ,  axis=1							)

				# 1. time
				if not isinstance(__lowerCAmelCase       ,  jnp.ndarray							):
					lowerCamelCase__								=		jnp.array([timesteps]       ,  dtype=jnp.intaa							)
				elif isinstance(__lowerCAmelCase       ,  jnp.ndarray							) and len(timesteps.shape							) == 0:
					lowerCamelCase__								=		timesteps.astype(dtype=jnp.floataa							)
					lowerCamelCase__								=		jnp.expand_dims(__lowerCAmelCase       ,  0							)

				lowerCamelCase__								=		self.time_proj(__lowerCAmelCase							)
				lowerCamelCase__								=		self.time_embedding(__lowerCAmelCase							)

				# 2. pre-process
				lowerCamelCase__								=		jnp.transpose(__lowerCAmelCase       ,  (0, 2, 3, 1)							)
				lowerCamelCase__								=		self.conv_in(__lowerCAmelCase							)

				lowerCamelCase__								=		jnp.transpose(__lowerCAmelCase       ,  (0, 2, 3, 1)							)
				lowerCamelCase__								=		self.controlnet_cond_embedding(__lowerCAmelCase							)
				sample += controlnet_cond

				# 3. down
				lowerCamelCase__								=		(sample,)
				for down_block in self.down_blocks:
					if isinstance(__lowerCAmelCase       ,  __lowerCAmelCase							):
						lowerCamelCase__				,	lowerCamelCase__								=		down_block(__lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  deterministic=not train							)
					else:
						lowerCamelCase__				,	lowerCamelCase__								=		down_block(__lowerCAmelCase       ,  __lowerCAmelCase       ,  deterministic=not train							)
					down_block_res_samples += res_samples

				# 4. mid
				lowerCamelCase__								=		self.mid_block(__lowerCAmelCase       ,  __lowerCAmelCase       ,  __lowerCAmelCase       ,  deterministic=not train							)

				# 5. contronet blocks
				lowerCamelCase__								=		()
				for down_block_res_sample, controlnet_block in zip(__lowerCAmelCase       ,  self.controlnet_down_blocks							):
					lowerCamelCase__								=		controlnet_block(__lowerCAmelCase							)
					controlnet_down_block_res_samples += (down_block_res_sample,)

				lowerCamelCase__								=		controlnet_down_block_res_samples

				lowerCamelCase__								=		self.controlnet_mid_block(__lowerCAmelCase							)

				# 6. scaling
				lowerCamelCase__								=		[sample * conditioning_scale for sample in down_block_res_samples]
				mid_block_res_sample *= conditioning_scale

				if not return_dict:
					return (down_block_res_samples, mid_block_res_sample)

				return FlaxControlNetOutput(
				    down_block_res_samples=__lowerCAmelCase       ,  mid_block_res_sample=__lowerCAmelCase							)



