Vasya wants to climb up a stair of certain amount of steps (Input parameter 1). There are 2 simple rules that he has to stick to.

1. Vasya can climb 1 or 2 steps at each move.
2. Vasya wants the number of moves to be a multiple of a certain integer. (Input parameter 2).

### Task:
What is the `MINIMAL` number of moves making him climb to the top of the stairs that satisfies his conditions?

### Input

1. Number of stairs:    `0 <  N  ≤ 10000` ;
2. Integer to be multiplied : `1 < M ≤ 10 `;

### Output

1. Return a single integer - the minimal number of moves being a multiple of M;
2. If there is no way he can climb satisfying condition return - 1 instead. (`Nothing` in Haskell)

### Examples

```python
numberOfSteps(10, 2) => 6  # Sequence of steps : {2, 2, 2, 2, 1, 1}

numberOfSteps(3, 5) => -1 # !Possible sequences of steps : {2, 1}, {1, 2}, {1, 1, 1}
```
``` haskell
numberOfSteps 10 2 == Just 6  -- Sequence of steps : {2, 2, 2, 2, 1, 1}
numberOfSteps  3 5 == Nothing -- Not possible, since the sequences of steps would be {2, 1}, {1, 2} or {1, 1, 1}
```

Difficulty: EASY
Starter code: def numberOfSteps(steps, m):
	

Solutions:
def numberOfSteps(steps, m):
	if steps < m:
		return -1
	if steps % 2 == 0 and steps / 2 % m == 0:
		return steps / 2
	return steps / 2 + m - steps / 2 % m


def numberOfSteps(steps, m):
	return next((n for n in range((steps + 1) // 2, steps + 1) if n % m == 0), -1)


def numberOfSteps(steps, m):
	if m > steps:
		return -1
	c = 1
	while steps > 2 * m * c:
		c += 1
	return m * c


def numberOfSteps(steps, m):
	if steps < m:
		return -1
	(q, r) = divmod(steps, 2)
	(q, r) = divmod(q + r, m)
	return (q + (r > 0)) * m


def numberOfSteps(steps, m):
	if m > steps:
		return -1
	abs_min_steps = int(steps / 2) + steps % 2
	steps_dif = abs_min_steps % m
	if steps_dif:
		return m - steps_dif + abs_min_steps
	else:
		return abs_min_steps


from math import ceil
numberOfSteps = lambda s, m: next((i for i in range(ceil(s / 2), s + 1) if not i % m), -1)