ShwStone/humaneval-leetcode huggingface dataset:
def longestStrChain(words: List[str]) -> int:
    """
    You are given an array of words where each word consists of lowercase English letters.
    wordA is a predecessor of wordB if and only if we can insert exactly one letter anywhere in wordA without changing the order of the other characters to make it equal to wordB.
    
    For example, "abc" is a predecessor of "abac", while "cba" is not a predecessor of "bcad".
    
    A word chain is a sequence of words [word1, word2, ..., wordk] with k >= 1, where word1 is a predecessor of word2, word2 is a predecessor of word3, and so on. A single word is trivially a word chain with k == 1.
    Return the length of the longest possible word chain with words chosen from the given list of words.
    
    Example 1:
    
    >>> longestStrChain(words = ["a","b","ba","bca","bda","bdca"])
    >>> 4
    Explanation: One of the longest word chains is ["a","ba","bda","bdca"].
    
    Example 2:
    
    >>> longestStrChain(words = ["xbc","pcxbcf","xb","cxbc","pcxbc"])
    >>> 5
    Explanation: All the words can be put in a word chain ["xb", "xbc", "cxbc", "pcxbc", "pcxbcf"].
    
    Example 3:
    
    >>> longestStrChain(words = ["abcd","dbqca"])
    >>> 1
    Explanation: The trivial word chain ["abcd"] is one of the longest word chains.
    ["abcd","dbqca"] is not a valid word chain because the ordering of the letters is changed.
    """
def lastStoneWeightII(stones: List[int]) -> int:
    """
    You are given an array of integers stones where stones[i] is the weight of the ith stone.
    We are playing a game with the stones. On each turn, we choose any two stones and smash them together. Suppose the stones have weights x and y with x <= y. The result of this smash is:
    
    If x == y, both stones are destroyed, and
    If x != y, the stone of weight x is destroyed, and the stone of weight y has new weight y - x.
    
    At the end of the game, there is at most one stone left.
    Return the smallest possible weight of the left stone. If there are no stones left, return 0.
    
    Example 1:
    
    >>> lastStoneWeightII(stones = [2,7,4,1,8,1])
    >>> 1
    Explanation:
    We can combine 2 and 4 to get 2, so the array converts to [2,7,1,8,1] then,
    we can combine 7 and 8 to get 1, so the array converts to [2,1,1,1] then,
    we can combine 2 and 1 to get 1, so the array converts to [1,1,1] then,
    we can combine 1 and 1 to get 0, so the array converts to [1], then that's the optimal value.
    
    Example 2:
    
    >>> lastStoneWeightII(stones = [31,26,33,21,40])
    >>> 5
    """
def heightChecker(heights: List[int]) -> int:
    """
    A school is trying to take an annual photo of all the students. The students are asked to stand in a single file line in non-decreasing order by height. Let this ordering be represented by the integer array expected where expected[i] is the expected height of the ith student in line.
    You are given an integer array heights representing the current order that the students are standing in. Each heights[i] is the height of the ith student in line (0-indexed).
    Return the number of indices where heights[i] != expected[i].
    
    Example 1:
    
    >>> heightChecker(heights = [1,1,4,2,1,3])
    >>> 3
    Explanation:
    heights:  [1,1,4,2,1,3]
    expected: [1,1,1,2,3,4]
    Indices 2, 4, and 5 do not match.
    
    Example 2:
    
    >>> heightChecker(heights = [5,1,2,3,4])
    >>> 5
    Explanation:
    heights:  [5,1,2,3,4]
    expected: [1,2,3,4,5]
    All indices do not match.
    
    Example 3:
    
    >>> heightChecker(heights = [1,2,3,4,5])
    >>> 0
    Explanation:
    heights:  [1,2,3,4,5]
    expected: [1,2,3,4,5]
    All indices match.
    """
