

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_url
from PIL import Image

from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
lowerCAmelCase_       	=	logging.get_logger(__name__)


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						snake_case_   =	DPTConfig()

						if "large" in checkpoint_url:
												snake_case_   =	1024
												snake_case_   =	4096
												snake_case_   =	24
												snake_case_   =	16
												snake_case_   =	[5, 11, 17, 23]
												snake_case_   =	[256, 512, 1024, 1024]
												snake_case_   =	(1, 384, 384)

						if "ade" in checkpoint_url:
												snake_case_   =	True

												snake_case_   =	150
												snake_case_   =	'''huggingface/label-files'''
												snake_case_   =	'''ade20k-id2label.json'''
												snake_case_   =	json.load(open(cached_download(hf_hub_url(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		repo_type='''dataset'''       )       )  ,		'''r'''       )       )
												snake_case_   =	{int(SCREAMING_SNAKE_CASE__       ): v for k, v in idalabel.items()}
												snake_case_   =	idalabel
												snake_case_   =	{v: k for k, v in idalabel.items()}
												snake_case_   =	[1, 150, 480, 480]

						return config, expected_shape


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						snake_case_   =	['''pretrained.model.head.weight''', '''pretrained.model.head.bias''']
						for k in ignore_keys:
												state_dict.pop(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						if (
						    "pretrained.model" in name
						    and "cls_token" not in name
						    and "pos_embed" not in name
						    and "patch_embed" not in name
						):
												snake_case_   =	name.replace('''pretrained.model'''  ,		'''dpt.encoder'''       )
						if "pretrained.model" in name:
												snake_case_   =	name.replace('''pretrained.model'''  ,		'''dpt.embeddings'''       )
						if "patch_embed" in name:
												snake_case_   =	name.replace('''patch_embed'''  ,		'''patch_embeddings'''       )
						if "pos_embed" in name:
												snake_case_   =	name.replace('''pos_embed'''  ,		'''position_embeddings'''       )
						if "attn.proj" in name:
												snake_case_   =	name.replace('''attn.proj'''  ,		'''attention.output.dense'''       )
						if "proj" in name and "project" not in name:
												snake_case_   =	name.replace('''proj'''  ,		'''projection'''       )
						if "blocks" in name:
												snake_case_   =	name.replace('''blocks'''  ,		'''layer'''       )
						if "mlp.fc1" in name:
												snake_case_   =	name.replace('''mlp.fc1'''  ,		'''intermediate.dense'''       )
						if "mlp.fc2" in name:
												snake_case_   =	name.replace('''mlp.fc2'''  ,		'''output.dense'''       )
						if "norm1" in name:
												snake_case_   =	name.replace('''norm1'''  ,		'''layernorm_before'''       )
						if "norm2" in name:
												snake_case_   =	name.replace('''norm2'''  ,		'''layernorm_after'''       )
						if "scratch.output_conv" in name:
												snake_case_   =	name.replace('''scratch.output_conv'''  ,		'''head'''       )
						if "scratch" in name:
												snake_case_   =	name.replace('''scratch'''  ,		'''neck'''       )
						if "layer1_rn" in name:
												snake_case_   =	name.replace('''layer1_rn'''  ,		'''convs.0'''       )
						if "layer2_rn" in name:
												snake_case_   =	name.replace('''layer2_rn'''  ,		'''convs.1'''       )
						if "layer3_rn" in name:
												snake_case_   =	name.replace('''layer3_rn'''  ,		'''convs.2'''       )
						if "layer4_rn" in name:
												snake_case_   =	name.replace('''layer4_rn'''  ,		'''convs.3'''       )
						if "refinenet" in name:
												snake_case_   =	int(name[len('''neck.refinenet'''       ) : len('''neck.refinenet'''       ) + 1]       )
												# tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3
												snake_case_   =	name.replace(F'''refinenet{layer_idx}'''  ,		F'''fusion_stage.layers.{abs(layer_idx-4       )}'''       )
						if "out_conv" in name:
												snake_case_   =	name.replace('''out_conv'''  ,		'''projection'''       )
						if "resConfUnit1" in name:
												snake_case_   =	name.replace('''resConfUnit1'''  ,		'''residual_layer1'''       )
						if "resConfUnit2" in name:
												snake_case_   =	name.replace('''resConfUnit2'''  ,		'''residual_layer2'''       )
						if "conv1" in name:
												snake_case_   =	name.replace('''conv1'''  ,		'''convolution1'''       )
						if "conv2" in name:
												snake_case_   =	name.replace('''conv2'''  ,		'''convolution2'''       )
						# readout blocks
						if "pretrained.act_postprocess1.0.project.0" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess1.0.project.0'''  ,		'''neck.reassemble_stage.readout_projects.0.0'''       )
						if "pretrained.act_postprocess2.0.project.0" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess2.0.project.0'''  ,		'''neck.reassemble_stage.readout_projects.1.0'''       )
						if "pretrained.act_postprocess3.0.project.0" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess3.0.project.0'''  ,		'''neck.reassemble_stage.readout_projects.2.0'''       )
						if "pretrained.act_postprocess4.0.project.0" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess4.0.project.0'''  ,		'''neck.reassemble_stage.readout_projects.3.0'''       )
						# resize blocks
						if "pretrained.act_postprocess1.3" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess1.3'''  ,		'''neck.reassemble_stage.layers.0.projection'''       )
						if "pretrained.act_postprocess1.4" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess1.4'''  ,		'''neck.reassemble_stage.layers.0.resize'''       )
						if "pretrained.act_postprocess2.3" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess2.3'''  ,		'''neck.reassemble_stage.layers.1.projection'''       )
						if "pretrained.act_postprocess2.4" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess2.4'''  ,		'''neck.reassemble_stage.layers.1.resize'''       )
						if "pretrained.act_postprocess3.3" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess3.3'''  ,		'''neck.reassemble_stage.layers.2.projection'''       )
						if "pretrained.act_postprocess4.3" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess4.3'''  ,		'''neck.reassemble_stage.layers.3.projection'''       )
						if "pretrained.act_postprocess4.4" in name:
												snake_case_   =	name.replace('''pretrained.act_postprocess4.4'''  ,		'''neck.reassemble_stage.layers.3.resize'''       )
						if "pretrained" in name:
												snake_case_   =	name.replace('''pretrained'''  ,		'''dpt'''       )
						if "bn" in name:
												snake_case_   =	name.replace('''bn'''  ,		'''batch_norm'''       )
						if "head" in name:
												snake_case_   =	name.replace('''head'''  ,		'''head.head'''       )
						if "encoder.norm" in name:
												snake_case_   =	name.replace('''encoder.norm'''  ,		'''layernorm'''       )
						if "auxlayer" in name:
												snake_case_   =	name.replace('''auxlayer'''  ,		'''auxiliary_head.head'''       )

						return name


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
						for i in range(config.num_hidden_layers       ):
												# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
												snake_case_   =	state_dict.pop(F'''dpt.encoder.layer.{i}.attn.qkv.weight'''       )
												snake_case_   =	state_dict.pop(F'''dpt.encoder.layer.{i}.attn.qkv.bias'''       )
												# next, add query, keys and values (in that order) to the state dict
												snake_case_   =	in_proj_weight[: config.hidden_size, :]
												snake_case_   =	in_proj_bias[: config.hidden_size]
												snake_case_   =	in_proj_weight[
												    config.hidden_size : config.hidden_size * 2, :
												]
												snake_case_   =	in_proj_bias[
												    config.hidden_size : config.hidden_size * 2
												]
												snake_case_   =	in_proj_weight[
												    -config.hidden_size :, :
												]
												snake_case_   =	in_proj_bias[-config.hidden_size :]


