


import contextlib
import csv
import json
import os
import sqlitea
import tarfile
import textwrap
import zipfile

import pyarrow as pa
import pyarrow.parquet as pq
import pytest

import datasets
import datasets.config







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   ):
							__snake_case						:     Optional[Any]									=  1_0
							__snake_case						:     List[Any]									=  datasets.Features(
							    {
							        "tokens": datasets.Sequence(datasets.Value("string"      )      ),
							        "labels": datasets.Sequence(datasets.ClassLabel(names=["negative", "positive"]      )      ),
							        "answers": datasets.Sequence(
							            {
							                "text": datasets.Value("string"      ),
							                "answer_start": datasets.Value("int32"      ),
							            }      ),
							        "id": datasets.Value("int64"      ),
							    }      )
							__snake_case						:     Any									=  datasets.Dataset.from_dict(
							    {
							        "tokens": [["foo"] * 5] * n,
							        "labels": [[1] * 5] * n,
							        "answers": [{"answer_start": [9_7], "text": ["1976"]}] * 1_0,
							        "id": list(range(__lowerCamelCase      )      ),
							    }				,      features=__lowerCamelCase				,      )
							return dataset







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Optional[int]									=  str(tmp_path_factory.mktemp("data"      ) / "file.arrow"      )
							dataset.map(cache_file_name=__lowerCamelCase      )
							return filename


# FILE_CONTENT + files


