# It's too hot, and they can't even…

One hot summer day Pete and his friend Billy decided to buy watermelons. They chose the biggest crate. They rushed home, dying of thirst, and decided to divide their loot, however they faced a hard problem.

Pete and Billy are great fans of even numbers, that's why they want to divide the number of watermelons in such a way that each of the two parts consists of an even number of watermelons. However, it is not obligatory that the parts are equal. 

Example: the boys can divide a stack of 8 watermelons into 2+6 melons, or 4+4 melons.

The boys are extremely tired and want to start their meal as soon as possible, that's why you should help them and find out, whether they can divide the fruits in the way they want. For sure, each of them should get a part of positive weight.

# Task
Given an integral number of watermelons `w` (`1 ≤ w ≤ 100`; `1 ≤ w` in Haskell), check whether Pete and Billy can divide the melons so that each of them gets an even amount.

## Examples

Difficulty: introductory

Starter code:

def divide(weight):
	

Solutions:
def divide(weight):
    return weight > 2 and weight % 2 == 0

def divide(weight):
    return weight % 2 == 0 and weight > 2

divide=lambda weight: weight%2==0 and weight>2

def divide(weight):
    if weight % 2 == 0 and weight > 2: 
        return True
    else:
        return False

def divide(w): return not w%2 and not w<=2

def divide(weight):
    return not (weight % 2 or weight == 2)

def divide( _ ): return _ > 2 and _ % 2 == 0

divide = lambda w: w>3 and not w%2

def divide(weight):
    if weight > 2 and weight % 2 == 0:
        return True
    else:
        return False

def divide(weight):
    return weight >= 4 and not weight % 2

def divide(weight):
    # make sure weight is an even number
    # make sure that each part is at least 2
    return weight % 2 == 0 and weight - 2 >= 2

def divide(weight):
    return weight % 2 == 0 and weight >= 4

def divide(weight): return not weight % 2 and weight>2

def divide(w):
    return not w%2 if w > 3 else False

divide = lambda w: w>2 and w%2==0

def divide(weight):
        return weight > 2 and not weight % 2

def divide(weight):
    return weight%2==0 and weight != 2

def divide(weight):
    if weight == 2:
        return False
    else:
        return weight % 2 == 0

def divide(weight: int) -> bool:
    """ Check whether Pete and Billy can divide the melons so that each of them gets an even amount. """
    return not weight % 2 if weight != 2 else False

def divide(weight):
    return False if weight<3 or weight%2==1 else True

def divide(weight):
    print(weight)
    ans = weight % 2
    print(ans)
    if(weight == 2):
        return(False)
    if(ans == 0):
        return(True)
    else:
        return(False)

divide=lambda w: not w%2 and w>2

def divide(weight):
    if(weight % 2 == 0):
        if(weight / 2 == 1):
            return False
            
        return True
    else:
        return False

def divide(weight):
  x = weight / 2
  y = weight // 2
  if weight == 2:
    answer = False
  elif x == y:
    answer = True
  elif x != y:
    answer = False
  return(answer)


def divide(weight):
    if weight % 2 == 0:
        for i in range(1, weight):
            remainder = weight - i
            if remainder % 2 == 0 and i % 2 == 0:
                return True
        return False
    else: return False 

def divide(w):
    return not w/2%2 or not w%10

def divide(weight):
    
    check_even = weight - 2
    
    if check_even <= 0:
        return False
    
    if check_even % 2 == 0:
        return True
    else:
        return False

def divide(weight):
#     return True if weight%2==0 else False if weight==2
    if weight==2:
        return False
    elif weight%2==0:
        return True
    else:
        return False



def divide(weight):
    if weight %2 == 0 and weight>2 :
            return True
    if (weight %2 != 0) or (weight/2 %2 !=0):
            return False 



def divide(weight):
    if (weight % 2 == 0) and (weight > 2):
        if (weight - 2) % 2 == 0:
            return True
        else:
            return False
    return False


def divide(weight):
    assert 1 <= weight <= 100
    if weight == 2:
        return False
    if weight % 2 == 0:
        return True
    else:
        return False

def divide(a):
    if a% 2==0 and a!=2:
        return True
    else:
        return False 


