ShwStone/humaneval-leetcode huggingface dataset:
def minCost(nums: List[int]) -> int:
    """
    You are given an integer array nums. Your task is to remove all elements from the array by performing one of the following operations at each step until nums is empty:
    
    Choose any two elements from the first three elements of nums and remove them. The cost of this operation is the maximum of the two elements removed.
    If fewer than three elements remain in nums, remove all the remaining elements in a single operation. The cost of this operation is the maximum of the remaining elements.
    
    Return the minimum cost required to remove all the elements.
    
    Example 1:
    
    >>> minCost(nums = [6,2,8,4])
    >>> 12
    Explanation:
    Initially, nums = [6, 2, 8, 4].
    
    In the first operation, remove nums[0] = 6 and nums[2] = 8 with a cost of max(6, 8) = 8. Now, nums = [2, 4].
    In the second operation, remove the remaining elements with a cost of max(2, 4) = 4.
    
    The cost to remove all elements is 8 + 4 = 12. This is the minimum cost to remove all elements in nums. Hence, the output is 12.
    
    Example 2:
    
    >>> minCost(nums = [2,1,3,3])
    >>> 5
    Explanation:
    Initially, nums = [2, 1, 3, 3].
    
    In the first operation, remove nums[0] = 2 and nums[1] = 1 with a cost of max(2, 1) = 2. Now, nums = [3, 3].
    In the second operation remove the remaining elements with a cost of max(3, 3) = 3.
    
    The cost to remove all elements is 2 + 3 = 5. This is the minimum cost to remove all elements in nums. Hence, the output is 5.
    """
def permute(n: int, k: int) -> List[int]:
    """
    Given two integers, n and k, an alternating permutation is a permutation of the first n positive integers such that no two adjacent elements are both odd or both even.
    Return the k-th alternating permutation sorted in lexicographical order. If there are fewer than k valid alternating permutations, return an empty list.
    
    Example 1:
    
    >>> permute(n = 4, k = 6)
    >>> [3,4,1,2]
    Explanation:
    The lexicographically-sorted alternating permutations of [1, 2, 3, 4] are:
    
    [1, 2, 3, 4]
    [1, 4, 3, 2]
    [2, 1, 4, 3]
    [2, 3, 4, 1]
    [3, 2, 1, 4]
    [3, 4, 1, 2] ← 6th permutation
    [4, 1, 2, 3]
    [4, 3, 2, 1]
    
    Since k = 6, we return [3, 4, 1, 2].
    
    Example 2:
    
    >>> permute(n = 3, k = 2)
    >>> [3,2,1]
    Explanation:
    The lexicographically-sorted alternating permutations of [1, 2, 3] are:
    
    [1, 2, 3]
    [3, 2, 1] ← 2nd permutation
    
    Since k = 2, we return [3, 2, 1].
    
    Example 3:
    
    >>> permute(n = 2, k = 3)
    >>> []
    Explanation:
    The lexicographically-sorted alternating permutations of [1, 2] are:
    
    [1, 2]
    [2, 1]
    
    There are only 2 alternating permutations, but k = 3, which is out of range. Thus, we return an empty list [].
    """
def largestInteger(nums: List[int], k: int) -> int:
    """
    You are given an integer array nums and an integer k.
    An integer x is almost missing from nums if x appears in exactly one subarray of size k within nums.
    Return the largest almost missing integer from nums. If no such integer exists, return -1.
    A subarray is a contiguous sequence of elements within an array.
    
    Example 1:
    
    >>> largestInteger(nums = [3,9,2,1,7], k = 3)
    >>> 7
    Explanation:
    
    1 appears in 2 subarrays of size 3: [9, 2, 1] and [2, 1, 7].
    2 appears in 3 subarrays of size 3: [3, 9, 2], [9, 2, 1], [2, 1, 7].
    3 appears in 1 subarray of size 3: [3, 9, 2].
    7 appears in 1 subarray of size 3: [2, 1, 7].
    9 appears in 2 subarrays of size 3: [3, 9, 2], and [9, 2, 1].
    
    We return 7 since it is the largest integer that appears in exactly one subarray of size k.
    
    Example 2:
    
    >>> largestInteger(nums = [3,9,7,2,1,7], k = 4)
    >>> 3
    Explanation:
    
    1 appears in 2 subarrays of size 4: [9, 7, 2, 1], [7, 2, 1, 7].
    2 appears in 3 subarrays of size 4: [3, 9, 7, 2], [9, 7, 2, 1], [7, 2, 1, 7].
    3 appears in 1 subarray of size 4: [3, 9, 7, 2].
    7 appears in 3 subarrays of size 4: [3, 9, 7, 2], [9, 7, 2, 1], [7, 2, 1, 7].
    9 appears in 2 subarrays of size 4: [3, 9, 7, 2], [9, 7, 2, 1].
    
    We return 3 since it is the largest and only integer that appears in exactly one subarray of size k.
    
    Example 3:
    
    >>> largestInteger(nums = [0,0], k = 1)
    >>> -1
    Explanation:
    There is no integer that appears in only one subarray of size 1.
    """