def maxSatisfied(customers: List[int], grumpy: List[int], minutes: int) -> int:
    """
    There is a bookstore owner that has a store open for n minutes. You are given an integer array customers of length n where customers[i] is the number of the customers that enter the store at the start of the ith minute and all those customers leave after the end of that minute.
    During certain minutes, the bookstore owner is grumpy. You are given a binary array grumpy where grumpy[i] is 1 if the bookstore owner is grumpy during the ith minute, and is 0 otherwise.
    When the bookstore owner is grumpy, the customers entering during that minute are not satisfied. Otherwise, they are satisfied.
    The bookstore owner knows a secret technique to remain not grumpy for minutes consecutive minutes, but this technique can only be used once.
    Return the maximum number of customers that can be satisfied throughout the day.
    
    Example 1:
    
    >>> maxSatisfied(customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,0,1,0,1], minutes = 3)
    >>> 16
    Explanation:
    The bookstore owner keeps themselves not grumpy for the last 3 minutes.
    The maximum number of customers that can be satisfied = 1 + 1 + 1 + 1 + 7 + 5 = 16.
    
    Example 2:
    
    >>> maxSatisfied(customers = [1], grumpy = [0], minutes = 1)
    >>> 1
    """
def prevPermOpt1(arr: List[int]) -> List[int]:
    """
    Given an array of positive integers arr (not necessarily distinct), return the lexicographically largest permutation that is smaller than arr, that can be made with exactly one swap. If it cannot be done, then return the same array.
    Note that a swap exchanges the positions of two numbers arr[i] and arr[j]
    
    Example 1:
    
    >>> prevPermOpt1(arr = [3,2,1])
    >>> [3,1,2]
    Explanation: Swapping 2 and 1.
    
    Example 2:
    
    >>> prevPermOpt1(arr = [1,1,5])
    >>> [1,1,5]
    Explanation: This is already the smallest permutation.
    
    Example 3:
    
    >>> prevPermOpt1(arr = [1,9,4,6,7])
    >>> [1,7,4,6,9]
    Explanation: Swapping 9 and 7.
    """
def rearrangeBarcodes(barcodes: List[int]) -> List[int]:
    """
    In a warehouse, there is a row of barcodes, where the ith barcode is barcodes[i].
    Rearrange the barcodes so that no two adjacent barcodes are equal. You may return any answer, and it is guaranteed an answer exists.
    
    Example 1:
    >>> rearrangeBarcodes(barcodes = [1,1,1,2,2,2])
    >>> [2,1,2,1,2,1]
    Example 2:
    >>> rearrangeBarcodes(barcodes = [1,1,1,1,2,2,3,3])
    >>> [1,3,1,3,1,2,1,2]
    """
def shortestWay(source: str, target: str) -> int:
    """
    A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., "ace" is a subsequence of "abcde" while "aec" is not).
    Given two strings source and target, return the minimum number of subsequences of source such that their concatenation equals target. If the task is impossible, return -1.
    
    Example 1:
    
    >>> shortestWay(source = "abc", target = "abcbc")
    >>> 2
    Explanation: The target "abcbc" can be formed by "abc" and "bc", which are subsequences of source "abc".
    
    Example 2:
    
    >>> shortestWay(source = "abc", target = "acdbc")
    >>> -1
    Explanation: The target string cannot be constructed from the subsequences of source string due to the character "d" in target string.
    
    Example 3:
    
    >>> shortestWay(source = "xyz", target = "xzyxz")
    >>> 3
    Explanation: The target string can be constructed as follows "xz" + "y" + "xz".
    """
def confusingNumber(n: int) -> bool:
    """
    A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.
    We can rotate digits of a number by 180 degrees to form new digits.
    
    When 0, 1, 6, 8, and 9 are rotated 180 degrees, they become 0, 1, 9, 8, and 6 respectively.
    When 2, 3, 4, 5, and 7 are rotated 180 degrees, they become invalid.
    
    Note that after rotating a number, we can ignore leading zeros.
    
    For example, after rotating 8000, we have 0008 which is considered as just 8.
    
    Given an integer n, return true if it is a confusing number, or false otherwise.
    
    Example 1:
    
    
    >>> confusingNumber(n = 6)
    >>> true
    Explanation: We get 9 after rotating 6, 9 is a valid number, and 9 != 6.
    
    Example 2:
    
    
    >>> confusingNumber(n = 89)
    >>> true
    Explanation: We get 68 after rotating 89, 68 is a valid number and 68 != 89.
    
    Example 3:
    
    
    >>> confusingNumber(n = 11)
    >>> false
    Explanation: We get 11 after rotating 11, 11 is a valid number but the value remains the same, thus 11 is not a confusing number
    """
