


'''simple docstring'''







def _UpperCamelCase	(					__A = 4000000   )							->		int:


      '''simple docstring'''



      if n <= 1:
            return 0
      UpperCamelCase__  =    0
      UpperCamelCase__  =    2
      UpperCamelCase__  =    0
      while 4 * b + a <= n:
            UpperCamelCase__  =    b, 4 * b + a
            count += a
      return count + b


if __name__ == "__main__":
  print(F"""{solution() = }""")









'''simple docstring'''







import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


if TYPE_CHECKING:
  import sqlitea

  import sqlalchemy


a__  : Optional[int]				=	datasets.utils.logging.get_logger(__name__)
@dataclass
class  lowercase_					(   datasets.BuilderConfig       ):
    __UpperCAmelCase             =     None
    __UpperCAmelCase             =     None
    __UpperCAmelCase             =     None
    __UpperCAmelCase             =     True
    __UpperCAmelCase             =     None
    __UpperCAmelCase             =     None
    __UpperCAmelCase             =     None
    __UpperCAmelCase             =     10000
    __UpperCAmelCase             =     None


    def        __a							(					self   ):
          if self.sql is None:
                raise ValueError("sql must be specified"   )
          if self.con is None:
                raise ValueError("con must be specified"   )


    def        __a							(					self  , a  , a = None  , ):
          UpperCamelCase__  =    config_kwargs.copy()
          # We need to stringify the Selectable object to make its hash deterministic

          # The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
          UpperCamelCase__  =    config_kwargs["sql"]
          if not isinstance(a  , a   ):
                if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
                      import sqlalchemy

                      if isinstance(a  , sqlalchemy.sql.Selectable   ):
                            UpperCamelCase__  =    sqlalchemy.create_engine(config_kwargs["con"].split("://"   )[0] + "://"   )
                            UpperCamelCase__  =    str(sql.compile(dialect=engine.dialect   )   )
                            UpperCamelCase__  =    sql_str
                      else:
                            raise TypeError(
                                f'''Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(a   )}: {sql}'''   )
                else:
                      raise TypeError(
                          f'''Supported types for \'sql\' are string and sqlalchemy.sql.Selectable but got {type(a   )}: {sql}'''   )
          UpperCamelCase__  =    config_kwargs["con"]
          if not isinstance(a  , a   ):
                UpperCamelCase__  =    id(a   )
                logger.info(
                    f'''SQL connection \'con\' of type {type(a   )} couldn\'t be hashed properly. To enable hashing, specify \'con\' as URI string instead.'''   )

          return super().create_config_id(a  , custom_features=a   )


    @property
    def        __a							(					self   ):
          UpperCamelCase__  =    {
              "index_col": self.index_col,
              "columns": self.columns,
              "params": self.params,
              "coerce_float": self.coerce_float,
              "parse_dates": self.parse_dates,
          }
          return pd_read_sql_kwargs

class  lowercase_					(   datasets.ArrowBasedBuilder       ):
    __UpperCAmelCase             =     SqlConfig


    def        __a							(					self   ):
          return datasets.DatasetInfo(features=self.config.features   )


    def        __a							(					self  , a   ):
          return [datasets.SplitGenerator(name=datasets.Split.TRAIN  , gen_kwargs={}   )]


    def        __a							(					self  , a   ):
          if self.config.features is not None:
                UpperCamelCase__  =    self.config.features.arrow_schema
                if all(not require_storage_cast(a   ) for feature in self.config.features.values()   ):
                      # cheaper cast
                      UpperCamelCase__  =    pa.Table.from_arrays([pa_table[field.name] for field in schema]  , schema=a   )
                else:
                      # more expensive cast; allows str <-> int/float or str to Audio for example
                      UpperCamelCase__  =    table_cast(a  , a   )
          return pa_table


    def        __a							(					self   ):
          UpperCamelCase__  =    self.config.chunksize
          UpperCamelCase__  =    pd.read_sql(
              self.config.sql  , self.config.con  , chunksize=a  , **self.config.pd_read_sql_kwargs   )
          UpperCamelCase__  =    [sql_reader] if chunksize is None else sql_reader
          for chunk_idx, df in enumerate(a   ):
                UpperCamelCase__  =    pa.Table.from_pandas(a   )
                yield chunk_idx, self._cast_table(a   )