def longestPalindromicSubsequence(s: str, k: int) -> int:
    """
    You are given a string s and an integer k.
    In one operation, you can replace the character at any position with the next or previous letter in the alphabet (wrapping around so that 'a' is after 'z'). For example, replacing 'a' with the next letter results in 'b', and replacing 'a' with the previous letter results in 'z'. Similarly, replacing 'z' with the next letter results in 'a', and replacing 'z' with the previous letter results in 'y'.
    Return the length of the longest palindromic subsequence of s that can be obtained after performing at most k operations.
    
    Example 1:
    
    >>> longestPalindromicSubsequence(s = "abced", k = 2)
    >>> 3
    Explanation:
    
    Replace s[1] with the next letter, and s becomes "acced".
    Replace s[4] with the previous letter, and s becomes "accec".
    
    The subsequence "ccc" forms a palindrome of length 3, which is the maximum.
    
    Example 2:
    
    >>> longestPalindromicSubsequence(s = "aaazzz", k = 4)
    >>> 6
    Explanation:
    
    Replace s[0] with the previous letter, and s becomes "zaazzz".
    Replace s[4] with the next letter, and s becomes "zaazaz".
    Replace s[3] with the next letter, and s becomes "zaaaaz".
    
    The entire string forms a palindrome of length 6.
    """
def maxSum(nums: List[int], k: int, m: int) -> int:
    """
    You are given an integer array nums and two integers, k and m.
    Return the maximum sum of k non-overlapping subarrays of nums, where each subarray has a length of at least m.
    
    Example 1:
    
    >>> maxSum(nums = [1,2,-1,3,3,4], k = 2, m = 2)
    >>> 13
    Explanation:
    The optimal choice is:
    
    Subarray nums[3..5] with sum 3 + 3 + 4 = 10 (length is 3 >= m).
    Subarray nums[0..1] with sum 1 + 2 = 3 (length is 2 >= m).
    
    The total sum is 10 + 3 = 13.
    
    Example 2:
    
    >>> maxSum(nums = [-10,3,-1,-2], k = 4, m = 1)
    >>> -10
    Explanation:
    The optimal choice is choosing each element as a subarray. The output is (-10) + 3 + (-1) + (-2) = -10.
    """
def generateString(str1: str, str2: str) -> str:
    """
    You are given two strings, str1 and str2, of lengths n and m, respectively.
    A string word of length n + m - 1 is defined to be generated by str1 and str2 if it satisfies the following conditions for each index 0 <= i <= n - 1:
    
    If str1[i] == 'T', the substring of word with size m starting at index i is equal to str2, i.e., word[i..(i + m - 1)] == str2.
    If str1[i] == 'F', the substring of word with size m starting at index i is not equal to str2, i.e., word[i..(i + m - 1)] != str2.
    
    Return the lexicographically smallest possible string that can be generated by str1 and str2. If no string can be generated, return an empty string "".
    
    Example 1:
    
    >>> generateString(str1 = "TFTF", str2 = "ab")
    >>> "ababa"
    Explanation:
    The table below represents the string "ababa"
    
    
    
    Index
    T/F
    Substring of length m
    
    
    0
    'T'
    "ab"
    
    
    1
    'F'
    "ba"
    
    
    2
    'T'
    "ab"
    
    
    3
    'F'
    "ba"
    
    
    
    The strings "ababa" and "ababb" can be generated by str1 and str2.
    Return "ababa" since it is the lexicographically smaller string.
    
    Example 2:
    
    >>> generateString(str1 = "TFTF", str2 = "abc")
    >>> ""
    Explanation:
    No string that satisfies the conditions can be generated.
    
    Example 3:
    
    >>> generateString(str1 = "F", str2 = "d")
    >>> "a"
    """
