






from collections import defaultdict
from typing import Optional

from ..image_utils import load_image
from ..utils import (
    add_end_docstrings,
    is_torch_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_torch_available():
							import torch

							from ..models.auto.modeling_auto import MODEL_FOR_MASK_GENERATION_MAPPING

A__      :     List[Any]       =					logging.get_logger(__name__)
@add_end_docstrings(A__      )
class  _UpperCAmelCase   (			A__      ):

				"""simple docstring"""




				def __init__(	self		:       str,    **lowerCamelCase		:       Tuple    ):

								'''simple docstring'''
								super().__init__(**lowerCamelCase    )
								requires_backends(self,    '''vision'''    )
								requires_backends(self,    '''torch'''    )

								if self.framework != "pt":
												raise ValueError(F"""The {self.__class__} is only available in PyTorch."""    )

								self.check_model_type(lowerCamelCase    )




				def 							lowercase__  (	self		:       int,    **lowerCamelCase		:       Any    ):

								'''simple docstring'''
								lowercase__  					=     {}
								lowercase__  					=     {}
								lowercase__  					=     {}
								# preprocess args
								if "points_per_batch" in kwargs:
												lowercase__  					=     kwargs['''points_per_batch''']
								if "points_per_crop" in kwargs:
												lowercase__  					=     kwargs['''points_per_crop''']
								if "crops_n_layers" in kwargs:
												lowercase__  					=     kwargs['''crops_n_layers''']
								if "crop_overlap_ratio" in kwargs:
												lowercase__  					=     kwargs['''crop_overlap_ratio''']
								if "crop_n_points_downscale_factor" in kwargs:
												lowercase__  					=     kwargs['''crop_n_points_downscale_factor''']
								# postprocess args
								if "pred_iou_thresh" in kwargs:
												lowercase__  					=     kwargs['''pred_iou_thresh''']
								if "stability_score_offset" in kwargs:
												lowercase__  					=     kwargs['''stability_score_offset''']
								if "mask_threshold" in kwargs:
												lowercase__  					=     kwargs['''mask_threshold''']
								if "stability_score_thresh" in kwargs:
												lowercase__  					=     kwargs['''stability_score_thresh''']
								if "crops_nms_thresh" in kwargs:
												lowercase__  					=     kwargs['''crops_nms_thresh''']
								if "output_rle_mask" in kwargs:
												lowercase__  					=     kwargs['''output_rle_mask''']
								if "output_bboxes_mask" in kwargs:
												lowercase__  					=     kwargs['''output_bboxes_mask''']
								return preprocess_kwargs, forward_params, postprocess_kwargs




				def __call__(	self		:       Tuple,    lowerCamelCase		:       List[str],    *lowerCamelCase		:       Optional[Any],    lowerCamelCase		:       Optional[Any]=None,    lowerCamelCase		:       str=None,    **lowerCamelCase		:       Optional[Any]    ):

								'''simple docstring'''
								return super().__call__(lowerCamelCase,    *lowerCamelCase,    num_workers=lowerCamelCase,    batch_size=lowerCamelCase,    **lowerCamelCase    )




				def 							lowercase__  (	self		:       List[str],    lowerCamelCase		:       Optional[Any],    lowerCamelCase		:       Dict=64,    lowerCamelCase		:       int = 0,    lowerCamelCase		:       float = 512 / 1_500,    lowerCamelCase		:       Optional[int] = 32,    lowerCamelCase		:       Optional[int] = 1,    ):

								'''simple docstring'''
								lowercase__  					=     load_image(lowerCamelCase    )
								lowercase__  					=     self.image_processor.size['''longest_edge''']
								lowercase__					,		lowercase__					,		lowercase__					,		lowercase__  					=     self.image_processor.generate_crop_boxes(
								    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    lowerCamelCase    )
								lowercase__  					=     self.image_processor(images=lowerCamelCase,    return_tensors='''pt'''    )

								with self.device_placement():
												if self.framework == "pt":
																lowercase__  					=     self.get_inference_context()
																with inference_context():
																				lowercase__  					=     self._ensure_tensor_on_device(lowerCamelCase,    device=self.device    )
																				lowercase__  					=     self.model.get_image_embeddings(model_inputs.pop('''pixel_values'''    )    )
																				lowercase__  					=     image_embeddings

								lowercase__  					=     grid_points.shape[1]
								lowercase__  					=     points_per_batch if points_per_batch is not None else n_points

								if points_per_batch <= 0:
												raise ValueError(
												    '''Cannot have points_per_batch<=0. Must be >=1 to returned batched outputs. '''
												    '''To return all points at once, set points_per_batch to None'''    )

								for i in range(0,    lowerCamelCase,    lowerCamelCase    ):
												lowercase__  					=     grid_points[:, i : i + points_per_batch, :, :]
												lowercase__  					=     input_labels[:, i : i + points_per_batch]
												lowercase__  					=     i == n_points - points_per_batch
												yield {
												    "input_points": batched_points,
												    "input_labels": labels,
												    "input_boxes": crop_boxes,
												    "is_last": is_last,
												    **model_inputs,
												}




				def 							lowercase__  (	self		:       Union[str, Any],    lowerCamelCase		:       Dict,    lowerCamelCase		:       List[str]=0.88,    lowerCamelCase		:       Optional[int]=0.95,    lowerCamelCase		:       Optional[int]=0,    lowerCamelCase		:       Any=1,    ):

								'''simple docstring'''
								lowercase__  					=     model_inputs.pop('''input_boxes'''    )
								lowercase__  					=     model_inputs.pop('''is_last'''    )
								lowercase__  					=     model_inputs.pop('''original_sizes'''    ).tolist()
								lowercase__  					=     model_inputs.pop('''reshaped_input_sizes'''    ).tolist()

								lowercase__  					=     self.model(**lowerCamelCase    )

								# post processing happens here in order to avoid CPU GPU copies of ALL the masks
								lowercase__  					=     model_outputs['''pred_masks''']
								lowercase__  					=     self.image_processor.post_process_masks(
								    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    binarize=lowerCamelCase    )
								lowercase__  					=     model_outputs['''iou_scores''']
								lowercase__					,		lowercase__					,		lowercase__  					=     self.image_processor.filter_masks(
								    masks[0],    iou_scores[0],    original_sizes[0],    input_boxes[0],    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    )
								return {
								    "masks": masks,
								    "is_last": is_last,
								    "boxes": boxes,
								    "iou_scores": iou_scores,
								}




				def 							lowercase__  (	self		:       List[Any],    lowerCamelCase		:       List[str],    lowerCamelCase		:       List[Any]=False,    lowerCamelCase		:       Union[str, Any]=False,    lowerCamelCase		:       List[str]=0.7,    ):

								'''simple docstring'''
								lowercase__  					=     []
								lowercase__  					=     []
								lowercase__  					=     []
								for model_output in model_outputs:
												all_scores.append(model_output.pop('''iou_scores'''    )    )
												all_masks.extend(model_output.pop('''masks'''    )    )
												all_boxes.append(model_output.pop('''boxes'''    )    )

								lowercase__  					=     torch.cat(lowerCamelCase    )
								lowercase__  					=     torch.cat(lowerCamelCase    )
								lowercase__					,		lowercase__					,		lowercase__					,		lowercase__  					=     self.image_processor.post_process_for_mask_generation(
								    lowerCamelCase,    lowerCamelCase,    lowerCamelCase,    lowerCamelCase    )

								lowercase__  					=     defaultdict(lowerCamelCase    )
								for output in model_outputs:
												for k, v in output.items():
																extra[k].append(lowerCamelCase    )

								lowercase__  					=     {}
								if output_rle_mask:
												lowercase__  					=     rle_mask

								if output_bboxes_mask:
												lowercase__  					=     bounding_boxes

								return {"masks": output_masks, "scores": iou_scores, **optional, **extra}












import collections
import json
import os
import re
from typing import TYPE_CHECKING, List, Optional, Tuple

import numpy as np

from ...tokenization_utils_fast import PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
							from transformers.pipelines.conversational import Conversation


A__      :     Any       =					logging.get_logger(__name__)

A__      :     Tuple       =					{'vocab_file': 'vocab.txt', 'emoji_file': 'emoji.json'}

A__      :     str       =					{
    'vocab_file': {
        'abeja/gpt-neox-japanese-2.7b': 'https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/vocab.txt',
    },
    'emoji_file': {
        'abeja/gpt-neox-japanese-2.7b': 'https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/emoji.json',
    },
}

A__      :     List[Any]       =					{
    'abeja/gpt-neox-japanese-2.7b': 20_48,
}






def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				with open(lowerCamelCase_						,  '''r'''						,  encoding='''utf-8'''							) as f:
								lowercase__  					=     json.loads(f.read()							)

				lowercase__  					=     collections.OrderedDict()
				lowercase__  					=     collections.OrderedDict()
				lowercase__  					=     collections.OrderedDict()
				with open(lowerCamelCase_						,  '''r'''						,  encoding='''utf-8'''							) as f:
								lowercase__  					=     f.readlines()
				lowercase__  					=     [[t.rstrip('''\n'''							)] if (t == ''',''' or ''',''' not in t) else t.rstrip('''\n'''							).split(''','''							) for t in token]
				for idx, b in enumerate(lowerCamelCase_							):
								lowercase__  					=     b
								lowercase__  					=     idx
								for wd in b:
												lowercase__  					=     idx

				return vocab, raw_vocab, ids_to_tokens, emoji
class  _UpperCAmelCase   (			A__      ):

				"""simple docstring"""




				lowercase__											=			VOCAB_FILES_NAMES
				lowercase__											=			PRETRAINED_VOCAB_FILES_MAP
				lowercase__											=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				lowercase__											=			["""input_ids""", """attention_mask"""]




				def __init__(	self		:       Any,    lowerCamelCase		:       int,    lowerCamelCase		:       Optional[int],    lowerCamelCase		:       Optional[int]="<|endoftext|>",    lowerCamelCase		:       str="<|endoftext|>",    lowerCamelCase		:       str="<|startoftext|>",    lowerCamelCase		:       Tuple="<|endoftext|>",    lowerCamelCase		:       str=False,    **lowerCamelCase		:       List[str],    ):

								'''simple docstring'''
								super().__init__(
								    unk_token=lowerCamelCase,    pad_token=lowerCamelCase,    bos_token=lowerCamelCase,    eos_token=lowerCamelCase,    do_clean_text=lowerCamelCase,    **lowerCamelCase,    )
								if not os.path.isfile(lowerCamelCase    ):
												raise ValueError(
												    F"""Can't find a vocabulary file at path '{vocab_file}'. To load the vocabulary from a Google pretrained"""
												    ''' model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`'''    )
								if not os.path.isfile(lowerCamelCase    ):
												raise ValueError(
												    F"""Can't find a emoji file at path '{emoji_file}'. To load the emoji information from a Google"""
												    ''' pretrained model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`'''    )
								lowercase__  					=     do_clean_text
								lowercase__					,		lowercase__					,		lowercase__					,		lowercase__  					=     load_vocab_and_emoji(lowerCamelCase,    lowerCamelCase    )
								lowercase__  					=     SubWordJapaneseTokenizer(
								    vocab=self.vocab,    ids_to_tokens=self.ids_to_tokens,    emoji=self.emoji    )




				@property
				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								# self.vocab contains support for character fluctuation unique to Japanese, and has a large number of vocab
								return len(self.raw_vocab    )




				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								return dict(self.raw_vocab,    **self.added_tokens_encoder    )




				def 							lowercase__  (	self		:       str,    lowerCamelCase		:       Any    ):

								'''simple docstring'''
								return self.subword_tokenizer.tokenize(lowerCamelCase,    clean=self.do_clean_text    )




				def 							lowercase__  (	self		:       List[Any],    lowerCamelCase		:       List[str]    ):

								'''simple docstring'''
								return self.vocab.get(lowerCamelCase,    self.vocab.get(self.unk_token    )    )




				def 							lowercase__  (	self		:       Dict,    lowerCamelCase		:       Any    ):

								'''simple docstring'''
								return self.subword_tokenizer.convert_id_to_token(lowerCamelCase    )




				def 							lowercase__  (	self		:       Dict,    lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     ''''''.join(lowerCamelCase    ).strip()
								return out_string




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       "Conversation"    ):

								'''simple docstring'''
								lowercase__  					=     []
								for is_user, text in conversation.iter_texts():
												input_ids.extend(self.encode(lowerCamelCase,    add_special_tokens=lowerCamelCase    ) + [self.eos_token_id]    )

								if len(lowerCamelCase    ) > self.model_max_length:
												lowercase__  					=     input_ids[-self.model_max_length :]
								return input_ids




				def 							lowercase__  (	self		:       List[Any],    lowerCamelCase		:       str,    lowerCamelCase		:       Optional[str] = None    ):

								'''simple docstring'''
								lowercase__  					=     0
								if os.path.isdir(lowerCamelCase    ):
												lowercase__  					=     os.path.join(
												    lowerCamelCase,    (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']    )
												lowercase__  					=     os.path.join(
												    lowerCamelCase,    (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''emoji_file''']    )
								else:
												lowercase__  					=     (
												    (filename_prefix + '''-''' if filename_prefix else '''''') + save_directory + VOCAB_FILES_NAMES['''vocab_file''']
												)
												lowercase__  					=     (
												    (filename_prefix + '''-''' if filename_prefix else '''''') + save_directory + VOCAB_FILES_NAMES['''emoji_file''']
												)
								with open(lowerCamelCase,    '''w''',    encoding='''utf-8'''    ) as writer:
												for token_index, token in self.ids_to_tokens.items():
																if index != token_index:
																				logger.warning(
																				    F"""Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."""
																				    ''' Please check that the vocabulary is not corrupted!'''    )
																				lowercase__  					=     token_index
																writer.write(''','''.join(lowerCamelCase    ) + '''\n'''    )
																index += 1
								with open(lowerCamelCase,    '''w''',    encoding='''utf-8'''    ) as writer:
												json.dump(self.emoji,    lowerCamelCase    )
								return vocab_file, emoji_file



class  _UpperCAmelCase   (			A__      ):

				"""simple docstring"""




				def __init__(	self		:       Union[str, Any],    lowerCamelCase		:       Optional[int],    lowerCamelCase		:       int,    lowerCamelCase		:       List[str]    ):

								'''simple docstring'''
								lowercase__  					=     vocab  # same as swe
								lowercase__  					=     ids_to_tokens  # same as bpe
								lowercase__  					=     emoji
								lowercase__  					=     np.max([len(lowerCamelCase    ) for w in self.vocab.keys()]    )
								lowercase__  					=     re.compile(R'''(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+$,%#]+)'''    )
								lowercase__  					=     re.compile(R'''[A-Za-z0-9\._+]*@[\-_0-9A-Za-z]+(\.[A-Za-z]+)*'''    )
								lowercase__  					=     re.compile(R'''[\(]{0,1}[0-9]{2,4}[\)\-\(]{0,1}[0-9]{2,4}[\)\-]{0,1}[0-9]{3,4}'''    )
								lowercase__  					=     re.compile(
								    R'''([12]\d{3}[/\-年])*(0?[1-9]|1[0-2])[/\-月]((0?[1-9]|[12][0-9]|3[01])日?)*(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*'''    )
								lowercase__  					=     re.compile(
								    R'''(明治|大正|昭和|平成|令和|㍾|㍽|㍼|㍻|\u32ff)\d{1,2}年(0?[1-9]|1[0-2])月(0?[1-9]|[12][0-9]|3[01])日(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*'''    )
								lowercase__  					=     re.compile(
								    R'''((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*億)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*万)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*千)*(0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*(千円|万円|千万円|円|千ドル|万ドル|千万ドル|ドル|千ユーロ|万ユーロ|千万ユーロ|ユーロ)+(\(税込\)|\(税抜\)|\+tax)*'''    )
								lowercase__  					=     '''─━│┃┄┅┆┇┈┉┊┋┌┍┎┏┐┑┒┓└┕┖┗┘┙┚┛├┝┞┟┠┡┢┣┤┥┦┧┨┩┪┫┬┭┮┯┰┱┲┳┴┵┶┷┸┹┺┻┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋╌╍╎╏═║╒╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡╢╣╤╥╦╧╨╩╪╫╬╭╮╯╰╱╲╳╴╵╶╷╸╹╺╻╼╽╾╿'''
								lowercase__  					=     '''▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟'''
								lowercase__  					=     str.maketrans({k: '''<BLOCK>''' for k in keisen + blocks}    )




				def __len__(	self		:       Optional[int]    ):

								'''simple docstring'''
								return len(self.ids_to_tokens    )




				def 							lowercase__  (	self		:       Union[str, Any],    lowerCamelCase		:       Dict    ):

								'''simple docstring'''
								lowercase__  					=     self.content_repattera.sub('''<URL>''',    lowerCamelCase    )
								lowercase__  					=     self.content_repattera.sub('''<EMAIL>''',    lowerCamelCase    )
								lowercase__  					=     self.content_repattera.sub('''<TEL>''',    lowerCamelCase    )
								lowercase__  					=     self.content_repattera.sub('''<DATE>''',    lowerCamelCase    )
								lowercase__  					=     self.content_repattera.sub('''<DATE>''',    lowerCamelCase    )
								lowercase__  					=     self.content_repattera.sub('''<PRICE>''',    lowerCamelCase    )
								lowercase__  					=     content.translate(self.content_transa    )
								while "<BLOCK><BLOCK>" in content:
												lowercase__  					=     content.replace('''<BLOCK><BLOCK>''',    '''<BLOCK>'''    )
								return content




				def 							lowercase__  (	self		:       Union[str, Any],    lowerCamelCase		:       List[Any],    lowerCamelCase		:       str=False    ):

								'''simple docstring'''
								lowercase__  					=     text.replace(''' ''',    '''<SP>'''    )
								lowercase__  					=     text.replace('''　''',    '''<SP>'''    )
								lowercase__  					=     text.replace('''\r\n''',    '''<BR>'''    )
								lowercase__  					=     text.replace('''\n''',    '''<BR>'''    )
								lowercase__  					=     text.replace('''\r''',    '''<BR>'''    )
								lowercase__  					=     text.replace('''\t''',    '''<TAB>'''    )
								lowercase__  					=     text.replace('''—''',    '''ー'''    )
								lowercase__  					=     text.replace('''−''',    '''ー'''    )
								for k, v in self.emoji["emoji"].items():
												if k in text:
																lowercase__  					=     text.replace(lowerCamelCase,    lowerCamelCase    )
								if clean:
												lowercase__  					=     self.clean_text(lowerCamelCase    )

								def check_simbol(lowerCamelCase		:       Any    ):
												lowercase__  					=     x.encode()
												if len(lowerCamelCase    ) == 1 and len(lowerCamelCase    ) == 2:
																lowercase__  					=     (int(e[0]    ) << 8) + int(e[1]    )
																if (
																    (c >= 0xC_2_A_1 and c <= 0xC_2_B_F)
																    or (c >= 0xC_7_8_0 and c <= 0xC_7_8_3)
																    or (c >= 0xC_A_B_9 and c <= 0xC_B_B_F)
																    or (c >= 0xC_C_8_0 and c <= 0xC_D_A_2)
																):
																				return True
												return False

								def checkuae(lowerCamelCase		:       Optional[Any]    ):
												lowercase__  					=     x.encode()
												if len(lowerCamelCase    ) == 1 and len(lowerCamelCase    ) == 3:
																lowercase__  					=     (int(e[0]    ) << 16) + (int(e[1]    ) << 8) + int(e[2]    )
																if c >= 0xE_2_8_0_8_0 and c <= 0xE_2_B_0_7_F:
																				return True
												return False

								lowercase__  					=     0
								lowercase__  					=     []
								while pos < len(lowerCamelCase    ):
												lowercase__  					=     min(len(lowerCamelCase    ),    pos + self.maxlen + 1    ) if text[pos] == '''<''' else pos + 3
												lowercase__  					=     []  # (token_id, token, pos)
												for e in range(lowerCamelCase,    lowerCamelCase,    -1    ):
																lowercase__  					=     text[pos:e]
																if wd in self.vocab:
																				if wd[0] == "<" and len(lowerCamelCase    ) > 2:
																								lowercase__  					=     [(self.vocab[wd], wd, e)]
																								break
																				else:
																								candidates.append((self.vocab[wd], wd, e)    )
												if len(lowerCamelCase    ) > 0:
																# the smallest token_id is adopted
																lowercase__					,		lowercase__					,		lowercase__  					=     sorted(lowerCamelCase,    key=lambda lowerCamelCase    : x[0]    )[0]
																result.append(lowerCamelCase    )
																lowercase__  					=     e
												else:
																lowercase__  					=     pos + 1
																lowercase__  					=     text[pos:end]
																if check_simbol(lowerCamelCase    ):
																				result.append('''<KIGOU>'''    )
																elif checkuae(lowerCamelCase    ):
																				result.append('''<U2000U2BFF>'''    )
																else:
																				for i in wd.encode('''utf-8'''    ):
																								result.append('''<|byte%d|>''' % i    )
																lowercase__  					=     end
								return result




				def 							lowercase__  (	self		:       Optional[Any],    lowerCamelCase		:       List[Any],    lowerCamelCase		:       Dict="\n"    ):

								'''simple docstring'''
								lowercase__  					=     []
								lowercase__  					=     []
								lowercase__  					=     self.ids_to_tokens[index][0]
								if word[:6] == "<|byte" and word[-2:] == "|>":
												byte_tokens.append(int(word[6:-2]    )    )
								else:
												if len(lowerCamelCase    ) > 0:
																words.append(bytearray(lowerCamelCase    ).decode('''utf-8''',    errors='''replace'''    )    )
																lowercase__  					=     []
												if word[:7] == "<|emoji" and word[-2:] == "|>":
																words.append(self.emoji['''emoji_inv'''][word]    )
												elif word == "<SP>":
																words.append(''' '''    )
												elif word == "<BR>":
																words.append(lowerCamelCase    )
												elif word == "<TAB>":
																words.append('''\t'''    )
												elif word == "<BLOCK>":
																words.append('''▀'''    )
												elif word == "<KIGOU>":
																words.append('''ǀ'''    )
												elif word == "<U2000U2BFF>":
																words.append('''‖'''    )
												else:
																words.append(lowerCamelCase    )
								if len(lowerCamelCase    ) > 0:
												words.append(bytearray(lowerCamelCase    ).decode('''utf-8''',    errors='''replace'''    )    )
								lowercase__  					=     ''''''.join(lowerCamelCase    )
								return text