def   __SCREAMING_SNAKE_CASE					():
						snake_case_   =	'''http://images.cocodataset.org/val2017/000000039769.jpg'''
						snake_case_   =	Image.open(requests.get(SCREAMING_SNAKE_CASE__  ,		stream=SCREAMING_SNAKE_CASE__       ).raw       )
						return im


@torch.no_grad()
def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       ):
						snake_case_,    snake_case_   =	get_dpt_config(SCREAMING_SNAKE_CASE__       )
						# load original state_dict from URL
						snake_case_   =	torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__  ,		map_location='''cpu'''       )
						# remove certain keys
						remove_ignore_keys_(SCREAMING_SNAKE_CASE__       )
						# rename keys
						for key in state_dict.copy().keys():
												snake_case_   =	state_dict.pop(SCREAMING_SNAKE_CASE__       )
												snake_case_   =	val
						# read in qkv matrices
						read_in_q_k_v(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )

						# load HuggingFace model
						snake_case_   =	DPTForSemanticSegmentation(SCREAMING_SNAKE_CASE__       ) if '''ade''' in checkpoint_url else DPTForDepthEstimation(SCREAMING_SNAKE_CASE__       )
						model.load_state_dict(SCREAMING_SNAKE_CASE__       )
						model.eval()

						# Check outputs on an image
						snake_case_   =	480 if '''ade''' in checkpoint_url else 384
						snake_case_   =	DPTImageProcessor(size=SCREAMING_SNAKE_CASE__       )

						snake_case_   =	prepare_img()
						snake_case_   =	image_processor(SCREAMING_SNAKE_CASE__  ,		return_tensors='''pt'''       )

						# forward pass
						snake_case_   =	model(**SCREAMING_SNAKE_CASE__       ).logits if '''ade''' in checkpoint_url else model(**SCREAMING_SNAKE_CASE__       ).predicted_depth

						# Assert logits
						snake_case_   =	torch.tensor([[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]]       )
						if "ade" in checkpoint_url:
												snake_case_   =	torch.tensor([[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]]       )
						assert outputs.shape == torch.Size(SCREAMING_SNAKE_CASE__       )
						assert (
						    torch.allclose(outputs[0, 0, :3, :3]  ,		SCREAMING_SNAKE_CASE__  ,		atol=1E-4       )
						    if "ade" in checkpoint_url
						    else torch.allclose(outputs[0, :3, :3]  ,		SCREAMING_SNAKE_CASE__       )
						)

						Path(SCREAMING_SNAKE_CASE__       ).mkdir(exist_ok=SCREAMING_SNAKE_CASE__       )
						print(F'''Saving model to {pytorch_dump_folder_path}'''       )
						model.save_pretrained(SCREAMING_SNAKE_CASE__       )
						print(F'''Saving image processor to {pytorch_dump_folder_path}'''       )
						image_processor.save_pretrained(SCREAMING_SNAKE_CASE__       )

						if push_to_hub:
												print('''Pushing model to hub...'''       )
												model.push_to_hub(
												    repo_path_or_name=Path(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )  ,		organization='''nielsr'''  ,		commit_message='''Add model'''  ,		use_temp_dir=SCREAMING_SNAKE_CASE__  ,		)
												image_processor.push_to_hub(
												    repo_path_or_name=Path(SCREAMING_SNAKE_CASE__  ,		SCREAMING_SNAKE_CASE__       )  ,		organization='''nielsr'''  ,		commit_message='''Add image processor'''  ,		use_temp_dir=SCREAMING_SNAKE_CASE__  ,		)