def maxProfit(workers: List[int], tasks: List[List[int]]) -> int:
    """
    You are given an integer array workers, where workers[i] represents the skill level of the ith worker. You are also given a 2D integer array tasks, where:
    
    tasks[i][0] represents the skill requirement needed to complete the task.
    tasks[i][1] represents the profit earned from completing the task.
    
    Each worker can complete at most one task, and they can only take a task if their skill level is equal to the task's skill requirement. An additional worker joins today who can take up any task, regardless of the skill requirement.
    Return the maximum total profit that can be earned by optimally assigning the tasks to the workers.
    
    Example 1:
    
    >>> maxProfit(workers = [1,2,3,4,5], tasks = [[1,100],[2,400],[3,100],[3,400]])
    >>> 1000
    Explanation:
    
    Worker 0 completes task 0.
    Worker 1 completes task 1.
    Worker 2 completes task 3.
    The additional worker completes task 2.
    
    
    Example 2:
    
    >>> maxProfit(workers = [10,10000,100000000], tasks = [[1,100]])
    >>> 100
    Explanation:
    Since no worker matches the skill requirement, only the additional worker can complete task 0.
    
    Example 3:
    
    >>> maxProfit(workers = [7], tasks = [[3,3],[3,3]])
    >>> 3
    Explanation:
    The additional worker completes task 1. Worker 0 cannot work since no task has a skill requirement of 7.
    """
def numOfUnplacedFruits(fruits: List[int], baskets: List[int]) -> int:
    """
    You are given two arrays of integers, fruits and baskets, each of length n, where fruits[i] represents the quantity of the ith type of fruit, and baskets[j] represents the capacity of the jth basket.
    From left to right, place the fruits according to these rules:
    
    Each fruit type must be placed in the leftmost available basket with a capacity greater than or equal to the quantity of that fruit type.
    Each basket can hold only one type of fruit.
    If a fruit type cannot be placed in any basket, it remains unplaced.
    
    Return the number of fruit types that remain unplaced after all possible allocations are made.
    
    Example 1:
    
    >>> numOfUnplacedFruits(fruits = [4,2,5], baskets = [3,5,4])
    >>> 1
    Explanation:
    
    fruits[0] = 4 is placed in baskets[1] = 5.
    fruits[1] = 2 is placed in baskets[0] = 3.
    fruits[2] = 5 cannot be placed in baskets[2] = 4.
    
    Since one fruit type remains unplaced, we return 1.
    
    Example 2:
    
    >>> numOfUnplacedFruits(fruits = [3,6,1], baskets = [6,4,7])
    >>> 0
    Explanation:
    
    fruits[0] = 3 is placed in baskets[0] = 6.
    fruits[1] = 6 cannot be placed in baskets[1] = 4 (insufficient capacity) but can be placed in the next available basket, baskets[2] = 7.
    fruits[2] = 1 is placed in baskets[1] = 4.
    
    Since all fruits are successfully placed, we return 0.
    """
def findMaxSum(nums1: List[int], nums2: List[int], k: int) -> List[int]:
    """
    You are given two integer arrays, nums1 and nums2, both of length n, along with a positive integer k.
    For each index i from 0 to n - 1, perform the following:
    
    Find all indices j where nums1[j] is less than nums1[i].
    Choose at most k values of nums2[j] at these indices to maximize the total sum.
    
    Return an array answer of size n, where answer[i] represents the result for the corresponding index i.
    
    Example 1:
    
    >>> findMaxSum(nums1 = [4,2,1,5,3], nums2 = [10,20,30,40,50], k = 2)
    >>> [80,30,0,80,50]
    Explanation:
    
    For i = 0: Select the 2 largest values from nums2 at indices [1, 2, 4] where nums1[j] < nums1[0], resulting in 50 + 30 = 80.
    For i = 1: Select the 2 largest values from nums2 at index [2] where nums1[j] < nums1[1], resulting in 30.
    For i = 2: No indices satisfy nums1[j] < nums1[2], resulting in 0.
    For i = 3: Select the 2 largest values from nums2 at indices [0, 1, 2, 4] where nums1[j] < nums1[3], resulting in 50 + 30 = 80.
    For i = 4: Select the 2 largest values from nums2 at indices [1, 2] where nums1[j] < nums1[4], resulting in 30 + 20 = 50.
    
    
    Example 2:
    
    >>> findMaxSum(nums1 = [2,2,2,2], nums2 = [3,1,2,3], k = 1)
    >>> [0,0,0,0]
    Explanation:
    Since all elements in nums1 are equal, no indices satisfy the condition nums1[j] < nums1[i] for any i, resulting in 0 for all positions.
    """
