



'''simple docstring'''


import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)







class 	UpperCAmelCase	(		unittest.TestCase):


 '''simple docstring'''




 def       lowercase_  (   self) ->      Dict:



      """simple docstring"""







      a_       		=["a", "b", "c"]

      # Defaults to last layer if both are None
      a_		,						a_       		=get_aligned_output_features_output_indices(lowerCAmelCase_							,  lowerCAmelCase_							,  lowerCAmelCase_)
      self.assertEqual(lowerCAmelCase_							,  ["c"])
      self.assertEqual(lowerCAmelCase_							,  [2])

      # Out indices set to match out features
      a_		,						a_       		=get_aligned_output_features_output_indices(["a", "c"]							,  lowerCAmelCase_							,  lowerCAmelCase_)
      self.assertEqual(lowerCAmelCase_							,  ["a", "c"])
      self.assertEqual(lowerCAmelCase_							,  [0, 2])

      # Out features set to match out indices
      a_		,						a_       		=get_aligned_output_features_output_indices(lowerCAmelCase_							,  [0, 2]							,  lowerCAmelCase_)
      self.assertEqual(lowerCAmelCase_							,  ["a", "c"])
      self.assertEqual(lowerCAmelCase_							,  [0, 2])

      # Out features selected from negative indices
      a_		,						a_       		=get_aligned_output_features_output_indices(lowerCAmelCase_							,  [-3, -1]							,  lowerCAmelCase_)
      self.assertEqual(lowerCAmelCase_							,  ["a", "c"])
      self.assertEqual(lowerCAmelCase_							,  [-3, -1])




 def       lowercase_  (   self) ->      Optional[Any]:



      """simple docstring"""







      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(["a", "b"]							,  (0, 1)							,  lowerCAmelCase_)

      # Out features must be a list
      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(("a", "b")							,  (0, 1)							,  ["a", "b"])

      # Out features must be a subset of stage names
      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(["a", "b"]							,  (0, 1)							,  ["a"])

      # Out indices must be a list or tuple
      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(lowerCAmelCase_							,  0							,  ["a", "b"])

      # Out indices must be a subset of stage names
      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(lowerCAmelCase_							,  (0, 1)							,  ["a"])

      # Out features and out indices must be the same length
      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(["a", "b"]							,  (0,)							,  ["a", "b", "c"])

      # Out features should match out indices
      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(["a", "b"]							,  (0, 2)							,  ["a", "b", "c"])

      # Out features and out indices should be in order
      with self.assertRaises(lowerCAmelCase_):
           verify_out_features_out_indices(["b", "a"]							,  (0, 1)							,  ["a", "b"])

      # Check passes with valid inputs
      verify_out_features_out_indices(["a", "b", "d"]							,  (0, 1, -1)							,  ["a", "b", "c", "d"])




 def       lowercase_  (   self) ->      Tuple:



      """simple docstring"""







      a_       		=BackboneMixin()

      a_       		=["a", "b", "c"]
      a_       		=["a", "c"]
      a_       		=[0, 2]

      # Check that the output features and indices are set correctly
      self.assertEqual(backbone.out_features							,  ["a", "c"])
      self.assertEqual(backbone.out_indices							,  [0, 2])

      # Check out features and indices are updated correctly
      a_       		=["a", "b"]
      self.assertEqual(backbone.out_features							,  ["a", "b"])
      self.assertEqual(backbone.out_indices							,  [0, 1])

      a_       		=[-3, -1]
      self.assertEqual(backbone.out_features							,  ["a", "c"])
      self.assertEqual(backbone.out_indices							,  [-3, -1])







'''simple docstring'''


from collections.abc import Sequence






def  UpperCAmelCase_       (		lowercase__ = None       ):


     '''simple docstring'''







     if nums is None or not nums:
          raise ValueError("Input sequence should not be empty"       )

     a_       		=nums[0]
     for i in range(1       ,	len(lowercase__       )       ):
          a_       		=nums[i]
          a_       		=max(lowercase__       ,	ans + num       ,	lowercase__       )

     return ans


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  # Try on a sample input from the user
  lowercase							       =			int(input('''Enter number of elements : ''').strip())
  lowercase							       =			list(map(int, input('''\nEnter the numbers : ''').strip().split()))[:n]
  print(max_subsequence_sum(array))