_snake_case	:						List[str]         =							"\\n    Text data.\n    Second line of data."







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Tuple									=  tmp_path_factory.mktemp("data"      ) / "file.txt"
							__snake_case						:     Optional[Any]									=  FILE_CONTENT
							with open(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase      )
							return filename







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							import bza

							__snake_case						:     List[str]									=  tmp_path_factory.mktemp("data"      ) / "file.txt.bz2"
							__snake_case						:     Optional[Any]									=  bytes(__lowerCamelCase				,      "utf-8"      )
							with bza.open(__lowerCamelCase				,      "wb"      ) as f:
														f.write(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							import gzip

							__snake_case						:     List[str]									=  str(tmp_path_factory.mktemp("data"      ) / "file.txt.gz"      )
							__snake_case						:     List[str]									=  bytes(__lowerCamelCase				,      "utf-8"      )
							with gzip.open(__lowerCamelCase				,      "wb"      ) as f:
														f.write(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							if datasets.config.LZ4_AVAILABLE:
														import lza.frame

														__snake_case						:     Any									=  tmp_path_factory.mktemp("data"      ) / "file.txt.lz4"
														__snake_case						:     str									=  bytes(__lowerCamelCase				,      "utf-8"      )
														with lza.frame.open(__lowerCamelCase				,      "wb"      ) as f:
																					f.write(__lowerCamelCase      )
														return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							if datasets.config.PY7ZR_AVAILABLE:
														import pyazr

														__snake_case						:     int									=  tmp_path_factory.mktemp("data"      ) / "file.txt.7z"
														with pyazr.SevenZipFile(__lowerCamelCase				,      "w"      ) as archive:
																					archive.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
														return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							import tarfile

							__snake_case						:     int									=  tmp_path_factory.mktemp("data"      ) / "file.txt.tar"
							with tarfile.TarFile(__lowerCamelCase				,      "w"      ) as f:
														f.add(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							import lzma

							__snake_case						:     Optional[int]									=  tmp_path_factory.mktemp("data"      ) / "file.txt.xz"
							__snake_case						:     Any									=  bytes(__lowerCamelCase				,      "utf-8"      )
							with lzma.open(__lowerCamelCase				,      "wb"      ) as f:
														f.write(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							import zipfile

							__snake_case						:     Optional[int]									=  tmp_path_factory.mktemp("data"      ) / "file.txt.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							if datasets.config.ZSTANDARD_AVAILABLE:
														import zstandard as zstd

														__snake_case						:     Optional[int]									=  tmp_path_factory.mktemp("data"      ) / "file.txt.zst"
														__snake_case						:     Optional[Any]									=  bytes(__lowerCamelCase				,      "utf-8"      )
														with zstd.open(__lowerCamelCase				,      "wb"      ) as f:
																					f.write(__lowerCamelCase      )
														return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     int									=  tmp_path_factory.mktemp("data"      ) / "file.xml"
							__snake_case						:     Dict									=  textwrap.dedent(
							    "\\n    <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n    <tmx version=\"1.4\">\n      <header segtype=\"sentence\" srclang=\"ca\" />\n      <body>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 1</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 1</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 2</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 2</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 3</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 3</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 4</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 4</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 5</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 5</seg></tuv>\n        </tu>\n      </body>\n    </tmx>"      )
							with open(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase      )
							return filename


_snake_case	:						Optional[int]         =							[
    {"col_1": "0", "col_2": 0, "col_3": 0.0},
    {"col_1": "1", "col_2": 1, "col_3": 1.0},
    {"col_1": "2", "col_2": 2, "col_3": 2.0},
    {"col_1": "3", "col_2": 3, "col_3": 3.0},
]
_snake_case	:						int         =							[
    {"col_1": "4", "col_2": 4, "col_3": 4.0},
    {"col_1": "5", "col_2": 5, "col_3": 5.0},
]
_snake_case	:						List[Any]         =							{
    "col_1": ["0", "1", "2", "3"],
    "col_2": [0, 1, 2, 3],
    "col_3": [0.0, 1.0, 2.0, 3.0],
}

_snake_case	:						List[str]         =							[
    {"col_3": 0.0, "col_1": "0", "col_2": 0},
    {"col_3": 1.0, "col_1": "1", "col_2": 1},
]

_snake_case	:						Optional[int]         =							[
    {"col_1": "s0", "col_2": 0, "col_3": 0.0},
    {"col_1": "s1", "col_2": 1, "col_3": 1.0},
    {"col_1": "s2", "col_2": 2, "col_3": 2.0},
    {"col_1": "s3", "col_2": 3, "col_3": 3.0},
]







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   ):
							return DATA_DICT_OF_LISTS







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Dict									=  datasets.Dataset.from_dict(__lowerCamelCase      )
							__snake_case						:     int									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.arrow"      )
							dataset.map(cache_file_name=__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Tuple									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.sqlite"      )
							with contextlib.closing(sqlitea.connect(__lowerCamelCase      )      ) as con:
														__snake_case						:     Dict									=  con.cursor()
														cur.execute("CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)"      )
														for item in DATA:
																					cur.execute("INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)"				,      tuple(item.values()      )      )
														con.commit()
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Any									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.csv"      )
							with open(__lowerCamelCase				,      "w"				,      newline=""      ) as f:
														__snake_case						:     Any									=  csv.DictWriter(__lowerCamelCase				,      fieldnames=["col_1", "col_2", "col_3"]      )
														writer.writeheader()
														for item in DATA:
																					writer.writerow(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Optional[Any]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset2.csv"      )
							with open(__lowerCamelCase				,      "w"				,      newline=""      ) as f:
														__snake_case						:     str									=  csv.DictWriter(__lowerCamelCase				,      fieldnames=["col_1", "col_2", "col_3"]      )
														writer.writeheader()
														for item in DATA:
																					writer.writerow(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							import bza

							__snake_case						:     List[str]									=  tmp_path_factory.mktemp("data"      ) / "dataset.csv.bz2"
							with open(__lowerCamelCase				,      "rb"      ) as f:
														__snake_case						:     Tuple									=  f.read()
							# data = bytes(FILE_CONTENT, "utf-8")
							with bza.open(__lowerCamelCase				,      "wb"      ) as f:
														f.write(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     List[str]									=  tmp_path_factory.mktemp("data"      ) / "dataset.csv.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Any									=  tmp_path_factory.mktemp("data"      ) / "dataset.csv.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.basename(csv_path.replace(".csv"				,      ".CSV"      )      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.basename(csva_path.replace(".csv"				,      ".CSV"      )      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     List[Any]									=  tmp_path_factory.mktemp("data"      ) / "dataset_with_dir.csv.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.join("main_dir"				,      os.path.basename(__lowerCamelCase      )      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.join("main_dir"				,      os.path.basename(__lowerCamelCase      )      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Optional[Any]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.parquet"      )
							__snake_case						:     Tuple									=  pa.schema(
							    {
							        "col_1": pa.string(),
							        "col_2": pa.intaa(),
							        "col_3": pa.floataa(),
							    }      )
							with open(__lowerCamelCase				,      "wb"      ) as f:
														__snake_case						:     List[str]									=  pq.ParquetWriter(__lowerCamelCase				,      schema=__lowerCamelCase      )
														__snake_case						:     Any									=  pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(__lowerCamelCase      )      )] for k in DATA[0]}				,      schema=__lowerCamelCase      )
														writer.write_table(__lowerCamelCase      )
														writer.close()
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Dict									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.json"      )
							__snake_case						:     str									=  {"data": DATA}
							with open(__lowerCamelCase				,      "w"      ) as f:
														json.dump(__lowerCamelCase				,      __lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     List[str]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.json"      )
							__snake_case						:     Tuple									=  {"data": DATA_DICT_OF_LISTS}
							with open(__lowerCamelCase				,      "w"      ) as f:
														json.dump(__lowerCamelCase				,      __lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     List[Any]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.jsonl"      )
							with open(__lowerCamelCase				,      "w"      ) as f:
														for item in DATA:
																					f.write(json.dumps(__lowerCamelCase      ) + "\n"      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     List[str]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset2.jsonl"      )
							with open(__lowerCamelCase				,      "w"      ) as f:
														for item in DATA:
																					f.write(json.dumps(__lowerCamelCase      ) + "\n"      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     List[Any]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset_312.jsonl"      )
							with open(__lowerCamelCase				,      "w"      ) as f:
														for item in DATA_312:
																					f.write(json.dumps(__lowerCamelCase      ) + "\n"      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     List[str]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset-str.jsonl"      )
							with open(__lowerCamelCase				,      "w"      ) as f:
														for item in DATA_STR:
																					f.write(json.dumps(__lowerCamelCase      ) + "\n"      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							import gzip

							__snake_case						:     int									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.txt.gz"      )
							with open(__lowerCamelCase				,      "rb"      ) as orig_file:
														with gzip.open(__lowerCamelCase				,      "wb"      ) as zipped_file:
																					zipped_file.writelines(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							import gzip

							__snake_case						:     Optional[int]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.jsonl.gz"      )
							with open(__lowerCamelCase				,      "rb"      ) as orig_file:
														with gzip.open(__lowerCamelCase				,      "wb"      ) as zipped_file:
																					zipped_file.writelines(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Any									=  tmp_path_factory.mktemp("data"      ) / "dataset.jsonl.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     List[str]									=  tmp_path_factory.mktemp("data"      ) / "dataset_nested.jsonl.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.join("nested"				,      os.path.basename(__lowerCamelCase      )      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Optional[int]									=  tmp_path_factory.mktemp("data"      ) / "dataset_with_dir.jsonl.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.join("main_dir"				,      os.path.basename(__lowerCamelCase      )      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.join("main_dir"				,      os.path.basename(__lowerCamelCase      )      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Optional[int]									=  tmp_path_factory.mktemp("data"      ) / "dataset.jsonl.tar"
							with tarfile.TarFile(__lowerCamelCase				,      "w"      ) as f:
														f.add(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
														f.add(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Optional[Any]									=  tmp_path_factory.mktemp("data"      ) / "dataset_nested.jsonl.tar"
							with tarfile.TarFile(__lowerCamelCase				,      "w"      ) as f:
														f.add(__lowerCamelCase				,      arcname=os.path.join("nested"				,      os.path.basename(__lowerCamelCase      )      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     List[Any]									=  ["0", "1", "2", "3"]
							__snake_case						:     Optional[Any]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset.txt"      )
							with open(__lowerCamelCase				,      "w"      ) as f:
														for item in data:
																					f.write(item + "\n"      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     List[str]									=  ["0", "1", "2", "3"]
							__snake_case						:     Any									=  str(tmp_path_factory.mktemp("data"      ) / "dataset2.txt"      )
							with open(__lowerCamelCase				,      "w"      ) as f:
														for item in data:
																					f.write(item + "\n"      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Tuple									=  ["0", "1", "2", "3"]
							__snake_case						:     Any									=  tmp_path_factory.mktemp("data"      ) / "dataset.abc"
							with open(__lowerCamelCase				,      "w"      ) as f:
														for item in data:
																					f.write(item + "\n"      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Optional[int]									=  tmp_path_factory.mktemp("data"      ) / "dataset.text.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     str									=  tmp_path_factory.mktemp("data"      ) / "dataset_with_dir.text.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.join("main_dir"				,      os.path.basename(__lowerCamelCase      )      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.join("main_dir"				,      os.path.basename(__lowerCamelCase      )      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Optional[int]									=  tmp_path_factory.mktemp("data"      ) / "dataset.ext.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.basename("unsupported.ext"      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.basename("unsupported_2.ext"      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Any									=  "\n".join(["First", "Second\u2029with Unicode new line", "Third"]      )
							__snake_case						:     List[str]									=  str(tmp_path_factory.mktemp("data"      ) / "dataset_with_unicode_new_lines.txt"      )
							with open(__lowerCamelCase				,      "w"				,      encoding="utf-8"      ) as f:
														f.write(__lowerCamelCase      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   ):
							return os.path.join("tests"				,      "features"				,      "data"				,      "test_image_rgb.jpg"      )







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   ):
							return os.path.join("tests"				,      "features"				,      "data"				,      "test_audio_44100.wav"      )







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase				,      __lowerCamelCase      ):
							__snake_case						:     Tuple									=  tmp_path_factory.mktemp("data"      ) / "dataset.img.zip"
							with zipfile.ZipFile(__lowerCamelCase				,      "w"      ) as f:
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      )      )
														f.write(__lowerCamelCase				,      arcname=os.path.basename(__lowerCamelCase      ).replace(".jpg"				,      "2.jpg"      )      )
							return path







@pytest.fixture(scope="session"      )
def 							lowerCAmelCase_	(   __lowerCamelCase      ):
							__snake_case						:     Any									=  tmp_path_factory.mktemp("data_dir"      )

							(data_dir / "subdir").mkdir()
							with open(data_dir / "subdir" / "train.txt"				,      "w"      ) as f:
														f.write("foo\n" * 1_0      )
							with open(data_dir / "subdir" / "test.txt"				,      "w"      ) as f:
														f.write("bar\n" * 1_0      )
							# hidden file
							with open(data_dir / "subdir" / ".test.txt"				,      "w"      ) as f:
														f.write("bar\n" * 1_0      )

							# hidden directory
							(data_dir / ".subdir").mkdir()
							with open(data_dir / ".subdir" / "train.txt"				,      "w"      ) as f:
														f.write("foo\n" * 1_0      )
							with open(data_dir / ".subdir" / "test.txt"				,      "w"      ) as f:
														f.write("bar\n" * 1_0      )

							return data_dir








def      _UpperCamelCase  (a__ :int = 1000							):






							"""simple docstring"""





							UpperCamelCase__					  =      2**power
							UpperCamelCase__					  =      0
							while n:
														UpperCamelCase__  ,  UpperCamelCase__					  =      r + n % 10, n // 10
							return r


if __name__ == "__main__":
					print(solution(int(str(input()).strip())))