def maxSubarrays(n: int, conflictingPairs: List[List[int]]) -> int:
    """
    You are given an integer n which represents an array nums containing the numbers from 1 to n in order. Additionally, you are given a 2D array conflictingPairs, where conflictingPairs[i] = [a, b] indicates that a and b form a conflicting pair.
    Remove exactly one element from conflictingPairs. Afterward, count the number of non-empty subarrays of nums which do not contain both a and b for any remaining conflicting pair [a, b].
    Return the maximum number of subarrays possible after removing exactly one conflicting pair.
    
    Example 1:
    
    >>> maxSubarrays(n = 4, conflictingPairs = [[2,3],[1,4]])
    >>> 9
    Explanation:
    
    Remove [2, 3] from conflictingPairs. Now, conflictingPairs = [[1, 4]].
    There are 9 subarrays in nums where [1, 4] do not appear together. They are [1], [2], [3], [4], [1, 2], [2, 3], [3, 4], [1, 2, 3] and [2, 3, 4].
    The maximum number of subarrays we can achieve after removing one element from conflictingPairs is 9.
    
    
    Example 2:
    
    >>> maxSubarrays(n = 5, conflictingPairs = [[1,2],[2,5],[3,5]])
    >>> 12
    Explanation:
    
    Remove [1, 2] from conflictingPairs. Now, conflictingPairs = [[2, 5], [3, 5]].
    There are 12 subarrays in nums where [2, 5] and [3, 5] do not appear together.
    The maximum number of subarrays we can achieve after removing one element from conflictingPairs is 12.
    """
def applySubstitutions(replacements: List[List[str]], text: str) -> str:
    """
    You are given a replacements mapping and a text string that may contain placeholders formatted as %var%, where each var corresponds to a key in the replacements mapping. Each replacement value may itself contain one or more such placeholders. Each placeholder is replaced by the value associated with its corresponding replacement key.
    Return the fully substituted text string which does not contain any placeholders.
    
    Example 1:
    
    >>> applySubstitutions(replacements = [["A","abc"],["B","def"]], text = "%A%_%B%")
    >>> "abc_def"
    Explanation:
    
    The mapping associates "A" with "abc" and "B" with "def".
    Replace %A% with "abc" and %B% with "def" in the text.
    The final text becomes "abc_def".
    
    
    Example 2:
    
    >>> applySubstitutions(replacements = [["A","bce"],["B","ace"],["C","abc%B%"]], text = "%A%_%B%_%C%")
    >>> "bce_ace_abcace"
    Explanation:
    
    The mapping associates "A" with "bce", "B" with "ace", and "C" with "abc%B%".
    Replace %A% with "bce" and %B% with "ace" in the text.
    Then, for %C%, substitute %B% in "abc%B%" with "ace" to obtain "abcace".
    The final text becomes "bce_ace_abcace".
    """
def totalNumbers(digits: List[int]) -> int:
    """
    You are given an array of digits called digits. Your task is to determine the number of distinct three-digit even numbers that can be formed using these digits.
    Note: Each copy of a digit can only be used once per number, and there may not be leading zeros.
    
    Example 1:
    
    >>> totalNumbers(digits = [1,2,3,4])
    >>> 12
    Explanation: The 12 distinct 3-digit even numbers that can be formed are 124, 132, 134, 142, 214, 234, 312, 314, 324, 342, 412, and 432. Note that 222 cannot be formed because there is only 1 copy of the digit 2.
    
    Example 2:
    
    >>> totalNumbers(digits = [0,2,2])
    >>> 2
    Explanation: The only 3-digit even numbers that can be formed are 202 and 220. Note that the digit 2 can be used twice because it appears twice in the array.
    
    Example 3:
    
    >>> totalNumbers(digits = [6,6,6])
    >>> 1
    Explanation: Only 666 can be formed.
    
    Example 4:
    
    >>> totalNumbers(digits = [1,3,5])
    >>> 0
    Explanation: No even 3-digit numbers can be formed.
    """
