




"""simple docstring"""





import itertools
from dataclasses import dataclass
from typing import List, Optional

import pyarrow as pa
import pyarrow.parquet as pq

import datasets
from datasets.table import table_cast


A				=							datasets.utils.logging.get_logger(__name__)



@dataclass
class   a__					(						datasets.BuilderConfig ):
			lowercase_		=						1_0_0_0_0
			lowercase_		=						None
			lowercase_		=						None






class   a__					(						datasets.ArrowBasedBuilder ):
			lowercase_		=						ParquetConfig


			def    a_  (   self   :     Any):


						"""simple docstring"""




						return datasets.DatasetInfo(features=self.config.features)


			def    a_  (   self   :     Optional[Any]   ,	UpperCamelCase_   :     str):


						"""simple docstring"""




						if not self.config.data_files:
									raise ValueError(F"At least one data file must be specified, but got data_files={self.config.data_files}")
						__UpperCAmelCase						:			str												=       dl_manager.download_and_extract(self.config.data_files)
						if isinstance(UpperCamelCase_   ,	(str, list, tuple)):
									__UpperCAmelCase						:			List[str]												=       data_files
									if isinstance(UpperCamelCase_   ,	UpperCamelCase_):
												__UpperCAmelCase						:			List[str]												=       [files]
									# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
									__UpperCAmelCase						:			Any												=       [dl_manager.iter_files(UpperCamelCase_) for file in files]
									return [datasets.SplitGenerator(name=datasets.Split.TRAIN   ,	gen_kwargs={"files": files})]
						__UpperCAmelCase						:			Optional[Any]												=       []
						for split_name, files in data_files.items():
									if isinstance(UpperCamelCase_   ,	UpperCamelCase_):
												__UpperCAmelCase						:			Any												=       [files]
									# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
									__UpperCAmelCase						:			Union[str, Any]												=       [dl_manager.iter_files(UpperCamelCase_) for file in files]
									# Infer features is they are stoed in the arrow schema
									if self.info.features is None:
												for file in itertools.chain.from_iterable(UpperCamelCase_):
															with open(UpperCamelCase_   ,	"rb") as f:
																		__UpperCAmelCase						:			str												=       datasets.Features.from_arrow_schema(pq.read_schema(UpperCamelCase_))
															break
									splits.append(datasets.SplitGenerator(name=UpperCamelCase_   ,	gen_kwargs={"files": files}))
						return splits


			def    a_  (   self   :     Tuple   ,	UpperCamelCase_   :     pa.Table):


						"""simple docstring"""




						if self.info.features is not None:
									# more expensive cast to support nested features with keys in a different order
									# allows str <-> int/float or str to Audio for example
									__UpperCAmelCase						:			Union[str, Any]												=       table_cast(UpperCamelCase_   ,	self.info.features.arrow_schema)
						return pa_table


			def    a_  (   self   :     str   ,	UpperCamelCase_   :     Optional[int]):


						"""simple docstring"""




						__UpperCAmelCase						:			str												=       self.info.features.arrow_schema if self.info.features is not None else None
						if self.info.features is not None and self.config.columns is not None:
									if sorted(field.name for field in schema) != sorted(self.config.columns):
												raise ValueError(
												    F"Tried to load parquet data with columns \'{self.config.columns}\' with mismatching features \'{self.info.features}\'")
						for file_idx, file in enumerate(itertools.chain.from_iterable(UpperCamelCase_)):
									with open(UpperCamelCase_   ,	"rb") as f:
												__UpperCAmelCase						:			List[str]												=       pq.ParquetFile(UpperCamelCase_)
												try:
															for batch_idx, record_batch in enumerate(
															    parquet_file.iter_batches(batch_size=self.config.batch_size   ,	columns=self.config.columns)):
																		__UpperCAmelCase						:			str												=       pa.Table.from_batches([record_batch])
																		# Uncomment for debugging (will print the Arrow table size and elements)
																		# logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
																		# logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
																		yield F"{file_idx}_{batch_idx}", self._cast_table(UpperCamelCase_)
												except ValueError as e:
															logger.error(F"Failed to read file \'{file}\' with error {type(UpperCamelCase_)}: {e}")
															raise








from collections import defaultdict





def 				A__ (snake_case   :		int				)     ->						int:
					__UpperCamelCase					:	Optional[int]             =      1
					__UpperCamelCase					:	Tuple             =      True
					for v in tree[start]:
										if v not in visited:
															ret += dfs(snake_case				)
					if ret % 2 == 0:
										cuts.append(snake_case				)
					return ret





def 				A__ ()     ->						str:
					dfs(1				)


if __name__ == "__main__":
	a__     ,							a__		     =     10, 9
	a__		     =     defaultdict(list)
	a__		     =     {}
	a__		     =     []
	a__		     =     0
	a__		     =     [(2, 1), (3, 1), (4, 3), (5, 2), (6, 1), (7, 2), (8, 6), (9, 8), (10, 8)]
	for u, v in edges:
		tree[u].append(v)
		tree[v].append(u)
	even_tree()
	print(len(cuts) - 1)