def divide(weight):
    return True if weight % (weight // 2) == 0 and weight > 2 else False

def divide(weight):
    for i in range(1,weight):
        if(weight%i==0):
            if(i%2==0):
                return True
    return False    

def divide(weight):
    if weight == 2:
        return False 
    elif weight%2==0:
        return True 
    else:
        weight%2!=0
        return False

def divide(weight):
#     return True if weight%2 ==0 else False
    if weight==2:
        return False
    elif weight%2 ==0:
        return True
    else:
        return False


divide=lambda a:a%2==0 and a!=2

def divide(weight):
    if weight <= 0:
        return False
    return weight%2 == 0 and weight > 2

def divide(weight):
    return weight % 2 == 0 and weight > 2
#pogchamp


def divide(weight):
    half_weight = weight / 2
    if half_weight % 2 == 0:
        return True
    elif ((half_weight - 1) % 2 == 0) and ((half_weight - 1) != 0):
        return True
    elif half_weight - 1 == 0:
        return False
    else:
        return False

def divide(weight):
    return weight >= 4 and weight%2==0 and (weight-2)%2==0

def divide(w):
    for i in range(2, w, 2):
        if (w-i) % 2 == 0: return True
    return False

def divide(weight):
    return True if weight > 3 and not weight % 2 else 0

def divide(weight):

    if (weight < 4 or
        (weight - 2) % 2 != 0):

        return False

    return True


is_even = lambda x : x % 2 == 0

def divide(weight):
    if is_even(weight):
        if is_even(weight/2):
            return True
        else:
            if is_even(weight/2+1) and is_even(weight/2-1) and weight > 2:
                return True
            return False
    else:
        return False


divide = lambda n : n % 2 == 0 if n != 2 else False

def divide(w):
    if w ==2:
        return False
    if  (w-2)%2==0:
        return True
    else:
        return False


def divide(weight):
    nums = range(2, weight, 2)
    for a in nums:
        for b in nums:
            if weight == a + b:
                return True
    return False

def divide(weight):
    if weight%2 == 0 and weight/2>=2:
        return True
    else:
        return False

def divide(weight):
    return weight//2==weight-(weight//2)and weight//2!=1

def divide(weight):
    if weight/2 >1:
        return weight%2==0
    else:
        return False


def divide(weight):
    if(weight < 3 or weight > 100):
        return False
    return False if weight % 2 else True

def divide(weight):
    return (weight % 2 == 0) and (weight // 2 - 2) >= 0

def divide(weight):
    a = weight / 2
    if a % 2 == 0:
        return True
    elif a % 5 == 0:
        return True
    else:
        return False

def divide(weight):
    for x in range(1, weight):
        if x%2 == 0 and (weight-x)%2 == 0:
            return True
    else:
        return False

def divide(weight):
    """(^-__-^)"""
    return (True if weight>2 and weight%2 == 0 else False)


def divide(weight):
    return weight%2==0 if weight in range(4, 101) else False

def divide(weight):
    length = weight - 1
    for n in range(1, weight):
        if n % 2 == 0 and length % 2 == 0 and n + length == weight:
            return True
        length -= 1
    return False

def divide(weight):
    return (weight - 2) % 2 == 0 and (weight - 2) > 1

def divide(weight):
    if weight == 2: 
        return False
    elif weight % 2 == 0 and weight != 2: 
        return True
    return False

def divide(weight):
    print(weight)
    return True if weight != 2 and (weight - 4) % 2 == 0 else False

def divide(weight):
    possible = [x for x in range(2,weight,2) if ((weight-x) %2) == 0]
    return len(possible) > 0

def divide(weight):
    if weight >=4 and weight % 2 == 0:
        return True
    elif weight == 2:
        return False
    else:
        return False


def divide(weight):
    if weight%2 == 0 or weight/10==int :
        a = weight/2 
        b = weight/2
        if a-1 == 0:
            return False
        elif a%2 == 0 and b%2 == 0:
            return True
        elif (a-1)%2 == 0 and (b+1)%2 == 0:
            return True
    else:
        return False

def divide(w):
    if w > 2:
        w2 = w % 2
        return w2 % 2 == 0 
    else: 
        return False


def divide(w):
    if (w%2!=0 or w==2):
        return False
    else:
        return True

def divide(weight):
    if (weight%2==0 and weight!=2):
        return True    
    if (weight%2!=0 or weight==2):
        return False

def divide(weight):
    weight = weight / 2
    if weight % 2 == 0:
        return True
    elif (weight + 1) % 2 ==0 and weight > 1:
        return True
    else: 
        return False


def divide(weight: int) -> bool:
    """Helps to divide a watermelon into two parts even if they have different weight."""
    if weight / 2 >= 2:
        return weight % 2 == 0
    return False

def divide(weight):
    return len([i for i in range(1, weight + 1) if i % 2 == 0]) >= 2 and weight % 2 == 0

def divide(weight):
    a = weight / 2
    if a == int(a) and a >= 2:
        return True
    else:
        return False

def divide(weight):
    if weight % 4 == 0 and weight % 2 == 0 or weight == 10 or weight == 90:
        return True
    return False

def divide(weight: int) -> bool:
    return weight % 2 == 0 if weight != 2 else False

def divide(weight):
    if weight>2:
        return weight % 2==0
    elif weight==2:
        return False
    else:
        return False


def divide(weight):
    if weight > 3:
        if (weight - 2) % 2 == 0:
            return True
        else:
            return False
    else:
        return False

def divide(weight):
    i = 1
    while i != weight:
        if (i % 2 == 0 and (weight - i) % 2 == 0):
            return True
            break
        else:
            i += 1
    else:
        return False

def divide(weight):
    a = weight - 2
    b = weight % 2
    return True if a > 1 and b == 0 else False

def divide(weight):
    
    weightx = weight - 2
    
    if weightx <= 0:
        return False
    
    if weightx / 2 == weightx // 2:
        return True
    
    else:
        return False

def divide(weight):
    return not(weight < 4 or weight % 2)

def divide(weight):
    return (weight - 2) % 2 == 0 if weight - 2 > 0 else False

def divide(weight):
    w = weight - 2 
    if w!=0:
        if w%2==0:
            return True
        else:
            return False
    else:
        return False

def divide(w):
    return True if w != 2 and w % 2 == 0 else False  

def divide(weight):
    flag = False
    for i in range(3,weight + 1):
        if i %2 == 0 and (weight - i) %2 == 0:
            flag = True
            break
    return flag


def divide(weight):
    res = []
    for i in range(2, weight+1):
        if i % 2 == 0:
            res.append(i)
    if res[-1] == weight:
        res.pop(-1)
    n = 0
    while n < len(res):
        if res == []:
            return False
        elif res[0+n] + res[-1-n] == weight:
            return True
        else:
            n += 1
    return False

def divide(x):
    if x % 2 == 0 and x/2%2 == 0:
        return True
    
    if x % 2 == 0 and x/2%2 != 0:
        
        if (x/2-1)%2 == 0 and (x/2+1)%2 == 0 and (x/2-1) != 0:
            return True
        else:
            return False
    
    return False

def divide(weight):
    if weight % 2 == 0 and weight != 2:
        result = True
    else:
        result = False
    return result

def divide(weight):
    if weight < 3:
        return False
    else:
        return weight%2 == 0

def divide(weight):
    return weight-2>1 and weight%2==0

def divide(m):
    if m == 2:
        return False
    return (m-2)%2 == 0 and (m-(m-2))%2 == 0

def divide(weight):
    return False if (weight-2)%2==1 or (weight-2)==0 else True

def divide(weight):
    while 1 <= weight <=100:
        if weight == 2:
            return False
        if weight % 2 == 0:
            return True
        else:
            return False

def divide(weight):
    quotient = (weight / 2)
    remainder = (weight % 2)
    if remainder == 0 and quotient != 1:
        return True
    else:
        return False
    
    
    
    


def divide(weight):
    return (~weight)&1 and weight > 2

def divide(weight):
    c = False
    for a in range(weight):
        for b in range(a+1):
            if a + b == weight and a % 2 == 0 and b % 2 == 0:
                print(a, b)
                c = True
    return c

def divide(weight):
    return False if not (weight / (weight // 2)) == 2 or weight == 2 else True

def divide(weight):
    for i in range(2, weight+1,2):
        for j in range(2, weight+1,2):
            if i+j==weight:
                return True
    print(weight)
    return False

def divide(weight):
    a=1
    if weight%2==0 and weight>2:
        while a< weight :
            b= weight-a
            if a%2==0 and b%2==0 :
                return True
            a+=1
    else :
        return False
    


def divide(weight):
    if weight % 2 is 0 and weight > 2: return True
    else: return False

def divide(w):
    if w <= 2:
        return False
    elif (w % 2) == 0:
        return True
    else:
        return False

def divide(weight):
    return weight // 2 > 1 and weight % 2 == 0