def assignBikes(workers: List[List[int]], bikes: List[List[int]]) -> List[int]:
    """
    On a campus represented on the X-Y plane, there are n workers and m bikes, with n <= m.
    You are given an array workers of length n where workers[i] = [xi, yi] is the position of the ith worker. You are also given an array bikes of length m where bikes[j] = [xj, yj] is the position of the jth bike. All the given positions are unique.
    Assign a bike to each worker. Among the available bikes and workers, we choose the (workeri, bikej) pair with the shortest Manhattan distance between each other and assign the bike to that worker.
    If there are multiple (workeri, bikej) pairs with the same shortest Manhattan distance, we choose the pair with the smallest worker index. If there are multiple ways to do that, we choose the pair with the smallest bike index. Repeat this process until there are no available workers.
    Return an array answer of length n, where answer[i] is the index (0-indexed) of the bike that the ith worker is assigned to.
    The Manhattan distance between two points p1 and p2 is Manhattan(p1, p2) = |p1.x - p2.x| + |p1.y - p2.y|.
    
    Example 1:
    
    
    >>> assignBikes(workers = [[0,0],[2,1]], bikes = [[1,2],[3,3]])
    >>> [1,0]
    Explanation: Worker 1 grabs Bike 0 as they are closest (without ties), and Worker 0 is assigned Bike 1. So the output is [1, 0].
    
    Example 2:
    
    
    >>> assignBikes(workers = [[0,0],[1,1],[2,0]], bikes = [[1,0],[2,2],[2,1]])
    >>> [0,2,1]
    Explanation: Worker 0 grabs Bike 0 at first. Worker 1 and Worker 2 share the same distance to Bike 2, thus Worker 1 is assigned to Bike 2, and Worker 2 will take Bike 1. So the output is [0,2,1].
    """
def minimizeError(prices: List[str], target: int) -> str:
    """
    Given an array of prices [p1,p2...,pn] and a target, round each price pi to Roundi(pi) so that the rounded array [Round1(p1),Round2(p2)...,Roundn(pn)] sums to the given target. Each operation Roundi(pi) could be either Floor(pi) or Ceil(pi).
    Return the string "-1" if the rounded array is impossible to sum to target. Otherwise, return the smallest rounding error, which is defined as Σ |Roundi(pi) - (pi)| for i from 1 to n, as a string with three places after the decimal.
    
    Example 1:
    
    >>> minimizeError(prices = ["0.700","2.800","4.900"], target = 8)
    >>> "1.000"
    Explanation:
    Use Floor, Ceil and Ceil operations to get (0.7 - 0) + (3 - 2.8) + (5 - 4.9) = 0.7 + 0.2 + 0.1 = 1.0 .
    
    Example 2:
    
    >>> minimizeError(prices = ["1.500","2.500","3.500"], target = 10)
    >>> "-1"
    Explanation: It is impossible to meet the target.
    
    Example 3:
    
    >>> minimizeError(prices = ["1.500","2.500","3.500"], target = 9)
    >>> "1.500"
    """
def leadsToDestination(n: int, edges: List[List[int]], source: int, destination: int) -> bool:
    """
    Given the edges of a directed graph where edges[i] = [ai, bi] indicates there is an edge between nodes ai and bi, and two nodes source and destination of this graph, determine whether or not all paths starting from source eventually, end at destination, that is:
    
    At least one path exists from the source node to the destination node
    If a path exists from the source node to a node with no outgoing edges, then that node is equal to destination.
    The number of possible paths from source to destination is a finite number.
    
    Return true if and only if all roads from source lead to destination.
    
    Example 1:
    
    
    >>> leadsToDestination(n = 3, edges = [[0,1],[0,2]], source = 0, destination = 2)
    >>> false
    Explanation: It is possible to reach and get stuck on both node 1 and node 2.
    
    Example 2:
    
    
    >>> leadsToDestination(n = 4, edges = [[0,1],[0,3],[1,2],[2,1]], source = 0, destination = 3)
    >>> false
    Explanation: We have two possibilities: to end at node 3, or to loop over node 1 and node 2 indefinitely.
    
    Example 3:
    
    
    >>> leadsToDestination(n = 4, edges = [[0,1],[0,2],[1,3],[2,3]], source = 0, destination = 3)
    >>> true
    """