if __name__ == "__main__":
					lowerCAmelCase_       	=	argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '''--checkpoint_url''',
					    default='''https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt''',
					    type=str,
					    help='''URL of the original DPT checkpoint you\'d like to convert.''',
					)
					parser.add_argument(
					    '''--pytorch_dump_folder_path''',
					    default=None,
					    type=str,
					    required=True,
					    help='''Path to the output PyTorch model directory.''',
					)
					parser.add_argument(
					    '''--push_to_hub''',
					    action='''store_true''',
					)
					parser.add_argument(
					    '''--model_name''',
					    default='''dpt-large''',
					    type=str,
					    help='''Name of the model, in case you\'re pushing to the hub.''',
					)

					lowerCAmelCase_       	=	parser.parse_args()
					convert_dpt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)



from __future__ import annotations

import math
import random
from collections.abc import Collection
from typing import overload






class     UpperCAmelCase__       :



    """simple docstring"""






    def __init__(			self					,   A_ = None    )  ->       None:
         if components is None:
              __UpperCamelCase    							=[]
         __UpperCamelCase    							=list(A_    )






    def __len__(			self    )  ->       int:
         return len(self.__components    )






    def __str__(			self    )  ->       str:
         return "(" + ",".join(map(A_					,   self.__components    )    ) + ")"






    def __add__(			self					,   A_    )  ->       Vector:
         __UpperCamelCase    							=len(self    )
         if size == len(A_    ):
              __UpperCamelCase    							=[self.__components[i] + other.component(A_    ) for i in range(A_    )]
              return Vector(A_    )
         else:
              raise Exception('must have the same size'    )






    def __sub__(			self					,   A_    )  ->       Vector:
         __UpperCamelCase    							=len(self    )
         if size == len(A_    ):
              __UpperCamelCase    							=[self.__components[i] - other.component(A_    ) for i in range(A_    )]
              return Vector(A_    )
         else:  # error case
              raise Exception('must have the same size'    )






    @overload
    def __mul__(			self					,   A_    )  ->       Vector:
         ...






    @overload
    def __mul__(			self					,   A_    )  ->       float:
         ...






    def __mul__(			self					,   A_    )  ->       float | Vector:
         if isinstance(A_					,   (float, int)    ):
              __UpperCamelCase    							=[c * other for c in self.__components]
              return Vector(A_    )
         elif isinstance(A_					,   A_    ) and len(self    ) == len(A_    ):
              __UpperCamelCase    							=len(self    )
              __UpperCamelCase    							=[self.__components[i] * other.component(A_    ) for i in range(A_    )]
              return sum(A_    )
         else:  # error case
              raise Exception('invalid operand!'    )






    def _a					(			self    )  ->       Vector:
         return Vector(self.__components    )






    def _a					(			self					,   A_    )  ->       float:
         if isinstance(A_					,   A_    ) and -len(self.__components    ) <= i < len(self.__components    ):
              return self.__components[i]
         else:
              raise Exception('index out of range'    )






    def _a					(			self					,   A_					,   A_    )  ->       None:
         assert -len(self.__components    ) <= pos < len(self.__components    )
         __UpperCamelCase    							=value






    def _a					(			self    )  ->       float:
         if len(self.__components    ) == 0:
              raise Exception('Vector is empty'    )
         __UpperCamelCase    							=[c**2 for c in self.__components]
         return math.sqrt(sum(A_    )    )






    def _a					(			self					,   A_					,   A_ = False    )  ->       float:
         __UpperCamelCase    							=self * other
         __UpperCamelCase    							=self.euclidean_length() * other.euclidean_length()
         if deg:
              return math.degrees(math.acos(num / den    )    )
         else:
              return math.acos(num / den    )

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):
     assert isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
     return Vector([0] * dimension				)

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int				):
     assert isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				) and (isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				))
     __UpperCamelCase    							=[0] * dimension
     __UpperCamelCase    							=1
     return Vector(SCREAMING_SNAKE_CASE__				)

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					float			,     SCREAMING_SNAKE_CASE__			:					Vector			,     SCREAMING_SNAKE_CASE__			:					Vector				):
     assert (
         isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
         and isinstance(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)
         and (isinstance(SCREAMING_SNAKE_CASE__			,     (int, float)				))
     )
     return x * scalar + y

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int				):
     random.seed(SCREAMING_SNAKE_CASE__				)
     __UpperCamelCase    							=[random.randint(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				) for _ in range(SCREAMING_SNAKE_CASE__				)]
     return Vector(SCREAMING_SNAKE_CASE__				)