def longestCommonPrefix(words: List[str], k: int) -> List[int]:
    """
    You are given an array of strings words and an integer k.
    For each index i in the range [0, words.length - 1], find the length of the longest common prefix among any k strings (selected at distinct indices) from the remaining array after removing the ith element.
    Return an array answer, where answer[i] is the answer for ith element. If removing the ith element leaves the array with fewer than k strings, answer[i] is 0.
    
    Example 1:
    
    >>> longestCommonPrefix(words = ["jump","run","run","jump","run"], k = 2)
    >>> [3,4,4,3,4]
    Explanation:
    
    Removing index 0 ("jump"):
    
    
    words becomes: ["run", "run", "jump", "run"]. "run" occurs 3 times. Choosing any two gives the longest common prefix "run" (length 3).
    
    
    Removing index 1 ("run"):
    
    words becomes: ["jump", "run", "jump", "run"]. "jump" occurs twice. Choosing these two gives the longest common prefix "jump" (length 4).
    
    
    Removing index 2 ("run"):
    
    words becomes: ["jump", "run", "jump", "run"]. "jump" occurs twice. Choosing these two gives the longest common prefix "jump" (length 4).
    
    
    Removing index 3 ("jump"):
    
    words becomes: ["jump", "run", "run", "run"]. "run" occurs 3 times. Choosing any two gives the longest common prefix "run" (length 3).
    
    
    Removing index 4 ("run"):
    
    words becomes: ["jump", "run", "run", "jump"]. "jump" occurs twice. Choosing these two gives the longest common prefix "jump" (length 4).
    
    
    
    
    Example 2:
    
    >>> longestCommonPrefix(words = ["dog","racer","car"], k = 2)
    >>> [0,0,0]
    Explanation:
    
    Removing any index results in an answer of 0.
    """
def longestSpecialPath(edges: List[List[int]], nums: List[int]) -> List[int]:
    """
    You are given an undirected tree rooted at node 0, with n nodes numbered from 0 to n - 1. This is represented by a 2D array edges of length n - 1, where edges[i] = [ui, vi, lengthi] indicates an edge between nodes ui and vi with length lengthi. You are also given an integer array nums, where nums[i] represents the value at node i.
    A special path is defined as a downward path from an ancestor node to a descendant node in which all node values are distinct, except for at most one value that may appear twice.
    Return an array result of size 2, where result[0] is the length of the longest special path, and result[1] is the minimum number of nodes in all possible longest special paths.
    
    Example 1:
    
    >>> longestSpecialPath(edges = [[0,1,1],[1,2,3],[1,3,1],[2,4,6],[4,7,2],[3,5,2],[3,6,5],[6,8,3]], nums = [1,1,0,3,1,2,1,1,0])
    >>> [9,3]
    Explanation:
    In the image below, nodes are colored by their corresponding values in nums.
    
    The longest special paths are 1 -> 2 -> 4 and 1 -> 3 -> 6 -> 8, both having a length of 9. The minimum number of nodes across all longest special paths is 3.
    
    Example 2:
    
    >>> longestSpecialPath(edges = [[1,0,3],[0,2,4],[0,3,5]], nums = [1,1,0,2])
    >>> [5,2]
    Explanation:
    
    The longest path is 0 -> 3 consisting of 2 nodes with a length of 5.
    """
def maxSum(nums: List[int]) -> int:
    """
    You are given an integer array nums.
    You are allowed to delete any number of elements from nums without making it empty. After performing the deletions, select a subarray of nums such that:
    
    All elements in the subarray are unique.
    The sum of the elements in the subarray is maximized.
    
    Return the maximum sum of such a subarray.
    
    Example 1:
    
    >>> maxSum(nums = [1,2,3,4,5])
    >>> 15
    Explanation:
    Select the entire array without deleting any element to obtain the maximum sum.
    
    Example 2:
    
    >>> maxSum(nums = [1,1,0,1,1])
    >>> 1
    Explanation:
    Delete the element nums[0] == 1, nums[1] == 1, nums[2] == 0, and nums[3] == 1. Select the entire array [1] to obtain the maximum sum.
    
    Example 3:
    
    >>> maxSum(nums = [1,2,-1,-2,1,0,-1])
    >>> 3
    Explanation:
    Delete the elements nums[2] == -1 and nums[3] == -2, and select the subarray [2, 1] from [1, 2, 1, 0, -1] to obtain the maximum sum.
    """