def missingElement(nums: List[int], k: int) -> int:
    """
    Given an integer array nums which is sorted in ascending order and all of its elements are unique and given also an integer k, return the kth missing number starting from the leftmost number of the array.
    
    Example 1:
    
    >>> missingElement(nums = [4,7,9,10], k = 1)
    >>> 5
    Explanation: The first missing number is 5.
    
    Example 2:
    
    >>> missingElement(nums = [4,7,9,10], k = 3)
    >>> 8
    Explanation: The missing numbers are [5,6,8,...], hence the third missing number is 8.
    
    Example 3:
    
    >>> missingElement(nums = [1,2,4], k = 3)
    >>> 6
    Explanation: The missing numbers are [3,5,6,7,...], hence the third missing number is 6.
    """
def smallestEquivalentString(s1: str, s2: str, baseStr: str) -> str:
    """
    You are given two strings of the same length s1 and s2 and a string baseStr.
    We say s1[i] and s2[i] are equivalent characters.
    
    For example, if s1 = "abc" and s2 = "cde", then we have 'a' == 'c', 'b' == 'd', and 'c' == 'e'.
    
    Equivalent characters follow the usual rules of any equivalence relation:
    
    Reflexivity: 'a' == 'a'.
    Symmetry: 'a' == 'b' implies 'b' == 'a'.
    Transitivity: 'a' == 'b' and 'b' == 'c' implies 'a' == 'c'.
    
    For example, given the equivalency information from s1 = "abc" and s2 = "cde", "acd" and "aab" are equivalent strings of baseStr = "eed", and "aab" is the lexicographically smallest equivalent string of baseStr.
    Return the lexicographically smallest equivalent string of baseStr by using the equivalency information from s1 and s2.
    
    Example 1:
    
    >>> smallestEquivalentString(s1 = "parker", s2 = "morris", baseStr = "parser")
    >>> "makkek"
    Explanation: Based on the equivalency information in s1 and s2, we can group their characters as [m,p], [a,o], [k,r,s], [e,i].
    The characters in each group are equivalent and sorted in lexicographical order.
    So the answer is "makkek".
    
    Example 2:
    
    >>> smallestEquivalentString(s1 = "hello", s2 = "world", baseStr = "hold")
    >>> "hdld"
    Explanation: Based on the equivalency information in s1 and s2, we can group their characters as [h,w], [d,e,o], [l,r].
    So only the second letter 'o' in baseStr is changed to 'd', the answer is "hdld".
    
    Example 3:
    
    >>> smallestEquivalentString(s1 = "leetcode", s2 = "programs", baseStr = "sourcecode")
    >>> "aauaaaaada"
    Explanation: We group the equivalent characters in s1 and s2 as [a,o,e,r,s,c], [l,p], [g,t] and [d,m], thus all letters in baseStr except 'u' and 'd' are transformed to 'a', the answer is "aauaaaaada".
    """
def longestRepeatingSubstring(s: str) -> int:
    """
    Given a string s, return the length of the longest repeating substrings. If no repeating substring exists, return 0.
    
    Example 1:
    
    >>> longestRepeatingSubstring(s = "abcd")
    >>> 0
    Explanation: There is no repeating substring.
    
    Example 2:
    
    >>> longestRepeatingSubstring(s = "abbaba")
    >>> 2
    Explanation: The longest repeating substrings are "ab" and "ba", each of which occurs twice.
    
    Example 3:
    
    >>> longestRepeatingSubstring(s = "aabcaabdaab")
    >>> 3
    Explanation: The longest repeating substring is "aab", which occurs 3 times.
    """
def validSubarrays(nums: List[int]) -> int:
    """
    Given an integer array nums, return the number of non-empty subarrays with the leftmost element of the subarray not larger than other elements in the subarray.
    A subarray is a contiguous part of an array.
    
    Example 1:
    
    >>> validSubarrays(nums = [1,4,2,5,3])
    >>> 11
    Explanation: There are 11 valid subarrays: [1],[4],[2],[5],[3],[1,4],[2,5],[1,4,2],[2,5,3],[1,4,2,5],[1,4,2,5,3].
    
    Example 2:
    
    >>> validSubarrays(nums = [3,2,1])
    >>> 3
    Explanation: The 3 valid subarrays are: [3],[2],[1].
    
    Example 3:
    
    >>> validSubarrays(nums = [2,2,2])
    >>> 6
    Explanation: There are 6 valid subarrays: [2],[2],[2],[2,2],[2,2],[2,2,2].
    """