class     UpperCAmelCase__       :



    """simple docstring"""






    def __init__(			self					,   A_					,   A_					,   A_    )  ->       None:
         __UpperCamelCase    							=matrix
         __UpperCamelCase    							=w
         __UpperCamelCase    							=h






    def __str__(			self    )  ->       str:
         __UpperCamelCase    							=''
         for i in range(self.__height    ):
              ans += "|"
              for j in range(self.__width    ):
                   if j < self.__width - 1:
                        ans += str(self.__matrix[i][j]    ) + ","
                   else:
                        ans += str(self.__matrix[i][j]    ) + "|\n"
         return ans






    def __add__(			self					,   A_    )  ->       Matrix:
         if self.__width == other.width() and self.__height == other.height():
              __UpperCamelCase    							=[]
              for i in range(self.__height    ):
                   __UpperCamelCase    							=[
                       self.__matrix[i][j] + other.component(A_					,   A_    )
                       for j in range(self.__width    )
                   ]
                   matrix.append(A_    )
              return Matrix(A_					,   self.__width					,   self.__height    )
         else:
              raise Exception('matrix must have the same dimension!'    )






    def __sub__(			self					,   A_    )  ->       Matrix:
         if self.__width == other.width() and self.__height == other.height():
              __UpperCamelCase    							=[]
              for i in range(self.__height    ):
                   __UpperCamelCase    							=[
                       self.__matrix[i][j] - other.component(A_					,   A_    )
                       for j in range(self.__width    )
                   ]
                   matrix.append(A_    )
              return Matrix(A_					,   self.__width					,   self.__height    )
         else:
              raise Exception('matrices must have the same dimension!'    )






    @overload
    def __mul__(			self					,   A_    )  ->       Matrix:
         ...






    @overload
    def __mul__(			self					,   A_    )  ->       Vector:
         ...






    def __mul__(			self					,   A_    )  ->       Vector | Matrix:
         if isinstance(A_					,   A_    ):  # matrix-vector
              if len(A_    ) == self.__width:
                   __UpperCamelCase    							=zero_vector(self.__height    )
                   for i in range(self.__height    ):
                        __UpperCamelCase    							=[
                            self.__matrix[i][j] * other.component(A_    )
                            for j in range(self.__width    )
                        ]
                        ans.change_component(A_					,   sum(A_    )    )
                   return ans
              else:
                   raise Exception(
                       'vector must have the same size as the '
                       'number of columns of the matrix!'    )
         elif isinstance(A_					,   (int, float)    ):  # matrix-scalar
              __UpperCamelCase    							=[
                  [self.__matrix[i][j] * other for j in range(self.__width    )]
                  for i in range(self.__height    )
              ]
              return Matrix(A_					,   self.__width					,   self.__height    )
         return None






    def _a					(			self    )  ->       int:
         return self.__height






    def _a					(			self    )  ->       int:
         return self.__width






    def _a					(			self					,   A_					,   A_    )  ->       float:
         if 0 <= x < self.__height and 0 <= y < self.__width:
              return self.__matrix[x][y]
         else:
              raise Exception('change_component: indices out of bounds'    )






    def _a					(			self					,   A_					,   A_					,   A_    )  ->       None:
         if 0 <= x < self.__height and 0 <= y < self.__width:
              __UpperCamelCase    							=value
         else:
              raise Exception('change_component: indices out of bounds'    )






    def _a					(			self					,   A_					,   A_    )  ->       float:
         if self.__height != self.__width:
              raise Exception('Matrix is not square'    )
         __UpperCamelCase    							=self.__matrix[:x] + self.__matrix[x + 1 :]
         for i in range(len(A_    )    ):
              __UpperCamelCase    							=minor[i][:y] + minor[i][y + 1 :]
         return Matrix(A_					,   self.__width - 1					,   self.__height - 1    ).determinant()






    def _a					(			self					,   A_					,   A_    )  ->       float:
         if self.__height != self.__width:
              raise Exception('Matrix is not square'    )
         if 0 <= x < self.__height and 0 <= y < self.__width:
              return (-1) ** (x + y) * self.minor(A_					,   A_    )
         else:
              raise Exception('Indices out of bounds'    )






    def _a					(			self    )  ->       float:
         if self.__height != self.__width:
              raise Exception('Matrix is not square'    )
         if self.__height < 1:
              raise Exception('Matrix has no element'    )
         elif self.__height == 1:
              return self.__matrix[0][0]
         elif self.__height == 2:
              return (
                  self.__matrix[0][0] * self.__matrix[1][1]
                  - self.__matrix[0][1] * self.__matrix[1][0]
              )
         else:
              __UpperCamelCase    							=[
                  self.__matrix[0][y] * self.cofactor(0					,   A_    ) for y in range(self.__width    )
              ]
              return sum(A_    )

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int				):
     __UpperCamelCase    							=[[0] * n for _ in range(SCREAMING_SNAKE_CASE__				)]
     return Matrix(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)





def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int			,     SCREAMING_SNAKE_CASE__			:					int				):
     random.seed(SCREAMING_SNAKE_CASE__				)
     __UpperCamelCase    							=[
         [random.randint(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				) for _ in range(SCREAMING_SNAKE_CASE__				)] for _ in range(SCREAMING_SNAKE_CASE__				)
     ]
     return Matrix(SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__			,     SCREAMING_SNAKE_CASE__				)