def solveQueries(nums: List[int], queries: List[int]) -> List[int]:
    """
    You are given a circular array nums and an array queries.
    For each query i, you have to find the following:
    
    The minimum distance between the element at index queries[i] and any other index j in the circular array, where nums[j] == nums[queries[i]]. If no such index exists, the answer for that query should be -1.
    
    Return an array answer of the same size as queries, where answer[i] represents the result for query i.
    
    Example 1:
    
    >>> solveQueries(nums = [1,3,1,4,1,3,2], queries = [0,3,5])
    >>> [2,-1,3]
    Explanation:
    
    Query 0: The element at queries[0] = 0 is nums[0] = 1. The nearest index with the same value is 2, and the distance between them is 2.
    Query 1: The element at queries[1] = 3 is nums[3] = 4. No other index contains 4, so the result is -1.
    Query 2: The element at queries[2] = 5 is nums[5] = 3. The nearest index with the same value is 1, and the distance between them is 3 (following the circular path: 5 -> 6 -> 0 -> 1).
    
    
    Example 2:
    
    >>> solveQueries(nums = [1,2,3,4], queries = [0,1,2,3])
    >>> [-1,-1,-1,-1]
    Explanation:
    Each value in nums is unique, so no index shares the same value as the queried element. This results in -1 for all queries.
    """
def minZeroArray(nums: List[int], queries: List[List[int]]) -> int:
    """
    You are given an integer array nums of length n and a 2D array queries, where queries[i] = [li, ri, vali].
    Each queries[i] represents the following action on nums:
    
    Select a subset of indices in the range [li, ri] from nums.
    Decrement the value at each selected index by exactly vali.
    
    A Zero Array is an array with all its elements equal to 0.
    Return the minimum possible non-negative value of k, such that after processing the first k queries in sequence, nums becomes a Zero Array. If no such k exists, return -1.
    
    Example 1:
    
    >>> minZeroArray(nums = [2,0,2], queries = [[0,2,1],[0,2,1],[1,1,3]])
    >>> 2
    Explanation:
    
    For query 0 (l = 0, r = 2, val = 1):
    
    Decrement the values at indices [0, 2] by 1.
    The array will become [1, 0, 1].
    
    
    For query 1 (l = 0, r = 2, val = 1):
    
    Decrement the values at indices [0, 2] by 1.
    The array will become [0, 0, 0], which is a Zero Array. Therefore, the minimum value of k is 2.
    
    
    
    
    Example 2:
    
    >>> minZeroArray(nums = [4,3,2,1], queries = [[1,3,2],[0,2,1]])
    >>> -1
    Explanation:
    It is impossible to make nums a Zero Array even after all the queries.
    
    Example 3:
    
    >>> minZeroArray(nums = [1,2,3,2,1], queries = [[0,1,1],[1,2,1],[2,3,2],[3,4,1],[4,4,1]])
    >>> 4
    Explanation:
    
    For query 0 (l = 0, r = 1, val = 1):
    
    Decrement the values at indices [0, 1] by 1.
    The array will become [0, 1, 3, 2, 1].
    
    
    For query 1 (l = 1, r = 2, val = 1):
    
    Decrement the values at indices [1, 2] by 1.
    The array will become [0, 0, 2, 2, 1].
    
    
    For query 2 (l = 2, r = 3, val = 2):
    
    Decrement the values at indices [2, 3] by 2.
    The array will become [0, 0, 0, 0, 1].
    
    
    For query 3 (l = 3, r = 4, val = 1):
    
    Decrement the value at index 4 by 1.
    The array will become [0, 0, 0, 0, 0]. Therefore, the minimum value of k is 4.
    
    
    
    
    Example 4:
    
    >>> minZeroArray(nums = [1,2,3,2,6], queries = [[0,1,1],[0,2,1],[1,4,2],[4,4,4],[3,4,1],[4,4,5]])
    >>> 4
    """