



'''simple docstring'''
import csv
import json
import os

import datasets


# TODO: Add BibTeX citation
# Find for instance the citation on arxiv or on the dataset repo/website
_UpperCamelCase									=      '''\
@InProceedings{huggingface:dataset,
title = {A great new dataset},
author={huggingface, Inc.
},
year={2020}
}
'''

# TODO: Add description of the dataset here
# You can copy an official description
_UpperCamelCase									=      '''\
This new dataset is designed to solve this great NLP task and is crafted with a lot of care.
'''

# TODO: Add a link to an official homepage for the dataset here
_UpperCamelCase									=      ''''''

# TODO: Add the licence for the dataset here if you can find it
_UpperCamelCase									=      ''''''

# TODO: Add link to the official dataset URLs here
# The HuggingFace Datasets library doesn't host the datasets but only points to the original files.
# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
_UpperCamelCase									=      {
    '''first_domain''': '''https://huggingface.co/great-new-dataset-first_domain.zip''',
    '''second_domain''': '''https://huggingface.co/great-new-dataset-second_domain.zip''',
}



class _A	(     datasets.GeneratorBasedBuilder     ):
		_SCREAMING_SNAKE_CASE       :     Dict       =      datasets.Version("1.1.0"     )

		# This is an example of a dataset with multiple configurations.
		# If you don't want/need to define several sub-sets in your dataset,
		# just remove the BUILDER_CONFIG_CLASS and the BUILDER_CONFIGS attributes.

		# If you need to make complex sub-parts in the datasets with configurable options
		# You can create your own builder configuration class to store attribute, inheriting from datasets.BuilderConfig
		# BUILDER_CONFIG_CLASS = MyBuilderConfig

		# You will be able to load one or the other configurations in the following list with
		# data = datasets.load_dataset('my_dataset', 'first_domain')
		# data = datasets.load_dataset('my_dataset', 'second_domain')
		_SCREAMING_SNAKE_CASE       :     List[Any]       =      [
		    datasets.BuilderConfig(name="first_domain"						,					version=__SCREAMING_SNAKE_CASE						,					description="This part of my dataset covers a first domain"     ),
		    datasets.BuilderConfig(name="second_domain"						,					version=__SCREAMING_SNAKE_CASE						,					description="This part of my dataset covers a second domain"     ),
		]

		_SCREAMING_SNAKE_CASE       :     Tuple       =      "first_domain"  # It's not mandatory to have a default configuration. Just use one if it make sense.





		def 				__A							(  self					)							->  Tuple:

					'''simple docstring'''
					# TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
					if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
								__UpperCAmelCase :   int    					=  datasets.Features(
								    {
								        """sentence""": datasets.Value("""string"""					),
								        """option1""": datasets.Value("""string"""					),
								        """answer""": datasets.Value("""string"""					)
								        # These are the features of your dataset like images, labels ...
								    }					)
					else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
								__UpperCAmelCase :   Dict    					=  datasets.Features(
								    {
								        """sentence""": datasets.Value("""string"""					),
								        """option2""": datasets.Value("""string"""					),
								        """second_domain_answer""": datasets.Value("""string"""					)
								        # These are the features of your dataset like images, labels ...
								    }					)
					return datasets.DatasetInfo(
					    # This is the description that will appear on the datasets page.
					    description=_DESCRIPTION			,							features=__UpperCAmelCase			,							homepage=_HOMEPAGE			,							license=_LICENSE			,							citation=_CITATION			,							)





		def 				__A							(  self			,							__UpperCAmelCase					)							->  int:

					'''simple docstring'''
					# TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
					# If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name

					# dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLS
					# It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
					# By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
					__UpperCAmelCase :   Union[str, Any]    					=  _URLS[self.config.name]
					__UpperCAmelCase :   Any    					=  dl_manager.download_and_extract(__UpperCAmelCase					)
					return [
					    datasets.SplitGenerator(
					        name=datasets.Split.TRAIN			,							gen_kwargs={
					            """filepath""": os.path.join(__UpperCAmelCase			,							"""train.jsonl"""					),
					            """split""": """train""",
					        }			,							),
					    datasets.SplitGenerator(
					        name=datasets.Split.VALIDATION			,							gen_kwargs={
					            """filepath""": os.path.join(__UpperCAmelCase			,							"""dev.jsonl"""					),
					            """split""": """dev""",
					        }			,							),
					    datasets.SplitGenerator(
					        name=datasets.Split.TEST			,							gen_kwargs={
					            """filepath""": os.path.join(__UpperCAmelCase			,							"""test.jsonl"""					),
					            """split""": """test"""
					        }			,							),
					]





		def 				__A							(  self			,							__UpperCAmelCase			,							__UpperCAmelCase					)							->  int:

					'''simple docstring'''
					# TODO: This method handles input defined in _split_generators to yield (key, example) tuples from the dataset.
					# The `key` is for legacy reasons (tfds) and is not important in itself, but must be unique for each example.
					with open(__UpperCAmelCase			,							encoding="""utf-8"""					) as f:
								for key, row in enumerate(__UpperCAmelCase					):
											__UpperCAmelCase :   Tuple    					=  json.loads(__UpperCAmelCase					)
											if self.config.name == "first_domain":
														# Yields examples as (key, example) tuples
														yield key, {
														    "sentence": data["sentence"],
														    "option1": data["option1"],
														    "answer": "" if split == "test" else data["answer"],
														}
											else:
														yield key, {
														    "sentence": data["sentence"],
														    "option2": data["option2"],
														    "second_domain_answer": "" if split == "test" else data["second_domain_answer"],
														}









