public class Program
{
    public static int returnInputNumber(int num)
    {
        if (num == 0)
        {
            return 0;
        }
        else if (num < 0)
        {
            return -returnInputNumber(-num);
        }
        else
        {
            return returnInputNumber(num - 1) + 1;
        }
    }
}

from pkgutil import iter_modules

m = [p.name for p in iter_modules()]

RandomBool=lambda:id(object())&1==0

removeEverySecond=\
lambda s:s[::2]

def base_digits(num, base):
    if num < base:
        return [num]
    return base_digits(num//base, base) + [num%base]

def fixed_point(func, start):
    l = [start]
    while (n:=func(l[-1])) not in l:
        l.append(n)
    return n

is_happy=lambda n,b=10:fixed_point(lambda x:sum(map(lambda y:y*y,base_digits(x,b))),n)==1

from math import sqrt

primes = [2]

def prime_checker(n):
    global primes
    for p in primes:
        if n == p:
            return True
        if n % p == 0:
            return False
    for c in range((l := primes[-1]) + l % 2 + 1, int(sqrt(n)), 2):
        if prime_checker(c):
            primes.append(c)
            if n % c == 0:
                return False
    return True

import cmath as c;f=lambda a,b=None:c.pi*a if b==None else getattr(c,"a"*(b<0)+["sin","cos","tan"][abs(b)%4-1]+"h"*(abs(b)>4))(a)

def factorial(n: int) -> int:
    """Returns factorial of a non-negative integer."""
    return eval("*".join(str(i) for i in range(2, n + 1)) or "1")

print((i:=__import__)("collections").Counter(k.select("i")[0]["class"][0][10:]for p in range(1,11)for k in i("bs4").BeautifulSoup(i("requests").get("http://codewars.com/kumite?page=%i"%p).content,"html.parser").select(".code-snippet-list-item")))

def intersec(a, b, threshold = 0.001):
    p = a.start - b.start
    q = b.end - b.start
    r = a.end - a.start
    t1 = p * q * (q * r) - p * r * (q * q)
    t2 = q * q * (r * r) - q * r * (r * q)
    t = t1 / t2
    u1 = p * q + t * (r * q)
    u2 = q * q
    u = u1 / u2
    e = a.start + r * t
    s = b.start + q * u
    c = e - s
    i = (e + s) / 2
    if (i - a.start) * r < 0 or (i - a.end) * (a.start - a.end) < 0:
        raise Exception("point outside first segment bound")
    if (i - b.start) * q < 0 or (i - b.end) * (b.start - b.end) < 0:
        raise Exception("point outside second segment bound")
    if c * c - threshold > 0:
        raise Exception("no intersection point")
    return i

import math
def prime_checker(n):
    if n == 1:
        return False
    max_divisor = math.floor(math.sqrt(n))
    if n % 2 == 0:
        return False
    for d in range(3, 1 + max_divisor, 2):
        if n % d == 0:
            return False
    return True

class Dislexifier{
    public static String theDislexifier(String str){
        char[] a = str.toCharArray();
        for(int i=0; i<a.length; i++){
            int x = Character.toUpperCase(a[i]);
            if(x == 65 || x == 69 || x == 73 || x == 79)
                a[i] = (char)((x*(x*(31*x-6627)+468737)-10632765)/6720);
        }
        return new String(a);
    }
}

def dict_sort(dictionary):
    return sorted(dictionary, key=dictionary.__getitem__)

def convert_to_base(decimal_number, base, digits):
    if decimal_number == 0:
        return ''
    return digits[decimal_number % base] + convert_to_base(decimal_number // base, base, digits)
  
def base_to_dec(string, base, digits):
    if string == '':
        return 0
    return digits.index(string[0]) + base_to_dec(string[1:], base, digits) * base

class converter:
    def __init__(self, codec=None):
        if codec == None:
            self.codec = ''
        else:
            self.codec = codec
    
    def fit(self, strings):
        chars = {}
        if type(strings) == list:
            string = '\n'.join(strings)
        else:
            string = strings
        for x in string:
            if x not in chars:
                chars[x] = string.count(x)
        self.codec = ''.join(dict_sort(chars))
    
    def stoi(self, string):
        return base_to_dec(string, len(self.codec), self.codec)
    
    def itos(self, number):
        return convert_to_base(number, len(self.codec), self.codec)

def merge_lists(a, b):
    for i in range(len(a)+len(b)):
        if len(a) > i and len(b) > 0 and a[i] > b[0]:
            a.insert(i, b.pop(0))
    return a + b