
'''simple docstring'''





import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE

class 						a   (				__magic_name__    ):
    _snake_case		    = ''''''
    _snake_case		    = (
        None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
    )
    _snake_case		    = None  # compression type in fsspec. ex: "gzip"
    _snake_case		    = None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz




    def __init__(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				str = "",    SCREAMING_SNAKE_CASE_	:				Optional[str] = None,    SCREAMING_SNAKE_CASE_	:				Optional[dict] = None,    **SCREAMING_SNAKE_CASE_	:				Union[str, Any]      ):
          super().__init__(self,    **SCREAMING_SNAKE_CASE_      )
          # always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
          snake_case       :     List[Any] =    fsspec.open(
              SCREAMING_SNAKE_CASE_,    mode='''rb''',    protocol=SCREAMING_SNAKE_CASE_,    compression=self.compression,    client_kwargs={
                  '''requote_redirect_url''': False,  # see https://github.com/huggingface/datasets/pull/5459
                  '''trust_env''': True,  # Enable reading proxy env variables.
                  **(target_options or {}).pop('''client_kwargs''',    {}      ),  # To avoid issues if it was already passed.
              },    **(target_options or {}),    )
          snake_case       :     Tuple =    os.path.basename(self.file.path.split('''::'''      )[0]      )
          snake_case       :     Optional[Any] =    (
              self.compressed_name[: self.compressed_name.rindex('''.'''      )]
              if '''.''' in self.compressed_name
              else self.compressed_name
          )
          snake_case       :     str =    None




    @classmethod
    def 	__snake_case							(							cls	:				Any,    SCREAMING_SNAKE_CASE_	:				int      ):
          # compressed file paths are always relative to the archive root
          return super()._strip_protocol(SCREAMING_SNAKE_CASE_      ).lstrip('''/'''      )




    def 	__snake_case							(							self	:				Optional[int]      ):
          if self.dir_cache is None:
                snake_case       :     Optional[int] =    {**self.file.fs.info(self.file.path      ), '''name''': self.uncompressed_name}
                snake_case       :     Tuple =    {f['''name''']: f}




    def 	__snake_case							(							self	:				List[Any],    SCREAMING_SNAKE_CASE_	:				str      ):
          return self.file.open().read()




    def 	__snake_case							(							self	:				List[Any],    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				str = "rb",    SCREAMING_SNAKE_CASE_	:				int=None,    SCREAMING_SNAKE_CASE_	:				Optional[int]=True,    SCREAMING_SNAKE_CASE_	:				List[Any]=None,    **SCREAMING_SNAKE_CASE_	:				Any,    ):
          snake_case       :     int =    self._strip_protocol(SCREAMING_SNAKE_CASE_      )
          if mode != "rb":
                raise ValueError(F"""Tried to read with mode {mode} on file {self.file.path} opened with mode 'rb'"""      )
          return self.file.open()




class 						a   (				__magic_name__    ):
    _snake_case		    = '''bz2'''
    _snake_case		    = '''bz2'''
    _snake_case		    = '''.bz2'''




class 						a   (				__magic_name__    ):
    _snake_case		    = '''gzip'''
    _snake_case		    = '''gzip'''
    _snake_case		    = '''.gz'''




class 						a   (				__magic_name__    ):
    _snake_case		    = '''lz4'''
    _snake_case		    = '''lz4'''
    _snake_case		    = '''.lz4'''




class 						a   (				__magic_name__    ):
    _snake_case		    = '''xz'''
    _snake_case		    = '''xz'''
    _snake_case		    = '''.xz'''




class 						a   (				__magic_name__    ):
    _snake_case		    = '''zstd'''
    _snake_case		    = '''zstd'''
    _snake_case		    = '''.zst'''




    def __init__(							self	:				int,    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				str = "rb",    SCREAMING_SNAKE_CASE_	:				Optional[str] = None,    SCREAMING_SNAKE_CASE_	:				Optional[dict] = None,    SCREAMING_SNAKE_CASE_	:				int = DEFAULT_BLOCK_SIZE,    **SCREAMING_SNAKE_CASE_	:				Optional[Any],    ):
          super().__init__(
              fo=SCREAMING_SNAKE_CASE_,    mode=SCREAMING_SNAKE_CASE_,    target_protocol=SCREAMING_SNAKE_CASE_,    target_options=SCREAMING_SNAKE_CASE_,    block_size=SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_,    )
          # We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
          #
          # File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
          #     out.close = close
          # AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
          #
          # see https://github.com/intake/filesystem_spec/issues/725
          snake_case       :     List[Any] =    self.file.__enter__

          class 						a   :




              def __init__(							self	:				int,    SCREAMING_SNAKE_CASE_	:				Dict      ):
                    snake_case       :     Dict =    file_




              def __enter__(							self	:				Optional[Any]      ):
                    self._file.__enter__()
                    return self




              def __exit__(							self	:				Union[str, Any],    *SCREAMING_SNAKE_CASE_	:				Dict,    **SCREAMING_SNAKE_CASE_	:				Tuple      ):
                    self._file.__exit__(*SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_      )




              def __iter__(							self	:				Union[str, Any]      ):
                    return iter(self._file      )




              def 	__snake_case							(							self	:				Union[str, Any]      ):
                    return next(self._file      )




              def __getattr__(							self	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				Optional[int]      ):
                    return getattr(self._file,    SCREAMING_SNAKE_CASE_      )

          def fixed_enter(*SCREAMING_SNAKE_CASE_	:				Optional[Any],    **SCREAMING_SNAKE_CASE_	:				List[Any]      ):
                return WrappedFile(_enter(*SCREAMING_SNAKE_CASE_,    **SCREAMING_SNAKE_CASE_      )      )

          snake_case       :     Union[str, Any] =    fixed_enter



'''simple docstring'''





from __future__ import annotations

def      A (       A_							:					list[int]    ,							A_							:					int       ):
						snake_case       :     list[list[int]] =    []
						snake_case       :     list[int] =    []
						snake_case       :     int =    0
						snake_case       :     int =    sum(A_       )
						create_state_space_tree(A_    ,							A_    ,							A_    ,							A_    ,							A_    ,							A_       )
						return result

def      A (       A_							:					list[int]    ,							A_							:					int    ,							A_							:					int    ,							A_							:					list[int]    ,							A_							:					list[list[int]]    ,							A_							:					int    ,							):
						if sum(A_       ) > max_sum or (remaining_nums_sum + sum(A_       )) < max_sum:
												return
						if sum(A_       ) == max_sum:
												result.append(A_       )
												return
						for index in range(A_    ,							len(A_       )       ):
												create_state_space_tree(
												    A_    ,							A_    ,							index + 1    ,							[*path, nums[index]]    ,							A_    ,							remaining_nums_sum - nums[index]    ,							)
UpperCAmelCase    					=   [3, 34, 4, 12, 5, 2]
UpperCAmelCase    					=   9
UpperCAmelCase    					=   generate_sum_of_subsets_soln(nums, max_sum)





print(*result)

