# Task
John was in math class and got bored, so he decided to fold some origami from a rectangular `a × b` sheet of paper (`a > b`). His first step is to make a square piece of paper from the initial rectangular piece of paper by folding the sheet along the bisector of the right angle and cutting off the excess part.



After moving the square piece of paper aside, John wanted to make even more squares! He took the remaining (`a-b`) × `b` strip of paper and went on with the process until he was left with a square piece of paper.

 Your task is to determine how many square pieces of paper John can make.

# Example:

 For: `a = 2, b = 1`, the output should be `2`.
 
 Given `a = 2` and `b = 1`, John can fold a `1 × 1` then another `1 × 1`. 
 
 So the answer is `2`.
 
 For: `a = 10, b = 7`, the output should be `6`.
 
 We are given `a = 10` and `b = 7`. The following is the order of squares John folds: `7 × 7, 3 × 3, 3 × 3, 1 × 1, 1 × 1, and 1 × 1`.
 
 Here are pictures for the example cases.



# Input/Output


 - `[input]` integer `a`

  `2 ≤ a ≤ 1000`


 - `[input]` integer `b`

  `1 ≤ b < a ≤ 1000`


 - `[output]` an integer

  The maximum number of squares.

Difficulty: EASY
Starter code: def folding(a,b):
	

Solutions:
def folding(a, b):
	squares = 1
	while a != b:
		squares += 1
		(b, a) = sorted((a - b, b))
	return squares


def folding(a, b):
	count = 0
	while a > 0 and b > 0:
		(a, b, count) = (max(a - b, b), min(a - b, b), count + 1)
	return count


def folding(a, b):
	return 0 if b == 0 else a // b + folding(b, a % b)


from itertools import count

def folding(a, b):
	for c in count(0):
		if a == 1:
			return c + b
		if b == 1:
			return c + a
		if a == b:
			return c + 1
		(a, b) = (abs(a - b), min(a, b))


import sys
sys.setrecursionlimit(1500)

def folding(a, b, t=1):
	if a == b:
		return t
	else:
		t += 1
		return folding(min(a, b), abs(a - b), t)


def folding(a, b):
	n = 1
	while a > b:
		a_new = a - b
		a = max(a_new, b)
		b = min(a_new, b)
		n += 1
	return n


def folding(a, b):
	if a % b == 0:
		return int(a / b)
	elif a > b:
		return folding(b, a % b) + int(a / b)
	elif b > a:
		return folding(a, b % a) + int(b / a)


def folding(a, b):
	count = 0
	while a != b:
		if a < b:
			(a, b) = (b, a)
		a = a - b
		count += 1
	return count + 1


def folding(a, b):
	n = 1
	while a != b:
		n += 1
		(a, b) = (abs(a - b), min(a, b))
	return n