'''simple docstring'''
from __future__ import annotations


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int			):

			"""simple docstring"""





			assert (
			    c % greatest_common_divisor(lowerCAmelCase__      ,				lowerCAmelCase__			) == 0
			)  # greatest_common_divisor(a,b) function implemented below
			((__UpperCAmelCase)					,	(__UpperCAmelCase)					,	(__UpperCAmelCase)) :   int    					=  extended_gcd(lowerCAmelCase__      ,				lowerCAmelCase__			)  # extended_gcd(a,b) function implemented below
			__UpperCAmelCase :   Union[str, Any]    					=  c / d
			return (r * x, r * y)


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int = 2			):

			"""simple docstring"""





			((__UpperCAmelCase)					,	(__UpperCAmelCase)) :   List[str]    					=  diophantine(lowerCAmelCase__      ,				lowerCAmelCase__      ,				lowerCAmelCase__			)  # Initial value
			__UpperCAmelCase :   List[str]    					=  greatest_common_divisor(lowerCAmelCase__      ,				lowerCAmelCase__			)
			__UpperCAmelCase :   List[str]    					=  a // d
			__UpperCAmelCase :   Tuple    					=  b // d

			for i in range(lowerCAmelCase__			):
						__UpperCAmelCase :   List[Any]    					=  xa + i * q
						__UpperCAmelCase :   Tuple    					=  ya - i * p
						print(lowerCAmelCase__      ,				lowerCAmelCase__			)


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int			):

			"""simple docstring"""





			if a < b:
						__UpperCAmelCase					,	__UpperCAmelCase :   List[str]    					=  b, a

			while a % b != 0:
						__UpperCAmelCase					,	__UpperCAmelCase :   Optional[int]    					=  b, a % b

			return b


def 	lowercase_						( lowerCAmelCase__						:	int      ,				lowerCAmelCase__						:	int			):

			"""simple docstring"""





			assert a >= 0 and b >= 0

			if b == 0:
						__UpperCAmelCase					,	__UpperCAmelCase					,	__UpperCAmelCase :   List[str]    					=  a, 1, 0
			else:
						((__UpperCAmelCase)					,	(__UpperCAmelCase)					,	(__UpperCAmelCase)) :   str    					=  extended_gcd(lowerCAmelCase__      ,				a % b			)
						__UpperCAmelCase :   Optional[Any]    					=  q
						__UpperCAmelCase :   Dict    					=  p - q * (a // b)

			assert a % d == 0 and b % d == 0
			assert d == a * x + b * y

			return (d, x, y)


if __name__ == "__main__":
					from doctest import testmod

					testmod(name='''diophantine''', verbose=True)
					testmod(name='''diophantine_all_soln''', verbose=True)
					testmod(name='''extended_gcd''', verbose=True)
					testmod(name='''greatest_common_divisor''', verbose=True)




