

import heapq as hq
import math
from collections.abc import Iterator

class   _a					:




      """simple docstring"""

      def __init__(   self							:				Any						,			UpperCAmelCase							:				Dict	):
            A_						  =				str(id_	)
            A_						  =				None
            A_						  =				None
            A_						  =				[]
            A_						  =				{}  # {vertex:distance}





      def __lt__(   self							:				Dict						,			UpperCAmelCase							:				Union[str, Any]	):
            return self.key < other.key





      def __repr__(   self							:				Optional[int]	):
            return self.id





      def 		__A	(   self							:				Any						,			UpperCAmelCase							:				Optional[Any]	):
            self.neighbors.append(UpperCAmelCase	)







      def 		__A	(   self							:				int						,			UpperCAmelCase							:				Union[str, Any]						,			UpperCAmelCase							:				int	):
            A_						  =				weight




def       __snake_case						( __UpperCamelCase	: Any				,__UpperCamelCase	: str				,__UpperCamelCase	: Tuple				,__UpperCamelCase	: Dict    ):



      """simple docstring"""

      graph[a - 1].add_neighbor(graph[b - 1]    )
      graph[b - 1].add_neighbor(graph[a - 1]    )
      # add the edges:
      graph[a - 1].add_edge(graph[b - 1]				,__UpperCamelCase    )
      graph[b - 1].add_edge(graph[a - 1]				,__UpperCamelCase    )

def       __snake_case						( __UpperCamelCase	: list				,__UpperCamelCase	: Vertex    ):



      """simple docstring"""

      A_						  =				[]
      for u in graph:
            A_						  =				math.inf
            A_						  =				None
      A_						  =				0
      A_						  =				graph[:]
      while q:
            A_						  =				min(__UpperCamelCase    )
            q.remove(__UpperCamelCase    )
            for v in u.neighbors:
                  if (v in q) and (u.edges[v.id] < v.key):
                        A_						  =				u
                        A_						  =				u.edges[v.id]
      for i in range(1				,len(__UpperCamelCase    )    ):
            a.append((int(graph[i].id    ) + 1, int(graph[i].pi.id    ) + 1)    )
      return a

def       __snake_case						( __UpperCamelCase	: list				,__UpperCamelCase	: Vertex    ):



      """simple docstring"""

      for u in graph:
            A_						  =				math.inf
            A_						  =				None
      A_						  =				0

      A_						  =				list(__UpperCamelCase    )
      hq.heapify(__UpperCamelCase    )

      while h:
            A_						  =				hq.heappop(__UpperCamelCase    )
            for v in u.neighbors:
                  if (v in h) and (u.edges[v.id] < v.key):
                        A_						  =				u
                        A_						  =				u.edges[v.id]
                        hq.heapify(__UpperCamelCase    )

      for i in range(1				,len(__UpperCamelCase    )    ):
            yield (int(graph[i].id    ) + 1, int(graph[i].pi.id    ) + 1)

def       __snake_case						( ):



      """simple docstring"""



if __name__ == "__main__":
      import doctest

      doctest.testmod()






from __future__ import annotations

def   __snake_case    (       _lowerCAmelCase			:			list[int]					,					_lowerCAmelCase			:			int						)			->    list[list[int]]:
   A_       :					list[list[int]]        =      []
   A_       :					list[int]        =      []
   A_       :					Dict        =      0
   A_       :					str        =      sum(_lowerCAmelCase						)
   create_state_space_tree(_lowerCAmelCase					,					_lowerCAmelCase					,					_lowerCAmelCase					,					_lowerCAmelCase					,					_lowerCAmelCase					,					_lowerCAmelCase						)
   return result

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





print(*result)