def fixedPoint(arr: List[int]) -> int:
    """
    Given an array of distinct integers arr, where arr is sorted in ascending order, return the smallest index i that satisfies arr[i] == i. If there is no such index, return -1.
    
    Example 1:
    
    >>> fixedPoint(arr = [-10,-5,0,3,7])
    >>> 3
    Explanation: For the given array, arr[0] = -10, arr[1] = -5, arr[2] = 0, arr[3] = 3, thus the output is 3.
    Example 2:
    
    >>> fixedPoint(arr = [0,2,5,8,17])
    >>> 0
    Explanation: arr[0] = 0, thus the output is 0.
    Example 3:
    
    >>> fixedPoint(arr = [-10,-5,3,4,7,9])
    >>> -1
    Explanation: There is no such i that arr[i] == i, thus the output is -1.
    """
def indexPairs(text: str, words: List[str]) -> List[List[int]]:
    """
    Given a string text and an array of strings words, return an array of all index pairs [i, j] so that the substring text[i...j] is in words.
    Return the pairs [i, j] in sorted order (i.e., sort them by their first coordinate, and in case of ties sort them by their second coordinate).
    
    Example 1:
    
    >>> indexPairs(text = "thestoryofleetcodeandme", words = ["story","fleet","leetcode"])
    >>> [[3,7],[9,13],[10,17]]
    
    Example 2:
    
    >>> indexPairs(text = "ababa", words = ["aba","ab"])
    >>> [[0,1],[0,2],[2,3],[2,4]]
    Explanation: Notice that matches can overlap, see "aba" is found in [0,2] and [2,4].
    """
def assignBikes(workers: List[List[int]], bikes: List[List[int]]) -> int:
    """
    On a campus represented as a 2D grid, there are n workers and m bikes, with n <= m. Each worker and bike is a 2D coordinate on this grid.
    We assign one unique bike to each worker so that the sum of the Manhattan distances between each worker and their assigned bike is minimized.
    Return the minimum possible sum of Manhattan distances between each worker and their assigned bike.
    The Manhattan distance between two points p1 and p2 is Manhattan(p1, p2) = |p1.x - p2.x| + |p1.y - p2.y|.
    
    Example 1:
    
    
    >>> assignBikes(workers = [[0,0],[2,1]], bikes = [[1,2],[3,3]])
    >>> 6
    Explanation:
    We assign bike 0 to worker 0, bike 1 to worker 1. The Manhattan distance of both assignments is 3, so the output is 6.
    
    Example 2:
    
    
    >>> assignBikes(workers = [[0,0],[1,1],[2,0]], bikes = [[1,0],[2,2],[2,1]])
    >>> 4
    Explanation:
    We first assign bike 0 to worker 0, then assign bike 1 to worker 1 or worker 2, bike 2 to worker 2 or worker 1. Both assignments lead to sum of the Manhattan distances as 4.
    
    Example 3:
    
    >>> assignBikes(workers = [[0,0],[1,0],[2,0],[3,0],[4,0]], bikes = [[0,999],[1,999],[2,999],[3,999],[4,999]])
    >>> 4995
    """
def digitsCount(d: int, low: int, high: int) -> int:
    """
    Given a single-digit integer d and two integers low and high, return the number of times that d occurs as a digit in all integers in the inclusive range [low, high].
    
    Example 1:
    
    >>> digitsCount(d = 1, low = 1, high = 13)
    >>> 6
    Explanation: The digit d = 1 occurs 6 times in 1, 10, 11, 12, 13.
    Note that the digit d = 1 occurs twice in the number 11.
    
    Example 2:
    
    >>> digitsCount(d = 3, low = 100, high = 250)
    >>> 35
    Explanation: The digit d = 3 occurs 35 times in 103,113,123,130,131,...,238,239,243.
    """
