def issort_list(list1):
    result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
    return result


def empty_list(length):
 empty_list = [{} for _ in range(length)]
 return empty_list


def sort_sublists(list1):
    result = list(map(sorted,list1))
    return result


def remove_words(list1, charlist):
    new_list = []
    for line in list1:
        new_words = ' '.join([word for word in line.split() if not any([phrase in word for phrase in charlist])])
        new_list.append(new_words)
    return new_list


def max_sum_pair_diff_lessthan_K(arr, N, K):
	arr.sort()
	dp = [0] * N
	dp[0] = 0
	for i in range(1, N):
		dp[i] = dp[i-1]
		if (arr[i] - arr[i-1] < K):
			if (i >= 2):
				dp[i] = max(dp[i], dp[i-2] + arr[i] + arr[i-1]);
			else:
				dp[i] = max(dp[i], arr[i] + arr[i-1]);
	return dp[N - 1]


def two_unique_nums(nums):
  return [i for i in nums if nums.count(i)==1]


def unique_product(list_data):
    temp = list(set(list_data))
    p = 1
    for i in temp:
        p *= i
    return p


def surfacearea_cylinder(r,h):
  surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
  return surfacearea


def count_no (A,N,L,R):
    count = 0
    for i in range (L,R + 1):
        if (i % A != 0):
            count += 1
        if (count == N):
            break
    return (i)


def is_Sub_Array(A,B,n,m):
    i = 0; j = 0;
    while (i < n and j < m):
        if (A[i] == B[j]):
            i += 1;
            j += 1;
            if (j == m):
                return True;
        else:
            i = i - j + 1;
            j = 0;
    return False;


def last_Digit_Factorial(n):
    if (n == 0): return 1
    elif (n <= 2): return n
    elif (n == 3): return 6
    elif (n == 4): return 4
    else:
      return 0


def interleave_lists(list1,list2,list3):
    result = [el for pair in zip(list1, list2, list3) for el in pair]
    return result


def find_dissimilar(test_tup1, test_tup2):
  res = tuple(set(test_tup1) ^ set(test_tup2))
  return (res)


def even_ele(test_tuple, even_fnc):
	res = tuple()
	for ele in test_tuple:
		if isinstance(ele, tuple):
			res += (even_ele(ele, even_fnc), )
		elif even_fnc(ele):
			res += (ele, )
	return res
def extract_even(test_tuple):
  res = even_ele(test_tuple, lambda x: x % 2 == 0)
  return (res)


def surface_Area(b,s):
    return 2 * b * s + pow(b,2)


def my_dict(dict1):
  if bool(dict1):
     return False
  else:
     return True


def catalan_number(num):
    if num <=1:
         return 1
    res_num = 0
    for i in range(num):
        res_num += catalan_number(i) * catalan_number(num-i-1)
    return res_num


import re
def find_adverbs(text):
  for m in re.finditer(r"\w+ly", text):
    return ('%d-%d: %s' % (m.start(), m.end(), m.group(0)))


import heapq
def expensive_items(items,n):
  expensive_items = heapq.nlargest(n, items, key=lambda s: s['price'])
  return expensive_items


def split_Arr(a,n,k):
   b = a[:k]
   return (a[k::]+b[::])


def list_tuple(listx):
  tuplex = tuple(listx)
  return tuplex


def big_diff(nums):
     diff= max(nums)-min(nums)
     return diff


def perfect_squares(a, b):
    lists=[]
    for i in range (a,b+1):
        j = 1;
        while j*j <= i:
            if j*j == i:
                 lists.append(i)
            j = j+1
        i = i+1
    return lists


import cmath
def polar_rect(x,y):
 cn = complex(x,y)
 cn=cmath.polar(cn)
 cn1 = cmath.rect(2, cmath.pi)
 return (cn,cn1)


def swap_List(newList):
    size = len(newList)
    temp = newList[0]
    newList[0] = newList[size - 1]
    newList[size - 1] = temp
    return newList


def binomial_Coeff(n,k):
    C = [0] * (k + 1);
    C[0] = 1; # nC0 is 1
    for i in range(1,n + 1):
        for j in range(min(i, k),0,-1):
            C[j] = C[j] + C[j - 1];
    return C[k];
def sum_Of_product(n):
    return binomial_Coeff(2 * n,n - 1);


import re
def removezero_ip(ip):
 string = re.sub('\.[0]*', '.', ip)
 return string


def diff_even_odd(list1):
    first_even = next((el for el in list1 if el%2==0),-1)
    first_odd = next((el for el in list1 if el%2!=0),-1)
    return (first_even-first_odd)


