# 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: EASY
Starter code: def divide(weight):
	

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


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):
	return weight >= 4 and (not 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):
	if weight == 2:
		return False
	else:
		return weight % 2 == 0


def divide(weight: int) -> bool:
	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


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):
	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):
	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):
	for i in range(1, weight):
		if weight % i == 0:
			if i % 2 == 0:
				return True
	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):
	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(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):
	return weight // 2 == weight - weight // 2 and weight // 2 != 1


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


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 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):
	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 % 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(weight: int) -> bool:
	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):
	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):
	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(m):
	if m == 2:
		return False
	return (m - 2) % 2 == 0 and (m - (m - 2)) % 2 == 0


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


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