from ..utils import DummyObject, requires_backends




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				List[Any]	,  *__lowerCamelCase:				Optional[int]	,  **__lowerCamelCase:				List[str]     )    ->				List[str]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				List[str]	,  *__lowerCamelCase:				Optional[Any]	,  **__lowerCamelCase:				int     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				int	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				Any     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[str]  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				List[Any]	,  **__lowerCamelCase:				Dict     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				Dict     )    ->				List[str]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				List[str]     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				List[str]	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				Any     )    ->				str:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Any  =     ["vision"]
					def __init__(  self:				int	,  *__lowerCamelCase:				Optional[int]	,  **__lowerCamelCase:				str     )    ->				Optional[int]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				List[Any]	,  *__lowerCamelCase:				Optional[Any]	,  **__lowerCamelCase:				str     )    ->				Optional[int]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Tuple  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				Optional[Any]	,  **__lowerCamelCase:				int     )    ->				List[str]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				int     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				Optional[int]	,  *__lowerCamelCase:				int	,  **__lowerCamelCase:				Dict     )    ->				str:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				Union[str, Any]	,  *__lowerCamelCase:				List[Any]	,  **__lowerCamelCase:				Optional[int]     )    ->				List[str]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				Tuple     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				List[Any]	,  **__lowerCamelCase:				Dict     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				Optional[int]     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[str]  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				List[Any]     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				Union[str, Any]	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				Union[str, Any]     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				Optional[Any]	,  **__lowerCamelCase:				Union[str, Any]     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				Any	,  **__lowerCamelCase:				Optional[int]     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				Union[str, Any]	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				Optional[int]     )    ->				str:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				Any     )    ->				Union[str, Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				Optional[int]     )    ->				Optional[int]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				List[str]	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				int     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				str	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				str     )    ->				Optional[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Any  =     ["vision"]
					def __init__(  self:				Union[str, Any]	,  *__lowerCamelCase:				Optional[int]	,  **__lowerCamelCase:				List[Any]     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				Optional[int]	,  *__lowerCamelCase:				int	,  **__lowerCamelCase:				Any     )    ->				List[str]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				List[Any]     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				Optional[Any]     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Tuple  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				List[Any]	,  **__lowerCamelCase:				Optional[int]     )    ->				List[str]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				Optional[int]	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				int     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Any  =     ["vision"]
					def __init__(  self:				List[Any]	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				List[Any]     )    ->				Optional[int]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[Any]  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				Dict     )    ->				Union[str, Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				List[str]	,  *__lowerCamelCase:				int	,  **__lowerCamelCase:				str     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				Optional[int]     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[str]  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				List[Any]	,  **__lowerCamelCase:				Tuple     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Tuple  =     ["vision"]
					def __init__(  self:				Union[str, Any]	,  *__lowerCamelCase:				Optional[int]	,  **__lowerCamelCase:				Tuple     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				int	,  *__lowerCamelCase:				Any	,  **__lowerCamelCase:				Union[str, Any]     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				int     )    ->				str:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				List[Any]	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				List[Any]     )    ->				Optional[int]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				Optional[Any]	,  **__lowerCamelCase:				List[Any]     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Tuple  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				List[str]     )    ->				Optional[int]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				Optional[int]	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				Dict     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				Optional[int]	,  *__lowerCamelCase:				int	,  **__lowerCamelCase:				Union[str, Any]     )    ->				List[str]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[Any]  =     ["vision"]
					def __init__(  self:				Optional[int]	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				Tuple     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				Union[str, Any]	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				Optional[int]     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				List[str]	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				Optional[Any]     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				Union[str, Any]     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[str]  =     ["vision"]
					def __init__(  self:				str	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				List[str]     )    ->				Optional[int]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[str]  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				int     )    ->				Optional[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				List[str]	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				int     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				List[Any]	,  *__lowerCamelCase:				Any	,  **__lowerCamelCase:				str     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				List[Any]     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				List[Any]	,  **__lowerCamelCase:				Dict     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[Any]  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				str     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				Any     )    ->				str:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				Any	,  **__lowerCamelCase:				str     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				Tuple     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				int     )    ->				Optional[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[str]  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				int     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				List[Any]	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				str     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				int	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				List[str]     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[Any]  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				Tuple	,  **__lowerCamelCase:				Optional[Any]     )    ->				Optional[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				Any	,  **__lowerCamelCase:				Optional[int]     )    ->				Any:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		int  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				Any	,  **__lowerCamelCase:				str     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				Tuple	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				Optional[int]     )    ->				int:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Any  =     ["vision"]
					def __init__(  self:				Any	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				str     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[Any]  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				str	,  **__lowerCamelCase:				Dict     )    ->				Dict:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		str  =     ["vision"]
					def __init__(  self:				Optional[Any]	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				List[str]     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Union[str, Any]  =     ["vision"]
					def __init__(  self:				List[Any]	,  *__lowerCamelCase:				Union[str, Any]	,  **__lowerCamelCase:				Dict     )    ->				Union[str, Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		List[Any]  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				Optional[int]	,  **__lowerCamelCase:				str     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				int	,  *__lowerCamelCase:				List[str]	,  **__lowerCamelCase:				str     )    ->				str:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Optional[int]  =     ["vision"]
					def __init__(  self:				Dict	,  *__lowerCamelCase:				int	,  **__lowerCamelCase:				int     )    ->				List[Any]:
												requires_backends(self	,  ["vision"]     )




class 					_snake_case						(						metaclass=_lowercase				):
					lowerCamelCase__:		Dict  =     ["vision"]
					def __init__(  self:				List[str]	,  *__lowerCamelCase:				Dict	,  **__lowerCamelCase:				List[str]     )    ->				Tuple:
												requires_backends(self	,  ["vision"]     )





import io
import json
import subprocess


_snake_case			=						[
    ['''en''', '''ru'''],
    ['''ru''', '''en'''],
    ['''en''', '''de'''],
    ['''de''', '''en'''],
]

_snake_case			=						8




def   _UpperCamelCase   (			snake_case__,    snake_case__							)						->   List[Any]:
							__UpperCAmelCase						:			int         =   {}
							for src, tgt in pairs:
														__UpperCAmelCase						:			Optional[Any]         =   f'''{src}-{tgt}'''
														__UpperCAmelCase						:			Union[str, Any]         =   f'''sacrebleu -t wmt19 -l {pair} --echo src'''.split()
														__UpperCAmelCase						:			Any         =   subprocess.run(snake_case__,    stdout=subprocess.PIPE							).stdout.decode("utf-8"							).splitlines()
														__UpperCAmelCase						:			Tuple         =   f'''sacrebleu -t wmt19 -l {pair} --echo ref'''.split()
														__UpperCAmelCase						:			List[Any]         =   subprocess.run(snake_case__,    stdout=subprocess.PIPE							).stdout.decode("utf-8"							).splitlines()
														__UpperCAmelCase						:			str         =   {"src": src_lines[:n_objs], "tgt": tgt_lines[:n_objs]}
							return text


_snake_case			=						get_all_data(pairs, n_objs)
_snake_case			=						'''./fsmt_val_data.json'''
with io.open(filename, '''w''', encoding='''utf-8''') as f:
	_snake_case			=						json.dump(text, f, indent=2, ensure_ascii=False)