def gcdOfStrings(str1: str, str2: str) -> str:
    """
    For two strings s and t, we say "t divides s" if and only if s = t + t + t + ... + t + t (i.e., t is concatenated with itself one or more times).
    Given two strings str1 and str2, return the largest string x such that x divides both str1 and str2.
    
    Example 1:
    
    >>> gcdOfStrings(str1 = "ABCABC", str2 = "ABC")
    >>> "ABC"
    
    Example 2:
    
    >>> gcdOfStrings(str1 = "ABABAB", str2 = "ABAB")
    >>> "AB"
    
    Example 3:
    
    >>> gcdOfStrings(str1 = "LEET", str2 = "CODE")
    >>> ""
    """
def maxEqualRowsAfterFlips(matrix: List[List[int]]) -> int:
    """
    You are given an m x n binary matrix matrix.
    You can choose any number of columns in the matrix and flip every cell in that column (i.e., Change the value of the cell from 0 to 1 or vice versa).
    Return the maximum number of rows that have all values equal after some number of flips.
    
    Example 1:
    
    >>> maxEqualRowsAfterFlips(matrix = [[0,1],[1,1]])
    >>> 1
    Explanation: After flipping no values, 1 row has all values equal.
    
    Example 2:
    
    >>> maxEqualRowsAfterFlips(matrix = [[0,1],[1,0]])
    >>> 2
    Explanation: After flipping values in the first column, both rows have equal values.
    
    Example 3:
    
    >>> maxEqualRowsAfterFlips(matrix = [[0,0,0],[0,0,1],[1,1,0]])
    >>> 2
    Explanation: After flipping values in the first two columns, the last two rows have equal values.
    """
def addNegabinary(arr1: List[int], arr2: List[int]) -> List[int]:
    """
    Given two numbers arr1 and arr2 in base -2, return the result of adding them together.
    Each number is given in array format:  as an array of 0s and 1s, from most significant bit to least significant bit.  For example, arr = [1,1,0,1] represents the number (-2)^3 + (-2)^2 + (-2)^0 = -3.  A number arr in array, format is also guaranteed to have no leading zeros: either arr == [0] or arr[0] == 1.
    Return the result of adding arr1 and arr2 in the same format: as an array of 0s and 1s with no leading zeros.
    
    Example 1:
    
    >>> addNegabinary(arr1 = [1,1,1,1,1], arr2 = [1,0,1])
    >>> [1,0,0,0,0]
    Explanation: arr1 represents 11, arr2 represents 5, the output represents 16.
    
    Example 2:
    
    >>> addNegabinary(arr1 = [0], arr2 = [0])
    >>> [0]
    
    Example 3:
    
    >>> addNegabinary(arr1 = [0], arr2 = [1])
    >>> [1]
    """
def numSubmatrixSumTarget(matrix: List[List[int]], target: int) -> int:
    """
    Given a matrix and a target, return the number of non-empty submatrices that sum to target.
    A submatrix x1, y1, x2, y2 is the set of all cells matrix[x][y] with x1 <= x <= x2 and y1 <= y <= y2.
    Two submatrices (x1, y1, x2, y2) and (x1', y1', x2', y2') are different if they have some coordinate that is different: for example, if x1 != x1'.
    
    Example 1:
    
    
    >>> numSubmatrixSumTarget(matrix = [[0,1,0],[1,1,1],[0,1,0]], target = 0)
    >>> 4
    Explanation: The four 1x1 submatrices that only contain 0.
    
    Example 2:
    
    >>> numSubmatrixSumTarget(matrix = [[1,-1],[-1,1]], target = 0)
    >>> 5
    Explanation: The two 1x2 submatrices, plus the two 2x1 submatrices, plus the 2x2 submatrix.
    
    Example 3:
    
    >>> numSubmatrixSumTarget(matrix = [[904]], target = 0)
    >>> 0
    """
def findOcurrences(text: str, first: str, second: str) -> List[str]:
    """
    Given two strings first and second, consider occurrences in some text of the form "first second third", where second comes immediately after first, and third comes immediately after second.
    Return an array of all the words third for each occurrence of "first second third".
    
    Example 1:
    >>> findOcurrences(text = "alice is a good girl she is a good student", first = "a", second = "good")
    >>> ["girl","student"]
    Example 2:
    >>> findOcurrences(text = "we will we will rock you", first = "we", second = "will")
    >>> ["we","rock"]
    """