def min_Swaps(str1,str2) :
    count = 0
    for i in range(len(str1)) :
        if str1[i] != str2[i] :
            count += 1
    if count % 2 == 0 :
        return (count // 2)
    else :
        return ("Not Possible")


import sys
def tuple_size(tuple_list):
  return (sys.getsizeof(tuple_list))


def find_kth(arr1, arr2, m, n, k):
	sorted1 = [0] * (m + n)
	i = 0
	j = 0
	d = 0
	while (i < m and j < n):
		if (arr1[i] < arr2[j]):
			sorted1[d] = arr1[i]
			i += 1
		else:
			sorted1[d] = arr2[j]
			j += 1
		d += 1
	while (i < m):
		sorted1[d] = arr1[i]
		d += 1
		i += 1
	while (j < n):
		sorted1[d] = arr2[j]
		d += 1
		j += 1
	return sorted1[k - 1]


def armstrong_number(number):
 sum = 0
 times = 0
 temp = number
 while temp > 0:
           times = times + 1
           temp = temp // 10
 temp = number
 while temp > 0:
           reminder = temp % 10
           sum = sum + (reminder ** times)
           temp //= 10
 if number == sum:
           return True
 else:
           return False


def sum_average(number):
 total = 0
 for value in range(1, number + 1):
    total = total + value
 average = total / number
 return (total,average)


def is_Even(n) :
    if (n^1 == n+1) :
        return True;
    else :
        return False;


class Pair(object):
	def __init__(self, a, b):
		self.a = a
		self.b = b
def max_chain_length(arr, n):
	max = 0
	mcl = [1 for i in range(n)]
	for i in range(1, n):
		for j in range(0, i):
			if (arr[i].a > arr[j].b and
				mcl[i] < mcl[j] + 1):
				mcl[i] = mcl[j] + 1
	for i in range(n):
		if (max < mcl[i]):
			max = mcl[i]
	return max


def first_repeated_char(str1):
  for index,c in enumerate(str1):
    if str1[:index+1].count(c) > 1:
      return c
  return "None"


def get_ludic(n):
	ludics = []
	for i in range(1, n + 1):
		ludics.append(i)
	index = 1
	while(index != len(ludics)):
		first_ludic = ludics[index]
		remove_index = index + first_ludic
		while(remove_index < len(ludics)):
			ludics.remove(ludics[remove_index])
			remove_index = remove_index + first_ludic - 1
		index += 1
	return ludics


def reverse_words(s):
        return ' '.join(reversed(s.split()))


def prime_num(num):
  if num >=1:
   for i in range(2, num//2):
     if (num % i) == 0:
                return False
     else:
                return True
  else:
          return False


import math
def radian_degree(degree):
 radian = degree*(math.pi/180)
 return radian


import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
def find_literals(text, pattern):
  match = re.search(pattern, text)
  s = match.start()
  e = match.end()
  return (match.re.pattern, s, e)


def bell_Number(n):
    bell = [[0 for i in range(n+1)] for j in range(n+1)]
    bell[0][0] = 1
    for i in range(1, n+1):
        bell[i][0] = bell[i-1][i-1]
        for j in range(1, i+1):
            bell[i][j] = bell[i-1][j-1] + bell[i][j-1]
    return bell[n][0]


def floor_Min(A,B,N):
    x = max(B - 1,N)
    return (A*x) // B


def remove_kth_element(list1, L):
    return  list1[:L-1] + list1[L:]


def max_of_nth(test_list, N):
  res = max([sub[N] for sub in test_list])
  return (res)


def merge(lst):
    return [list(ele) for ele in list(zip(*lst))]


def maximum_value(test_list):
  res = [(key, max(lst)) for key, lst in test_list]
  return (res)


def cummulative_sum(test_list):
  res = sum(map(sum, test_list))
  return (res)


def average_tuple(nums):
    result = [sum(x) / len(x) for x in zip(*nums)]
    return result


def tuple_modulo(test_tup1, test_tup2):
  res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
  return (res)


def min_Jumps(a, b, d):
    temp = a
    a = min(a, b)
    b = max(temp, b)
    if (d >= b):
        return (d + b - 1) / b
    if (d == 0):
        return 0
    if (d == a):
        return 1
    else:
        return 2


def div_list(nums1,nums2):
  result = map(lambda x, y: x / y, nums1, nums2)
  return list(result)


def move_num(test_str):
  res = ''
  dig = ''
  for ele in test_str:
    if ele.isdigit():
      dig += ele
    else:
      res += ele
  res += dig
  return (res)


def largest_subset(a, n):
	dp = [0 for i in range(n)]
	dp[n - 1] = 1;
	for i in range(n - 2, -1, -1):
		mxm = 0;
		for j in range(i + 1, n):
			if a[j] % a[i] == 0 or a[i] % a[j] == 0:
				mxm = max(mxm, dp[j])
		dp[i] = 1 + mxm
	return max(dp)


def increment_numerics(test_list, K):
  res = [str(int(ele) + K) if ele.isdigit() else ele for ele in test_list]
  return res


def get_median(arr1, arr2, n):
  i = 0
  j = 0
  m1 = -1
  m2 = -1
  count = 0
  while count < n + 1:
    count += 1
    if i == n:
      m1 = m2
      m2 = arr2[0]
      break
    elif j == n:
      m1 = m2
      m2 = arr1[0]
      break
    if arr1[i] <= arr2[j]:
      m1 = m2
      m2 = arr1[i]
      i += 1
    else:
      m1 = m2
      m2 = arr2[j]
      j += 1
  return (m1 + m2)/2


def nth_nums(nums,n):
 nth_nums = list(map(lambda x: x ** n, nums))
 return nth_nums


def is_upper(string):
  return (string.upper())


def swap_List(newList):
    size = len(newList)
    temp = newList[0]
    newList[0] = newList[size - 1]
    newList[size - 1] = temp
    return newList


def triangle_area(r) :
    if r < 0 :
        return -1
    return r * r


def find_First_Missing(array,start,end):
    if (start > end):
        return end + 1
    if (start != array[start]):
        return start;
    mid = int((start + end) / 2)
    if (array[mid] == mid):
        return find_First_Missing(array,mid+1,end)
    return find_First_Missing(array,start,mid)


MAX=1000;
def replace_spaces(string):
  string=string.strip()
  i=len(string)
  space_count=string.count(' ')
  new_length = i + space_count*2
  if new_length > MAX:
    return -1
  index = new_length-1
  string=list(string)
  for f in range(i-2, new_length-2):
    string.append('0')
  for j in range(i-1, 0, -1):
    if string[j] == ' ':
      string[index] = '0'
      string[index-1] = '2'
      string[index-2] = '%'
      index=index-3
    else:
      string[index] = string[j]
      index -= 1
  return ''.join(string)


def Split(list):
    ev_li = []
    for i in list:
        if (i % 2 == 0):
            ev_li.append(i)
    return ev_li


def adjac(ele, sub = []):
  if not ele:
     yield sub
  else:
     yield from [idx for j in range(ele[0] - 1, ele[0] + 2)
                for idx in adjac(ele[1:], sub + [j])]
def get_coordinates(test_tup):
  res = list(adjac(test_tup))
  return (res)


import re
text = 'Python Exercises'
def replace_spaces(text):
  text =text.replace (" ", "_")
  return (text)
  text =text.replace ("_", " ")
  return (text)


def move_zero(num_list):
    a = [0 for i in range(num_list.count(0))]
    x = [ i for i in num_list if i != 0]
    x.extend(a)
    return (x)


def pair_OR_Sum(arr,n) :
    ans = 0
    for i in range(0,n) :
        for j in range(i + 1,n) :
            ans = ans + (arr[i] ^ arr[j])
    return ans


def even_Power_Sum(n):
    sum = 0;
    for i in range(1,n + 1):
        j = 2*i;
        sum = sum + (j*j*j*j);
    return sum;


import heapq as hq
def heap_sort(iterable):
    h = []
    for value in iterable:
        hq.heappush(h, value)
    return [hq.heappop(h) for i in range(len(h))]


def Check_Solution(a,b,c):
    if (a == c):
        return ("Yes");
    else:
        return ("No");


def noprofit_noloss(actual_cost,sale_amount):
  if(sale_amount == actual_cost):
    return True
  else:
    return False


import math
def wind_chill(v,t):
 windchill = 13.12 + 0.6215*t -  11.37*math.pow(v, 0.16) + 0.3965*t*math.pow(v, 0.16)
 return int(round(windchill, 0))


def sample_nam(sample_names):
  sample_names=list(filter(lambda el:el[0].isupper() and el[1:].islower(),sample_names))
  return len(''.join(sample_names))


import re
def remove_parenthesis(items):
 for item in items:
    return (re.sub(r" ?\([^)]+\)", "", item))


def is_nonagonal(n):
	return int(n * (7 * n - 5) / 2)


def remove_similar_row(test_list):
  res = set(sorted([tuple(sorted(set(sub))) for sub in test_list]))
  return (res)


import re
def text_match_wordz_middle(text):
        patterns = '\Bz\B'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')


def reverse_Array_Upto_K(input, k):
  return (input[k-1::-1] + input[k:])


def get_product(val) :
	res = 1
	for ele in val:
		res *= ele
	return res
def find_k_product(test_list, K):
  res = get_product([sub[K] for sub in test_list])
  return (res)


def No_of_cubes(N,K):
    No = 0
    No = (N - K + 1)
    No = pow(No, 3)
    return No


import re
def split_upperstring(text):
 return (re.findall('[A-Z][^A-Z]*', text))


from itertools import zip_longest, chain, tee
def exchange_elements(lst):
    lst1, lst2 = tee(iter(lst), 2)
    return list(chain.from_iterable(zip_longest(lst[1::2], lst[::2])))


def sum_Range_list(nums, m, n):
    sum_range = 0
    for i in range(m, n+1, 1):
        sum_range += nums[i]
    return sum_range


def are_Equal(arr1,arr2,n,m):
    if (n != m):
        return False
    arr1.sort()
    arr2.sort()
    for i in range(0,n - 1):
        if (arr1[i] != arr2[i]):
            return False
    return True


def check_subset(test_tup1, test_tup2):
  res = set(test_tup2).issubset(test_tup1)
  return (res)


def matrix_to_list(test_list):
  temp = [ele for sub in test_list for ele in sub]
  res = list(zip(*temp))
  return (str(res))


from collections import defaultdict
def grouping_dictionary(l):
    d = defaultdict(list)
    for k, v in l:
        d[k].append(v)
    return d


def rectangle_perimeter(l,b):
  perimeter=2*(l+b)
  return perimeter


def fifth_Power_Sum(n) :
    sm = 0
    for i in range(1,n+1) :
        sm = sm + (i*i*i*i*i)
    return sm


def find_Min_Sum(a,b,n):
    a.sort()
    b.sort()
    sum = 0
    for i in range(n):
        sum = sum + abs(a[i] - b[i])
    return sum


import math
def first_Digit(n) :
    fact = 1
    for i in range(2,n + 1) :
        fact = fact * i
        while (fact % 10 == 0) :
            fact = int(fact / 10)
    while (fact >= 10) :
        fact = int(fact / 10)
    return math.floor(fact)


def max_occurrences(list1):
    max_val = 0
    result = list1[0]
    for i in list1:
        occu = list1.count(i)
        if occu > max_val:
            max_val = occu
            result = i
    return result


def Repeat(x):
    _size = len(x)
    repeated = []
    for i in range(_size):
        k = i + 1
        for j in range(k, _size):
            if x[i] == x[j] and x[i] not in repeated:
                repeated.append(x[i])
    return repeated


def find_Points(l1,r1,l2,r2):
    x = min(l1,l2) if (l1 != l2) else -1
    y = max(r1,r2) if (r1 != r2) else -1
    return (x,y)


def max_sum_of_three_consecutive(arr, n):
	sum = [0 for k in range(n)]
	if n >= 1:
		sum[0] = arr[0]
	if n >= 2:
		sum[1] = arr[0] + arr[1]
	if n > 2:
		sum[2] = max(sum[1], max(arr[1] + arr[2], arr[0] + arr[2]))
	for i in range(3, n):
		sum[i] = max(max(sum[i-1], sum[i-2] + arr[i]), arr[i] + arr[i-1] + sum[i-3])
	return sum[n-1]


def sorted_dict(dict1):
  sorted_dict = {x: sorted(y) for x, y in dict1.items()}
  return sorted_dict


import sys
def find_max_val(n, x, y):
	ans = -sys.maxsize
	for k in range(n + 1):
		if (k % x == y):
			ans = max(ans, k)
	return (ans if (ans >= 0 and
					ans <= n) else -1)


def average_Even(n) :
    if (n% 2!= 0) :
        return ("Invalid Input")
        return -1
    sm = 0
    count = 0
    while (n>= 2) :
        count = count+1
        sm = sm+n
        n = n-2
    return sm // count


def move_last(num_list):
    a = [num_list[0] for i in range(num_list.count(num_list[0]))]
    x = [ i for i in num_list if i != num_list[0]]
    x.extend(a)
    return (x)


def count_char(string,char):
 count = 0
 for i in range(len(string)):
    if(string[i] == char):
        count = count + 1
 return count


def Check_Vow(string, vowels):
    final = [each for each in string if each in vowels]
    return(len(final))


import re
def replace(string, char):
    pattern = char + '{2,}'
    string = re.sub(pattern, char, string)
    return string


import re
regex = '''^(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.(
			25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.(
			25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\.(
			25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)$'''
def check_IP(Ip):
	if(re.search(regex, Ip)):
		return ("Valid IP address")
	else:
		return ("Invalid IP address")


def decreasing_trend(nums):
    if (sorted(nums)== nums):
        return True
    else:
        return False


import math
def get_Pos_Of_Right_most_Set_Bit(n):
    return int(math.log2(n&-n)+1)
def set_Right_most_Unset_Bit(n):
    if (n == 0):
        return 1
    if ((n & (n + 1)) == 0):
        return n
    pos = get_Pos_Of_Right_most_Set_Bit(~n)
    return ((1 << (pos - 1)) | n)


def max_of_three(num1,num2,num3):
    if (num1 >= num2) and (num1 >= num3):
       lnum = num1
    elif (num2 >= num1) and (num2 >= num3):
       lnum = num2
    else:
       lnum = num3
    return lnum


def convert(list):
    s = [str(i) for i in list]
    res = int("".join(s))
    return (res)


from collections import OrderedDict
def remove_duplicate(string):
  result = ' '.join(OrderedDict((w,w) for w in string.split()).keys())
  return result


def sum_nums(x, y,m,n):
    sum_nums= x + y
    if sum_nums in range(m, n):
        return 20
    else:
        return sum_nums


import re
def remove_extra_char(text1):
  pattern = re.compile('[\W_]+')
  return (pattern.sub('', text1))


def validity_triangle(a,b,c):
 total = a + b + c
 if total == 180:
    return True
 else:
    return False


def remove_spaces(str1):
  str1 = str1.replace(' ','')
  return str1


def access_key(ditionary,key):
  return list(ditionary)[key]


def increasing_trend(nums):
    if (sorted(nums)== nums):
        return True
    else:
        return False


def smallest_Divisor(n):
    if (n % 2 == 0):
        return 2;
    i = 3;
    while (i*i <= n):
        if (n % i == 0):
            return i;
        i += 2;
    return n;


def mul_list(nums1,nums2):
  result = map(lambda x, y: x * y, nums1, nums2)
  return list(result)


def sum_Square(n) :
    i = 1
    while i*i <= n :
        j = 1
        while (j*j <= n) :
            if (i*i+j*j == n) :
                return True
            j = j+1
        i = i+1
    return False


def count_Char(str,x):
    count = 0
    for i in range(len(str)):
        if (str[i] == x) :
            count += 1
    n = 10
    repititions = n // len(str)
    count = count * repititions
    l = n % len(str)
    for i in range(l):
        if (str[i] == x):
            count += 1
    return count


def sum_Of_Primes(n):
    prime = [True] * (n + 1)
    p = 2
    while p * p <= n:
        if prime[p] == True:
            i = p * 2
            while i <= n:
                prime[i] = False
                i += p
        p += 1
    sum = 0
    for i in range (2,n + 1):
        if(prime[i]):
            sum += i
    return sum


from collections import defaultdict
def freq_element(test_tup):
  res = defaultdict(int)
  for ele in test_tup:
    res[ele] += 1
  return (str(dict(res)))


def recur_gcd(a, b):
	low = min(a, b)
	high = max(a, b)
	if low == 0:
		return high
	elif low == 1:
		return 1
	else:
		return recur_gcd(low, high%low)


import cmath
def len_complex(a,b):
  cn=complex(a,b)
  length=abs(cn)
  return length


def min_jumps(arr, n):
	jumps = [0 for i in range(n)]
	if (n == 0) or (arr[0] == 0):
		return float('inf')
	jumps[0] = 0
	for i in range(1, n):
		jumps[i] = float('inf')
		for j in range(i):
			if (i <= j + arr[j]) and (jumps[j] != float('inf')):
				jumps[i] = min(jumps[i], jumps[j] + 1)
				break
	return jumps[n-1]


def mul_consecutive_nums(nums):
    result = [b*a for a, b in zip(nums[:-1], nums[1:])]
    return result


from itertools import groupby
def group_element(test_list):
  res = dict()
  for key, val in groupby(sorted(test_list, key = lambda ele: ele[1]), key = lambda ele: ele[1]):
    res[key] = [ele[0] for ele in val]
  return (res)


def last_Two_Digits(N):
    if (N >= 10):
        return
    fac = 1
    for i in range(1,N + 1):
        fac = (fac * i) % 100
    return (fac)


import re
def remove_multiple_spaces(text1):
  return (re.sub(' +',' ',text1))


def extract_unique(test_dict):
  res = list(sorted({ele for val in test_dict.values() for ele in val}))
  return res


def check_greater(test_tup1, test_tup2):
  res = all(x < y for x, y in zip(test_tup1, test_tup2))
  return (res)


def zip_list(list1,list2):
 result = list(map(list.__add__, list1, list2))
 return result


def count_even(array_nums):
   count_even = len(list(filter(lambda x: (x%2 == 0) , array_nums)))
   return count_even


def sort_dict_item(test_dict):
  res = {key: test_dict[key] for key in sorted(test_dict.keys(), key = lambda ele: ele[1] * ele[0])}
  return  (res)


def min_Swaps(str1,str2) :
    count = 0
    for i in range(len(str1)) :
        if str1[i] != str2[i] :
            count += 1
    if count % 2 == 0 :
        return (count // 2)
    else :
        return ("Not Possible")


def count_range_in_list(li, min, max):
	ctr = 0
	for x in li:
		if min <= x <= max:
			ctr += 1
	return ctr


def equilibrium_index(arr):
  total_sum = sum(arr)
  left_sum=0
  for i, num in enumerate(arr):
    total_sum -= num
    if left_sum == total_sum:
      return i
    left_sum += num
  return -1


def find_ind(key, i, n,
			k, arr):
	ind = -1
	start = i + 1
	end = n - 1;
	while (start < end):
		mid = int(start +
				(end - start) / 2)
		if (arr[mid] - key <= k):
			ind = mid
			start = mid + 1
		else:
			end = mid
	return ind
def removals(arr, n, k):
	ans = n - 1
	arr.sort()
	for i in range(0, n):
		j = find_ind(arr[i], i,
					n, k, arr)
		if (j != -1):
			ans = min(ans, n -
						(j - i + 1))
	return ans


def is_key_present(d,x):
  if x in d:
    return True
  else:
     return False


def harmonic_sum(n):
  if n < 2:
    return 1
  else:
    return 1 / n + (harmonic_sum(n - 1))


def sort_sublists(list1):
      list1.sort()
      list1.sort(key=len)
      return  list1


def is_subset(arr1, m, arr2, n):
	hashset = set()
	for i in range(0, m):
		hashset.add(arr1[i])
	for i in range(0, n):
		if arr2[i] in hashset:
			continue
		else:
			return False
	return True


def count_Set_Bits(n) :
    n += 1;
    powerOf2 = 2;
    cnt = n // 2;
    while (powerOf2 <= n) :
        totalPairs = n // powerOf2;
        cnt += (totalPairs // 2) * powerOf2;
        if (totalPairs & 1) :
            cnt += (n % powerOf2)
        else :
            cnt += 0
        powerOf2 <<= 1;
    return cnt;


def Convert(string):
    li = list(string.split(" "))
    return li


from collections import defaultdict
def get_unique(test_list):
  res = defaultdict(list)
  for sub in test_list:
    res[sub[1]].append(sub[0])
  res = dict(res)
  res_dict = dict()
  for key in res:
    res_dict[key] = len(list(set(res[key])))
  return (str(res_dict))


def front_and_rear(test_tup):
  res = (test_tup[0], test_tup[-1])
  return (res)


def product_Equal(n):
    if n < 10:
        return False
    prodOdd = 1; prodEven = 1
    while n > 0:
        digit = n % 10
        prodOdd *= digit
        n = n//10
        if n == 0:
            break;
        digit = n % 10
        prodEven *= digit
        n = n//10
    if prodOdd == prodEven:
        return True
    return False


import itertools
def remove_duplicate(list1):
 list.sort(list1)
 remove_duplicate = list(list1 for list1,_ in itertools.groupby(list1))
 return remove_duplicate


def check_valid(test_tup):
  res = not any(map(lambda ele: not ele, test_tup))
  return (res)


def count_Fac(n):
    m = n
    count = 0
    i = 2
    while((i * i) <= m):
        total = 0
        while (n % i == 0):
            n /= i
            total += 1
        temp = 0
        j = 1
        while((temp + j) <= total):
            temp += j
            count += 1
            j += 1
        i += 1
    if (n != 1):
        count += 1
    return count


def str_to_tuple(test_str):
  res = tuple(map(int, test_str.split(', ')))
  return (res)


def rombus_perimeter(a):
  perimeter=4*a
  return perimeter


import math
import sys
def sd_calc(data):
    n = len(data)
    if n <= 1:
        return 0.0
    mean, sd = avg_calc(data), 0.0
    for el in data:
        sd += (float(el) - mean)**2
    sd = math.sqrt(sd / float(n-1))
    return sd
def avg_calc(ls):
    n, mean = len(ls), 0.0
    if n <= 1:
        return ls[0]
    for el in ls:
        mean = mean + float(el)
    mean = mean / float(n)
    return mean


def alternate_elements(list1):
    result=[]
    for item in list1[::2]:
        result.append(item)
    return result


import re
def text_match(text):
        patterns = 'ab*?'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')


def add_dict_to_tuple(test_tup, test_dict):
  test_tup = list(test_tup)
  test_tup.append(test_dict)
  test_tup = tuple(test_tup)
  return (test_tup)


M = 100
def maxAverageOfPath(cost, N):
	dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
	dp[0][0] = cost[0][0]
	for i in range(1, N):
		dp[i][0] = dp[i - 1][0] + cost[i][0]
	for j in range(1, N):
		dp[0][j] = dp[0][j - 1] + cost[0][j]
	for i in range(1, N):
		for j in range(1, N):
			dp[i][j] = max(dp[i - 1][j],
						dp[i][j - 1]) + cost[i][j]
	return dp[N - 1][N - 1] / (2 * N - 1)


def filter_data(students,h,w):
    result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
    return result


from operator import eq
def count_same_pair(nums1, nums2):
    result = sum(map(eq, nums1, nums2))
    return result


def power_base_sum(base, power):
    return sum([int(i) for i in str(pow(base, power))])


import re
def extract_quotation(text1):
  return (re.findall(r'"(.*?)"', text1))


def multiply_elements(test_tup):
  res = tuple(i * j for i, j in zip(test_tup, test_tup[1:]))
  return (res)


import re
def remove_char(S):
  result = re.sub('[\W_]+', '', S)
  return result


def sum_list(lst1,lst2):
  res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
  return res_list


def add_list(nums1,nums2):
  result = map(lambda x, y: x + y, nums1, nums2)
  return list(result)


from itertools import groupby
def consecutive_duplicates(nums):
    return [key for key, group in groupby(nums)]


import math
def lateralsurface_cone(r,h):
  l = math.sqrt(r * r + h * h)
  LSA = math.pi * r  * l
  return LSA


import re
def replace_specialchar(text):
 return (re.sub("[ ,.]", ":", text))


def find_first_occurrence(A, x):
    (left, right) = (0, len(A) - 1)
    result = -1
    while left <= right:
        mid = (left + right) // 2
        if x == A[mid]:
            result = mid
            right = mid - 1
        elif x < A[mid]:
            right = mid - 1
        else:
            left = mid + 1
    return result


def sum_Of_Subarray_Prod(arr,n):
    ans = 0
    res = 0
    i = n - 1
    while (i >= 0):
        incr = arr[i]*(1 + res)
        ans += incr
        res = incr
        i -= 1
    return (ans)


def set_middle_bits(n):
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    return (n >> 1) ^ 1
def toggle_middle_bits(n):
    if (n == 1):
        return 1
    return n ^ set_middle_bits(n)


import bisect
def left_insertion(a, x):
    i = bisect.bisect_left(a, x)
    return i


import re
regex = '^[aeiouAEIOU][A-Za-z0-9_]*'
def check_str(string):
	if(re.search(regex, string)):
		return ("Valid")
	else:
		return ("Invalid")


def geometric_sum(n):
  if n < 0:
    return 0
  else:
    return 1 / (pow(2, n)) + geometric_sum(n - 1)


import math
def find_Index(n):
    x = math.sqrt(2 * math.pow(10,(n - 1)));
    return round(x);


def tuple_to_dict(test_tup):
  res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2))
  return (res)


def all_Characters_Same(s) :
    n = len(s)
    for i in range(1,n) :
        if s[i] != s[0] :
            return False
    return True


import math
def area_tetrahedron(side):
  area = math.sqrt(3)*(side*side)
  return area


def rotate_right(list1,m,n):
  result =  list1[-(m):]+list1[:-(n)]
  return result


def check_none(test_tup):
  res = any(map(lambda ele: ele is None, test_tup))
  return (res)


def divisible_by_digits(startnum, endnum):
    return [n for n in range(startnum, endnum+1) \
                if not any(map(lambda x: int(x) == 0 or n%int(x) != 0, str(n)))]


def sector_area(r,a):
    pi=22/7
    if a >= 360:
        return None
    sectorarea = (pi*r**2) * (a/360)
    return sectorarea


def lcs_of_three(X, Y, Z, m, n, o):
	L = [[[0 for i in range(o+1)] for j in range(n+1)]
		for k in range(m+1)]
	for i in range(m+1):
		for j in range(n+1):
			for k in range(o+1):
				if (i == 0 or j == 0 or k == 0):
					L[i][j][k] = 0
				elif (X[i-1] == Y[j-1] and
					X[i-1] == Z[k-1]):
					L[i][j][k] = L[i-1][j-1][k-1] + 1
				else:
					L[i][j][k] = max(max(L[i-1][j][k],
					L[i][j-1][k]),
									L[i][j][k-1])
	return L[m][n][o]


import re
def capital_words_spaces(str1):
  return re.sub(r"(\w)([A-Z])", r"\1 \2", str1)


def sort_numeric_strings(nums_str):
    result = [int(x) for x in nums_str]
    result.sort()
    return result


def add_tuple(test_list, test_tup):
  test_list += test_tup
  return (test_list)


def check_min_heap(arr, i):
    if 2 * i + 2 > len(arr):
        return True
    left_child = (arr[i] <= arr[2 * i + 1]) and check_min_heap(arr, 2 * i + 1)
    right_child = (2 * i + 2 == len(arr)) or (arr[i] <= arr[2 * i + 2]
                                      and check_min_heap(arr, 2 * i + 2))
    return left_child and right_child


def jacobsthal_num(n):
	dp = [0] * (n + 1)
	dp[0] = 0
	dp[1] = 1
	for i in range(2, n+1):
		dp[i] = dp[i - 1] + 2 * dp[i - 2]
	return dp[n]


def min_k(test_list, K):
  res = sorted(test_list, key = lambda x: x[1])[:K]
  return (res)


def extract_index_list(l1, l2, l3):
    result = []
    for m, n, o in zip(l1, l2, l3):
        if (m == n == o):
            result.append(m)
    return result


def second_smallest(numbers):
  if (len(numbers)<2):
    return
  if ((len(numbers)==2)  and (numbers[0] == numbers[1]) ):
    return
  dup_items = set()
  uniq_items = []
  for x in numbers:
    if x not in dup_items:
      uniq_items.append(x)
      dup_items.add(x)
  uniq_items.sort()
  return  uniq_items[1]


import re
def text_match_zero_one(text):
        patterns = 'ab?'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')


def count_reverse_pairs(test_list):
  res = sum([1 for idx in range(0, len(test_list)) for idxn in range(idx, len(
	test_list)) if test_list[idxn] == str(''.join(list(reversed(test_list[idx]))))])
  return str(res)


def unique_sublists(list1):
    result ={}
    for l in  list1:
        result.setdefault(tuple(l), list()).append(1)
    for a, b in result.items():
        result[a] = sum(b)
    return result


def is_decimal(num):
    import re
    dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
    result = dnumre.search(num)
    return bool(result)


def unique_Element(arr,n):
    s = set(arr)
    if (len(s) == 1):
        return ('YES')
    else:
        return ('NO')


def arc_length(d,a):
    pi=22/7
    if a >= 360:
        return None
    arclength = (pi*d) * (a/360)
    return arclength


def check_monthnumber_number(monthnum3):
  if(monthnum3==4 or monthnum3==6 or monthnum3==9 or monthnum3==11):
    return True
  else:
    return False


def find_Min_Diff(arr,n):
    arr = sorted(arr)
    diff = 10**20
    for i in range(n-1):
        if arr[i+1] - arr[i] < diff:
            diff = arr[i+1] - arr[i]
    return diff


def number_ctr(str):
      number_ctr= 0
      for i in range(len(str)):
          if str[i] >= '0' and str[i] <= '9': number_ctr += 1
      return  number_ctr


import math
def is_polite(n):
	n = n + 1
	return (int)(n+(math.log((n + math.log(n, 2)), 2)))


def pair_wise(l1):
    temp = []
    for i in range(len(l1) - 1):
        current_element, next_element = l1[i], l1[i + 1]
        x = (current_element, next_element)
        temp.append(x)
    return temp


def get_Pairs_Count(arr,n,sum):
    count = 0
    for i in range(0,n):
        for j in range(i + 1,n):
            if arr[i] + arr[j] == sum:
                count += 1
    return count


def check_Odd_Parity(x):
    parity = 0
    while (x != 0):
        x = x & (x - 1)
        parity += 1
    if (parity % 2 == 1):
        return True
    else:
        return False


def Diff(li1,li2):
    return (list(list(set(li1)-set(li2)) + list(set(li2)-set(li1))))


def odd_Num_Sum(n) :
    j = 0
    sm = 0
    for i in range(1,n + 1) :
        j = (2*i-1)
        sm = sm + (j*j*j*j)
    return sm


from collections import deque
def check_expression(exp):
    if len(exp) & 1:
        return False
    stack = deque()
    for ch in exp:
        if ch == '(' or ch == '{' or ch == '[':
            stack.append(ch)
        if ch == ')' or ch == '}' or ch == ']':
            if not stack:
                return False
            top = stack.pop()
            if (top == '(' and ch != ')') or (top == '{' and ch != '}' or (top == '[' and ch != ']')):
                return False
    return not stack


def remove_length(test_str, K):
  temp = test_str.split()
  res = [ele for ele in temp if len(ele) != K]
  res = ' '.join(res)
  return (res)


import re
def occurance_substring(text,pattern):
 for match in re.finditer(pattern, text):
    s = match.start()
    e = match.end()
    return (text[s:e], s, e)


import re
regex = '^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$'
def check_email(email):
	if(re.search(regex,email)):
		return ("Valid Email")
	else:
		return ("Invalid Email")


def odd_position(nums):
	return all(nums[i]%2==i%2 for i in range(len(nums)))


def count_vowels(test_str):
  res = 0
  vow_list = ['a', 'e', 'i', 'o', 'u']
  for idx in range(1, len(test_str) - 1):
    if test_str[idx] not in vow_list and (test_str[idx - 1] in vow_list or test_str[idx + 1] in vow_list):
      res += 1
  if test_str[0] not in vow_list and test_str[1] in vow_list:
    res += 1
  if test_str[-1] not in vow_list and test_str[-2] in vow_list:
    res += 1
  return (res)


def find_Sum(arr,n):
    arr.sort()
    sum = arr[0]
    for i in range(0,n-1):
        if (arr[i] != arr[i+1]):
            sum = sum + arr[i+1]
    return sum


from itertools import groupby
def pack_consecutive_duplicates(list1):
    return [list(group) for key, group in groupby(list1)]


def unique_sublists(list1):
    result ={}
    for l in list1:
        result.setdefault(tuple(l), list()).append(1)
    for a, b in result.items():
        result[a] = sum(b)
    return result


from itertools import combinations
def find_combinations(test_list):
  res = [(b1 + a1, b2 + a2) for (a1, a2), (b1, b2) in combinations(test_list, 2)]
  return (res)


import math
def count_Divisors(n) :
    count = 0
    for i in range(1, (int)(math.sqrt(n)) + 2) :
        if (n % i == 0) :
            if( n // i == i) :
                count = count + 1
            else :
                count = count + 2
    if (count % 2 == 0) :
        return ("Even")
    else :
        return ("Odd")


def Odd_Length_Sum(arr):
    Sum = 0
    l = len(arr)
    for i in range(l):
        Sum += ((((i + 1) *(l - i) + 1) // 2) * arr[i])
    return Sum


def rgb_to_hsv(r, g, b):
    r, g, b = r/255.0, g/255.0, b/255.0
    mx = max(r, g, b)
    mn = min(r, g, b)
    df = mx-mn
    if mx == mn:
        h = 0
    elif mx == r:
        h = (60 * ((g-b)/df) + 360) % 360
    elif mx == g:
        h = (60 * ((b-r)/df) + 120) % 360
    elif mx == b:
        h = (60 * ((r-g)/df) + 240) % 360
    if mx == 0:
        s = 0
    else:
        s = (df/mx)*100
    v = mx*100
    return h, s, v


def mul_even_odd(list1):
    first_even = next((el for el in list1 if el%2==0),-1)
    first_odd = next((el for el in list1 if el%2!=0),-1)
    return (first_even*first_odd)


def tuple_str_int(test_str):
  res = tuple(int(num) for num in test_str.replace('(', '').replace(')', '').replace('...', '').split(', '))
  return (res)


import bisect
def right_insertion(a, x):
    i = bisect.bisect_right(a, x)
    return i


import re
def text_match_three(text):
        patterns = 'ab{3}?'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')


def new_tuple(test_list, test_str):
  res = tuple(test_list + [test_str])
  return (res)


from math import tan, pi
def perimeter_polygon(s,l):
  perimeter = s*l
  return perimeter


def even_position(nums):
	return all(nums[i]%2==i%2 for i in range(len(nums)))


def remove_nested(test_tup):
  res = tuple()
  for count, ele in enumerate(test_tup):
    if not isinstance(ele, tuple):
      res = res + (ele, )
  return (res)


def count_list(input_list):
    return len(input_list)


def last(arr,x,n):
    low = 0
    high = n - 1
    res = -1
    while (low <= high):
        mid = (low + high) // 2
        if arr[mid] > x:
            high = mid - 1
        elif arr[mid] < x:
            low = mid + 1
        else:
            res = mid
            low = mid + 1
    return res


import re
def text_starta_endb(text):
        patterns = 'a.*?b$'
        if re.search(patterns,  text):
                return 'Found a match!'
        else:
                return('Not matched!')


import heapq
def cheap_items(items,n):
  cheap_items = heapq.nsmallest(n, items, key=lambda s: s['price'])
  return cheap_items


def return_sum(dict):
  sum = 0
  for i in dict.values():
    sum = sum + i
  return sum


def sum_Odd(n):
    terms = (n + 1)//2
    sum1 = terms * terms
    return sum1
def sum_in_Range(l,r):
    return sum_Odd(r) - sum_Odd(l - 1)


def _sum(arr):
    sum=0
    for i in arr:
        sum = sum + i
    return(sum)


INT_BITS = 32
def left_Rotate(n,d):
    return (n << d)|(n >> (INT_BITS - d))


import re
def remove_all_spaces(text):
 return (re.sub(r'\s+', '',text))


def test_three_equal(x,y,z):
  result= set([x,y,z])
  if len(result)==3:
    return 0
  else:
    return (4-len(result))


def count_Rotation(arr,n):
    for i in range (1,n):
        if (arr[i] < arr[i - 1]):
            return i
    return 0


def is_Perfect_Square(n) :
    i = 1
    while (i * i<= n):
        if ((n % i == 0) and (n / i == i)):
            return True
        i = i + 1
    return False


def is_Product_Even(arr,n):
    for i in range(0,n):
        if ((arr[i] & 1) == 0):
            return True
    return False


def max_sum_list(lists):
 return max(lists, key=sum)


def max_run_uppercase(test_str):
  cnt = 0
  res = 0
  for idx in range(0, len(test_str)):
    if test_str[idx].isupper():
      cnt += 1
    else:
      res = cnt
      cnt = 0
  if test_str[len(test_str) - 1].isupper():
    res = cnt
  return (res)


def first_odd(nums):
  first_odd = next((el for el in nums if el%2!=0),-1)
  return first_odd


def check_K(test_tup, K):
  res = False
  for ele in test_tup:
    if ele == K:
      res = True
      break
  return (res)


def check_smaller(test_tup1, test_tup2):
  res = all(x > y for x, y in zip(test_tup1, test_tup2))
  return (res)


from collections import Counter
def count_variable(a,b,c,d):
  c = Counter(p=a, q=b, r=c, s=d)
  return list(c.elements())


def check_identical(test_list1, test_list2):
  res = test_list1 == test_list2
  return (res)


import re
def road_rd(street):
  return (re.sub('Road$', 'Rd.', street))


def string_length(str1):
    count = 0
    for char in str1:
        count += 1
    return count


def rombus_area(p,q):
  area=(p*q)/2
  return area


def sort_by_dnf(arr, n):
  low=0
  mid=0
  high=n-1
  while mid <= high:
    if arr[mid] == 0:
      arr[low], arr[mid] = arr[mid], arr[low]
      low = low + 1
      mid = mid + 1
    elif arr[mid] == 1:
      mid = mid + 1
    else:
      arr[mid], arr[high] = arr[high], arr[mid]
      high = high - 1
  return arr


def clear_tuple(test_tup):
  temp = list(test_tup)
  temp.clear()
  test_tup = tuple(temp)
  return (test_tup)


def div_of_nums(nums,m,n):
 result = list(filter(lambda x: (x % m == 0 or x % n == 0), nums))
 return result


def lower_ctr(str):
      lower_ctr= 0
      for i in range(len(str)):
          if str[i] >= 'a' and str[i] <= 'z': lower_ctr += 1
      return  lower_ctr


def count_duplic(lists):
    element = []
    frequency = []
    if not lists:
        return element
    running_count = 1
    for i in range(len(lists)-1):
        if lists[i] == lists[i+1]:
            running_count += 1
        else:
            frequency.append(running_count)
            element.append(lists[i])
            running_count = 1
    frequency.append(running_count)
    element.append(lists[i+1])
    return element,frequency


def check_monthnum_number(monthnum1):
  if monthnum1 == 2:
    return True
  else:
    return False


import collections as ct
def merge_dictionaries(dict1,dict2):
    merged_dict = dict(ct.ChainMap({}, dict1, dict2))
    return merged_dict


import re
def pass_validity(p):
 x = True
 while x:
    if (len(p)<6 or len(p)>12):
        break
    elif not re.search("[a-z]",p):
        break
    elif not re.search("[0-9]",p):
        break
    elif not re.search("[A-Z]",p):
        break
    elif not re.search("[$#@]",p):
        break
    elif re.search("\s",p):
        break
    else:
        return True
        x=False
        break

 if x:
    return False


import re
def check_substring(string, sample) :
  if (sample in string):
      y = "\A" + sample
      x = re.search(y, string)
      if x :
          return ("string starts with the given substring")
      else :
          return ("string doesnt start with the given substring")
  else :
      return ("entered string isnt a substring")


def remove_even(l):
    for i in l:
        if i % 2 == 0:
            l.remove(i)
    return l


def access_elements(nums, list_index):
    result = [nums[i] for i in list_index]
    return result


def check_Type_Of_Triangle(a,b,c):
    sqa = pow(a,2)
    sqb = pow(b,2)
    sqc = pow(c,2)
    if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
        return ("Right-angled Triangle")
    elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
        return ("Obtuse-angled Triangle")
    else:
        return ("Acute-angled Triangle")


def sum_column(list1, C):
    result = sum(row[C] for row in list1)
    return result


def count_alpha_dig_spl(string):
  alphabets=digits = special = 0
  for i in range(len(string)):
    if(string[i].isalpha()):
        alphabets = alphabets + 1
    elif(string[i].isdigit()):
        digits = digits + 1
    else:
        special = special + 1
  return (alphabets,digits,special)


from collections import Counter

def second_frequent(input):
	dict = Counter(input)
	value = sorted(dict.values(), reverse=True)
	second_large = value[1]
	for (key, val) in dict.items():
		if val == second_large:
			return (key)


import math
def round_up(a, digits):
    n = 10**-digits
    return round(math.ceil(a / n) * n, digits)


def count_Pairs(arr,n):
    cnt = 0;
    for i in range(n):
        for j in range(i + 1,n):
            if (arr[i] == arr[j]):
                cnt += 1;
    return cnt;


import re
def extract_max(input):
	numbers = re.findall('\d+',input)
	numbers = map(int,numbers)
	return max(numbers)


def get_key(dict):
    list = []
    for key in dict.keys():
        list.append(key)
    return list


def generate_matrix(n):
        if n<=0:
            return []
        matrix=[row[:] for row in [[0]*n]*n]
        row_st=0
        row_ed=n-1
        col_st=0
        col_ed=n-1
        current=1
        while (True):
            if current>n*n:
                break
            for c in range (col_st, col_ed+1):
                matrix[row_st][c]=current
                current+=1
            row_st+=1
            for r in range (row_st, row_ed+1):
                matrix[r][col_ed]=current
                current+=1
            col_ed-=1
            for c in range (col_ed, col_st-1, -1):
                matrix[row_ed][c]=current
                current+=1
            row_ed-=1
            for r in range (row_ed, row_st-1, -1):
                matrix[r][col_st]=current
                current+=1
            col_st+=1
        return matrix


def slope(x1,y1,x2,y2):
    return (float)(y2-y1)/(x2-x1)


from sys import maxsize
def max_sub_array_sum(a,size):
	max_so_far = -maxsize - 1
	max_ending_here = 0
	start = 0
	end = 0
	s = 0
	for i in range(0,size):
		max_ending_here += a[i]
		if max_so_far < max_ending_here:
			max_so_far = max_ending_here
			start = s
			end = i
		if max_ending_here < 0:
			max_ending_here = 0
			s = i+1
	return (end - start + 1)


def cube_Sum(n):
    sum = 0
    for i in range(0,n) :
        sum += (2*i+1)*(2*i+1)*(2*i+1)
    return sum


def min_Swaps(s1,s2) :
    c0 = 0; c1 = 0;
    for i in range(len(s1)) :
        if (s1[i] == '0' and s2[i] == '1') :
            c0 += 1;
        elif (s1[i] == '1' and s2[i] == '0') :
            c1 += 1;
    result = c0 // 2 + c1 // 2;
    if (c0 % 2 == 0 and c1 % 2 == 0) :
        return result;
    elif ((c0 + c1) % 2 == 0) :
        return result + 2;
    else :
        return -1;


def sort_tuple(tup):
	n = len(tup)
	for i in range(n):
		for j in range(n-i-1):
			if tup[j][0] > tup[j + 1][0]:
				tup[j], tup[j + 1] = tup[j + 1], tup[j]
	return tup


def Check_Solution(a,b,c):
    if b == 0:
        return ("Yes")
    else:
        return ("No")


def get_inv_count(arr, n):
	inv_count = 0
	for i in range(n):
		for j in range(i + 1, n):
			if (arr[i] > arr[j]):
				inv_count += 1
	return inv_count


def get_odd_occurence(arr, arr_size):
  for i in range(0, arr_size):
    count = 0
    for j in range(0, arr_size):
      if arr[i] == arr[j]:
        count += 1
    if (count % 2 != 0):
      return arr[i]
  return -1


import heapq
def nth_super_ugly_number(n, primes):
    uglies = [1]
    def gen(prime):
        for ugly in uglies:
            yield ugly * prime
    merged = heapq.merge(*map(gen, primes))
    while len(uglies) < n:
        ugly = next(merged)
        if ugly != uglies[-1]:
            uglies.append(ugly)
    return uglies[-1]


def get_Number(n, k):
    arr = [0] * n;
    i = 0;
    odd = 1;
    while (odd <= n):
        arr[i] = odd;
        i += 1;
        odd += 2;
    even = 2;
    while (even <= n):
        arr[i] = even;
        i += 1;
        even += 2;
    return arr[k - 1];


import math
def find_Digits(n):
    if (n < 0):
        return 0;
    if (n <= 1):
        return 1;
    x = ((n * math.log10(n / math.e) + math.log10(2 * math.pi * n) /2.0));
    return math.floor(x) + 1;


def find_platform(arr, dep, n):
    arr.sort()
    dep.sort()
    plat_needed = 1
    result = 1
    i = 1
    j = 0
    while (i < n and j < n):
        if (arr[i] <= dep[j]):
            plat_needed+= 1
            i+= 1
        elif (arr[i] > dep[j]):
            plat_needed-= 1
            j+= 1
        if (plat_needed > result):
            result = plat_needed
    return result


def lcopy(xs):
  return xs[:]


def area_trapezium(base1,base2,height):
 area = 0.5 * (base1 + base2) * height
 return area


def Sum(N):
    SumOfPrimeDivisors = [0]*(N + 1)
    for i in range(2,N + 1) :
        if (SumOfPrimeDivisors[i] == 0) :
            for j in range(i,N + 1,i) :
                SumOfPrimeDivisors[j] += i
    return SumOfPrimeDivisors[N]


def is_triangleexists(a,b,c):
    if(a != 0 and b != 0 and c != 0 and (a + b + c)== 180):
        if((a + b)>= c or (b + c)>= a or (a + c)>= b):
            return True
        else:
            return False
    else:
        return False


def Sum_of_Inverse_Divisors(N,Sum):
    ans = float(Sum)*1.0 /float(N);
    return round(ans,2);


def remove_negs(num_list):
    for item in num_list:
        if item < 0:
           num_list.remove(item)
    return num_list


import math
def sum_of_odd_Factors(n):
    res = 1
    while n % 2 == 0:
        n = n // 2
    for i in range(3,int(math.sqrt(n) + 1)):
        count = 0
        curr_sum = 1
        curr_term = 1
        while n % i == 0:
            count+=1
            n = n // i
            curr_term *= i
            curr_sum += curr_term
        res *= curr_sum
    if n >= 2:
        res *= (1 + n)
    return res


import heapq as hq
def raw_heap(rawheap):
  hq.heapify(rawheap)
  return rawheap


def check_Even_Parity(x):
    parity = 0
    while (x != 0):
        x = x & (x - 1)
        parity += 1
    if (parity % 2 == 0):
        return True
    else:
        return False


def find_Min_Swaps(arr,n) :
    noOfZeroes = [0] * n
    count = 0
    noOfZeroes[n - 1] = 1 - arr[n - 1]
    for i in range(n-2,-1,-1) :
        noOfZeroes[i] = noOfZeroes[i + 1]
        if (arr[i] == 0) :
            noOfZeroes[i] = noOfZeroes[i] + 1
    for i in range(0,n) :
        if (arr[i] == 1) :
            count = count + noOfZeroes[i]
    return count


def listify_list(list1):
  result = list(map(list,list1))
  return result


def count_list(input_list):
    return (len(input_list))**2


from itertools import combinations
def sub_lists(my_list):
	subs = []
	for i in range(0, len(my_list)+1):
	  temp = [list(x) for x in combinations(my_list, i)]
	  if len(temp)>0:
	    subs.extend(temp)
	return subs


import re
regex = '[a-zA-z0-9]$'
def check_alphanumeric(string):
	if(re.search(regex, string)):
		return ("Accept")
	else:
		return ("Discard")


from collections import Counter
def anagram_lambda(texts,str):
  result = list(filter(lambda x: (Counter(str) == Counter(x)), texts))
  return result


from collections import Counter
import re
def n_common_words(text,n):
  words = re.findall('\w+',text)
  n_common_words= Counter(words).most_common(n)
  return list(n_common_words)


def find_longest_conseq_subseq(arr, n):
	ans = 0
	count = 0
	arr.sort()
	v = []
	v.append(arr[0])
	for i in range(1, n):
		if (arr[i] != arr[i - 1]):
			v.append(arr[i])
	for i in range(len(v)):
		if (i > 0 and v[i] == v[i - 1] + 1):
			count += 1
		else:
			count = 1
		ans = max(ans, count)
	return ans


def palindrome_lambda(texts):
  result = list(filter(lambda x: (x == "".join(reversed(x))), texts))
  return result


def ntimes_list(nums,n):
    result = map(lambda x:n*x, nums)
    return list(result)


def check_monthnumb(monthname2):
  if(monthname2=="January" or monthname2=="March"or monthname2=="May" or monthname2=="July" or monthname2=="Augest" or monthname2=="October" or monthname2=="December"):
    return True
  else:
    return False


def min_Num(arr,n):
    odd = 0
    for i in range(n):
        if (arr[i] % 2):
            odd += 1
    if (odd % 2):
        return 1
    return 2


def length_Of_Last_Word(a):
    l = 0
    x = a.strip()
    for i in range(len(x)):
        if x[i] == " ":
            l = 0
        else:
            l += 1
    return l


def remove_list_range(list1, leftrange, rigthrange):
   result = [i for i in list1 if (min(i)>=leftrange and max(i)<=rigthrange)]
   return result


def sum_positivenum(nums):
  sum_positivenum = list(filter(lambda nums:nums>0,nums))
  return sum(sum_positivenum)


def are_Rotations(string1,string2):
    size1 = len(string1)
    size2 = len(string2)
    temp = ''
    if size1 != size2:
        return False
    temp = string1 + string1
    if (temp.count(string2)> 0):
        return True
    else:
        return False


def check_subset(list1,list2):
    return all(map(list1.__contains__,list2))


def fibonacci(n):
  if n == 1 or n == 2:
    return 1
  else:
    return (fibonacci(n - 1) + (fibonacci(n - 2)))


def check_Concat(str1,str2):
    N = len(str1)
    M = len(str2)
    if (N % M != 0):
        return False
    for i in range(N):
        if (str1[i] != str2[i % M]):
            return False
    return True


def min_difference(test_list):
  temp = [abs(b - a) for a, b in test_list]
  res = min(temp)
  return (res)


def lcm(x, y):
   if x > y:
       z = x
   else:
       z = y
   while(True):
       if((z % x == 0) and (z % y == 0)):
           lcm = z
           break
       z += 1
   return lcm


def sort_String(str) :
    str = ''.join(sorted(str))
    return (str)


def check_tuples(test_tuple, K):
  res = all(ele in K for ele in test_tuple)
  return (res)


import re
def text_match(text):
  patterns = 'a.*?b$'
  if re.search(patterns,  text):
    return ('Found a match!')
  else:
    return ('Not matched!')


def Check_Solution(a,b,c) :
    if ((b*b) - (4*a*c)) > 0 :
        return ("2 solutions")
    elif ((b*b) - (4*a*c)) == 0 :
        return ("1 solution")
    else :
        return ("No solutions")


def sum_even_odd(list1):
    first_even = next((el for el in list1 if el%2==0),-1)
    first_odd = next((el for el in list1 if el%2!=0),-1)
    return (first_even+first_odd)


def parallelogram_perimeter(b,h):
  perimeter=2*(b*h)
  return perimeter


def div_of_nums(nums,m,n):
 result = list(filter(lambda x: (x % m == 0 and x % n == 0), nums))
 return result


def all_Bits_Set_In_The_Given_Range(n,l,r):
    num = ((1 << r) - 1) ^ ((1 << (l - 1)) - 1)
    new_num = n & num
    if (num == new_num):
        return True
    return False


def is_Isomorphic(str1,str2):
    dict_str1 = {}
    dict_str2 = {}
    for i, value in enumerate(str1):
        dict_str1[value] = dict_str1.get(value,[]) + [i]
    for j, value in enumerate(str2):
        dict_str2[value] = dict_str2.get(value,[]) + [j]
    if sorted(dict_str1.values()) == sorted(dict_str2.values()):
        return True
    else:
        return False


def sum_num(numbers):
    total = 0
    for x in numbers:
        total += x
    return total/len(numbers)


def is_odd(n) :
    if (n^1 == n-1) :
        return True;
    else :
        return False;


def substract_elements(test_tup1, test_tup2):
  res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
   for tup1, tup2 in zip(test_tup1, test_tup2))
  return (res)


def reverse_list_lists(lists):
    for l in lists:
        l.sort(reverse = True)
    return lists


def find_Extra(arr1,arr2,n) :
    for i in range(0, n) :
        if (arr1[i] != arr2[i]) :
            return i
    return n


def same_Length(A,B):
    while (A > 0 and B > 0):
        A = A / 10;
        B = B / 10;
    if (A == 0 and B == 0):
        return True;
    return False;


import re
def remove_spaces(text):
 return (re.sub(' +',' ',text))


def Extract(lst):
    return [item[-1] for item in lst]


def float_to_tuple(test_str):
  res = tuple(map(float, test_str.split(', ')))
  return (res)


def max_sum_subseq(A):
    n = len(A)
    if n == 1:
        return A[0]
    look_up = [None] * n
    look_up[0] = A[0]
    look_up[1] = max(A[0], A[1])
    for i in range(2, n):
        look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
        look_up[i] = max(look_up[i], A[i])
    return look_up[n - 1]


def last(n):
   return n[-1]
def sort_list_last(tuples):
  return sorted(tuples, key=last)


def is_Word_Present(sentence,word):
    s = sentence.split(" ")
    for i in s:
        if (i == word):
            return True
    return False


from itertools import groupby
def extract_elements(numbers, n):
    result = [i for i, j in groupby(numbers) if len(list(j)) == n]
    return result


def check(arr,n):
    g = 0
    for i in range(1,n):
        if (arr[i] - arr[i - 1] > 0 and g == 1):
            return False
        if (arr[i] - arr[i] < 0):
            g = 1
    return True


import re
def match_num(string):
    text = re.compile(r"^5")
    if text.match(string):
        return True
    else:
        return False


def smallest_multiple(n):
    if (n<=2):
      return n
    i = n * 2
    factors = [number  for number in range(n, 1, -1) if number * 2 > n]
    while True:
        for a in factors:
            if i % a != 0:
                i += n
                break
            if (a == factors[-1] and i % a == 0):
                return i


from collections import Counter
def add_dict(d1,d2):
   add_dict = Counter(d1) + Counter(d2)
   return add_dict


def count_Unset_Bits(n) :
    cnt = 0;
    for i in range(1,n + 1) :
        temp = i;
        while (temp) :
            if (temp % 2 == 0) :
                cnt += 1;
            temp = temp // 2;
    return cnt;


def even_num(x):
  if x%2==0:
     return True
  else:
    return False


def factorial(start,end):
    res = 1
    for i in range(start,end + 1):
        res *= i
    return res
def sum_of_square(n):
   return int(factorial(n + 1, 2 * n)  /factorial(1, n))


import re
def extract_date(url):
        return re.findall(r'/(\d{4})/(\d{1,2})/(\d{1,2})/', url)


def lucky_num(n):
 List=range(-1,n*n+9,2)
 i=2
 while List[i:]:List=sorted(set(List)-set(List[List[i]::List[i]]));i+=1
 return List[1:n+1]


def find_fixed_point(arr, n):
	for i in range(n):
		if arr[i] is i:
			return i
	return -1


def previous_palindrome(num):
    for x in range(num-1,0,-1):
        if str(x) == str(x)[::-1]:
            return x


import datetime
def check_date(m, d, y):
    try:
        m, d, y = map(int, (m, d, y))
        datetime.date(y, m, d)
        return True
    except ValueError:
        return False


def maximum_product(nums):
    import heapq
    a, b = heapq.nlargest(3, nums), heapq.nsmallest(2, nums)
    return max(a[0] * a[1] * a[2], a[0] * b[0] * b[1])


def binomial_coeff(n, k):
	C = [[0 for j in range(k + 1)]
			for i in range(n + 1)]
	for i in range(0, n + 1):
		for j in range(0, min(i, k) + 1):
			if (j == 0 or j == i):
				C[i][j] = 1
			else:
				C[i][j] = (C[i - 1][j - 1]
							+ C[i - 1][j])
	return C[n][k]
def lobb_num(n, m):
	return (((2 * m + 1) *
		binomial_coeff(2 * n, m + n))
					/ (m + n + 1))


import re
def end_num(string):
    text = re.compile(r".*[0-9]$")
    if text.match(string):
        return True
    else:
        return False


def is_Two_Alter(s):
    for i in range (len( s) - 2) :
        if (s[i] != s[i + 2]) :
            return False
    if (s[0] == s[1]):
        return False
    return True


def rearrange_numbs(array_nums):
  result = sorted(array_nums, key = lambda i: 0 if i == 0 else -1 / i)
  return result


def find_triplet_array(A, arr_size, sum):
	for i in range( 0, arr_size-2):
		for j in range(i + 1, arr_size-1):
			for k in range(j + 1, arr_size):
				if A[i] + A[j] + A[k] == sum:
					return  A[i],A[j],A[k]
					return True
	return False


import re
def text_uppercase_lowercase(text):
        patterns = '[A-Z]+[a-z]+$'
        if re.search(patterns, text):
                return 'Found a match!'
        else:
                return ('Not matched!')


def coin_change(S, m, n):
    table = [[0 for x in range(m)] for x in range(n+1)]
    for i in range(m):
        table[0][i] = 1
    for i in range(1, n+1):
        for j in range(m):
            x = table[i - S[j]][j] if i-S[j] >= 0 else 0
            y = table[i][j-1] if j >= 1 else 0
            table[i][j] = x + y
    return table[n][m-1]


def multiply_list(items):
    tot = 1
    for x in items:
        tot *= x
    return tot


def remove_tuple(test_list):
  res = [sub for sub in test_list if not all(ele == None for ele in sub)]
  return (str(res))


def chunk_tuples(test_tup, N):
  res = [test_tup[i : i + N] for i in range(0, len(test_tup), N)]
  return (res)


def max_product(arr):
    arr_len = len(arr)
    if (arr_len < 2):
        return None
    x = arr[0]; y = arr[1]
    for i in range(0, arr_len):
        for j in range(i + 1, arr_len):
            if (arr[i] * arr[j] > x * y):
                x = arr[i]; y = arr[j]
    return x,y


def super_seq(X, Y, m, n):
	if (not m):
		return n
	if (not n):
		return m
	if (X[m - 1] == Y[n - 1]):
		return 1 + super_seq(X, Y, m - 1, n - 1)
	return 1 + min(super_seq(X, Y, m - 1, n),	super_seq(X, Y, m, n - 1))


def max_of_two( x, y ):
    if x > y:
        return x
    return y


def mutiple_tuple(nums):
    temp = list(nums)
    product = 1
    for x in temp:
        product *= x
    return product


def binomial_coeffi(n, k):
	if (k == 0 or k == n):
		return 1
	return (binomial_coeffi(n - 1, k - 1)
		+ binomial_coeffi(n - 1, k))
def rencontres_number(n, m):
	if (n == 0 and m == 0):
		return 1
	if (n == 1 and m == 0):
		return 0
	if (m == 0):
		return ((n - 1) * (rencontres_number(n - 1, 0)+ rencontres_number(n - 2, 0)))
	return (binomial_coeffi(n, m) * rencontres_number(n - m, 0))


class Node:
	def __init__(self, data):
		self.data = data
		self.left = None
		self.right = None
def max_height(node):
	if node is None:
		return 0 ;
	else :
		left_height = max_height(node.left)
		right_height = max_height(node.right)
		if (left_height > right_height):
			return left_height+1
		else:
			return right_height+1


import re
def change_date_format(dt):
        return re.sub(r'(\d{4})-(\d{1,2})-(\d{1,2})', '\\3-\\2-\\1', dt)
        return change_date_format(dt)


def count_tuplex(tuplex,value):
  count = tuplex.count(value)
  return count


import re
def text_match(text):
        patterns = 'ab*?'
        if re.search(patterns,  text):
                return ('Found a match!')
        else:
                return ('Not matched!')


import math
def sum_series(number):
 total = 0
 total = math.pow((number * (number + 1)) /2, 2)
 return total


def remove_duplic_list(l):
    temp = []
    for x in l:
        if x not in temp:
            temp.append(x)
    return temp


import re
def camel_to_snake(text):
  str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
  return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower()


def dealnnoy_num(n, m):
	if (m == 0 or n == 0) :
		return 1
	return dealnnoy_num(m - 1, n) + dealnnoy_num(m - 1, n - 1) + dealnnoy_num(m, n - 1)


def series_sum(number):
 total = 0
 total = (number * (number + 1) * (2 * number + 1)) / 6
 return total


def re_arrange_tuples(test_list, ord_list):
  temp = dict(test_list)
  res = [(key, temp[key]) for key in ord_list]
  return (res)


from collections import Counter
def max_char(str1):
    temp = Counter(str1)
    max_char = max(temp, key = temp.get)
    return max_char


import sys

def find_closet(A, B, C, p, q, r):
	diff = sys.maxsize
	res_i = 0
	res_j = 0
	res_k = 0
	i = 0
	j = 0
	k = 0
	while(i < p and j < q and k < r):
		minimum = min(A[i], min(B[j], C[k]))
		maximum = max(A[i], max(B[j], C[k]));
		if maximum-minimum < diff:
			res_i = i
			res_j = j
			res_k = k
			diff = maximum - minimum;
		if diff == 0:
			break
		if A[i] == minimum:
			i = i+1
		elif B[j] == minimum:
			j = j+1
		else:
			k = k+1
	return A[res_i],B[res_j],C[res_k]


def sorted_models(models):
 sorted_models = sorted(models, key = lambda x: x['color'])
 return sorted_models


def heap_sort(arr):
    heapify(arr)
    end = len(arr) - 1
    while end > 0:
        arr[end], arr[0] = arr[0], arr[end]
        shift_down(arr, 0, end - 1)
        end -= 1
    return arr

def heapify(arr):
    start = len(arr) // 2
    while start >= 0:
        shift_down(arr, start, len(arr) - 1)
        start -= 1
def shift_down(arr, start, end):
    root = start
    while root * 2 + 1 <= end:
        child = root * 2 + 1
        if child + 1 <= end and arr[child] < arr[child + 1]:
            child += 1
        if child <= end and arr[root] < arr[child]:
            arr[root], arr[child] = arr[child], arr[root]
            root = child
        else:
            return


def count_elim(num):
  count_elim = 0
  for n in num:
    if isinstance(n, tuple):
        break
    count_elim += 1
  return count_elim


def check_element(test_tup, check_list):
  res = False
  for ele in check_list:
    if ele in test_tup:
      res = True
      break
  return (res)


from heapq import merge
def combine_lists(num1,num2):
  combine_lists=list(merge(num1, num2))
  return combine_lists


import re
def num_position(text):
 for m in re.finditer("\d+", text):
    return m.start()


def tuple_to_set(t):
  s = set(t)
  return (s)


from collections import Counter
def most_common_elem(s,a):
  most_common_elem=Counter(s).most_common(a)
  return most_common_elem


def len_log(list1):
    min=len(list1[0])
    for i in list1:
        if len(i)<min:
            min=len(i)
    return min


def get_item(tup1,index):
  item = tup1[index]
  return item


def count_digs(tup):
  return sum([len(str(ele)) for ele in tup ])
def sort_list(test_list):
  test_list.sort(key = count_digs)
  return (str(test_list))


def chinese_zodiac(year):
 if (year - 2000) % 12 == 0:
     sign = 'Dragon'
 elif (year - 2000) % 12 == 1:
     sign = 'Snake'
 elif (year - 2000) % 12 == 2:
     sign = 'Horse'
 elif (year - 2000) % 12 == 3:
     sign = 'sheep'
 elif (year - 2000) % 12 == 4:
     sign = 'Monkey'
 elif (year - 2000) % 12 == 5:
     sign = 'Rooster'
 elif (year - 2000) % 12 == 6:
     sign = 'Dog'
 elif (year - 2000) % 12 == 7:
     sign = 'Pig'
 elif (year - 2000) % 12 == 8:
     sign = 'Rat'
 elif (year - 2000) % 12 == 9:
     sign = 'Ox'
 elif (year - 2000) % 12 == 10:
     sign = 'Tiger'
 else:
     sign = 'Hare'
 return sign


def max_similar_indices(test_list1, test_list2):
  res = [(max(x[0], y[0]), max(x[1], y[1]))
   for x, y in zip(test_list1, test_list2)]
  return (res)


def nCr_mod_p(n, r, p):
	if (r > n- r):
		r = n - r
	C = [0 for i in range(r + 1)]
	C[0] = 1
	for i in range(1, n + 1):
		for j in range(min(i, r), 0, -1):
			C[j] = (C[j] + C[j-1]) % p
	return C[r]


def subset(ar, n):
    res = 0
    ar.sort()
    for i in range(0, n) :
        count = 1
        for i in range(n - 1):
            if ar[i] == ar[i + 1]:
                count+=1
            else:
                break
        res = max(res, count)
    return res


def profit_amount(actual_cost,sale_amount):
 if(actual_cost > sale_amount):
    amount = actual_cost - sale_amount
    return amount
 else:
    return None


def is_abundant(n):
    fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
    return fctrsum > n


import re
def split_list(text):
  return (re.findall('[A-Z][^A-Z]*', text))


import math
def get_First_Set_Bit_Pos(n):
     return math.log2(n&-n)+1


def int_to_roman( num):
        val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
        syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
        roman_num = ''
        i = 0
        while  num > 0:
            for _ in range(num // val[i]):
                roman_num += syb[i]
                num -= val[i]
            i += 1
        return roman_num


def Average(lst):
    return sum(lst) / len(lst)


def get_noOfways(n):
    if (n == 0):
        return 0;
    if (n == 1):
        return 1;
    return get_noOfways(n - 1) + get_noOfways(n - 2);


def roman_to_int(s):
        rom_val = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
        int_val = 0
        for i in range(len(s)):
            if i > 0 and rom_val[s[i]] > rom_val[s[i - 1]]:
                int_val += rom_val[s[i]] - 2 * rom_val[s[i - 1]]
            else:
                int_val += rom_val[s[i]]
        return int_val


def sum_Natural(n):
    sum = (n * (n + 1))
    return int(sum)
def sum_Even(l,r):
    return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))


def discriminant_value(x,y,z):
    discriminant = (y**2) - (4*x*z)
    if discriminant > 0:
        return ("Two solutions",discriminant)
    elif discriminant == 0:
        return ("one solution",discriminant)
    elif discriminant < 0:
        return ("no real solution",discriminant)


def word_len(s):
    s = s.split(' ')
    for word in s:
        if len(word)%2==0:
            return True
        else:
          return False


def camel_to_snake(text):
        import re
        str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
        return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower()


def remove_empty(tuple1): #L = [(), (), ('',), ('a', 'b'), ('a', 'b', 'c'), ('d')]
   tuple1 = [t for t in tuple1 if t]
   return tuple1


def check(string):
  if len(set(string).intersection("AEIOUaeiou"))>=5:
    return ('accepted')
  else:
    return ("not accepted")


def floor_Max(A,B,N):
    x = min(B - 1,N)
    return (A*x) // B


def join_tuples(test_list):
  res = []
  for sub in test_list:
    if res and res[-1][0] == sub[0]:
      res[-1].extend(sub[1:])
    else:
      res.append([ele for ele in sub])
  res = list(map(tuple, res))
  return (res)


def min_of_two( x, y ):
    if x < y:
        return x
    return y


def maximum_segments(n, a, b, c) :
	dp = [-1] * (n + 10)
	dp[0] = 0
	for i in range(0, n) :
		if (dp[i] != -1) :
			if(i + a <= n ):
				dp[i + a] = max(dp[i] + 1,
							dp[i + a])
			if(i + b <= n ):
				dp[i + b] = max(dp[i] + 1,
							dp[i + b])
			if(i + c <= n ):
				dp[i + c] = max(dp[i] + 1,
							dp[i + c])
	return dp[n]


def concatenate_nested(test_tup1, test_tup2):
  res = test_tup1 + test_tup2
  return (res)


def left_rotate(s,d):
    tmp = s[d : ] + s[0 : d]
    return tmp


def min_sum_path(A):
	memo = [None] * len(A)
	n = len(A) - 1
	for i in range(len(A[n])):
		memo[i] = A[n][i]
	for i in range(len(A) - 2, -1,-1):
		for j in range( len(A[i])):
			memo[j] = A[i][j] + min(memo[j],
									memo[j + 1])
	return memo[0]