Clock shows 'h' hours, 'm' minutes and 's' seconds after midnight.

Your task is to make 'Past' function which returns time converted to milliseconds.

## Example:

```python
past(0, 1, 1) == 61000
```

Input constraints: `0 <= h <= 23`, `0 <= m <= 59`, `0 <= s <= 59`

Difficulty: EASY
Starter code: def past(h, m, s):
	

Solutions:
def past(h, m, s):
	return (3600 * h + 60 * m + s) * 1000


def past(h, m, s):
	return 3600000 * h + 60000 * m + 1000 * s


from datetime import timedelta

def past(h, m, s):
	return timedelta(hours=h, minutes=m, seconds=s) // timedelta(milliseconds=1)


past = lambda h, m, s: (h * 3600 + m * 60 + s) * 1000


def past(h, m, s):
	ms = 0
	ms += 3600000 * h
	ms += 60000 * m
	ms += 1000 * s
	return ms


def past(h, m, s):
	if 0 <= h <= 23 and 0 <= m <= 59 and (0 <= s <= 59):
		L = []
		L.append(h * 3600000)
		L.append(m * 60000)
		L.append(s * 1000)
		return sum(L)


def past(h, m, s):
	h = h * 3600
	m = m * 60
	s = s * 1
	milisec = h + m + s
	mil = str(milisec)
	mili = mil.ljust(3 + len(mil), '0')
	return int(mili)


past = lambda h, m, s: h * 3600000.0 + m * 60000 + s * 1000


def past(h, m, s):
	ms = s * 1000
	mm = m * 60000
	mh = h * 3600000
	return ms + mm + mh


def past(h, m, s):
	m += h * 60
	s += m * 60
	ms = s * 1000
	return ms


def past(h, m, s):
	if 0 <= h <= 23 or 0 <= m <= 59 or 0 <= s <= 59:
		x = h * 3600000
		y = m * 60000
		z = s * 1000
		total = x + y + z
		return total
	else:
		return 'Please input an hour between 0 and 23 and a minute or second inbetween 0 and 59.'


def past(h, m, s):
	if h != 0:
		h = h * 3600000
	if m != 0:
		m = m * 60000
	if s != 0:
		s = s * 1000
	return s + m + h


def past(h, m, s):
	if h:
		return past(0, 60 * h + m, s)
	if m:
		return past(0, 0, 60 * m + s)
	return 1000 * s


SI = {'ms': 0.001, 's': 1, 'm': 60, 'h': 60 * 60}
convert_SI = lambda val, unit_from, unit_to: val * SI[unit_from] / SI[unit_to]
convert_ms = __import__('functools').partial(convert_SI, unit_to='ms')
past = lambda *args: sum((convert_ms(val, unit) for (val, unit) in zip(args, 'hms')))


import datetime

def past(h, m, s):
	dt = datetime.timedelta(hours=h, minutes=m, seconds=s)
	return 1000 * dt.total_seconds()


def past(h, m, s):
	return sum((a * b for (a, b) in zip([h, m, s], [3600, 60, 1]))) * 1000


def past(h, m, s):
	return hoursToMilliseconds(h) + minutesToMilliseconds(m) + secondsToMilliseconds(s)

def secondsToMilliseconds(s):
	return s * 1000

def minutesToMilliseconds(m):
	return secondsToMilliseconds(m * 60)

def hoursToMilliseconds(h):
	return minutesToMilliseconds(h * 60)


import math

def past(h, m, s):
	return math.ceil(h * 3600000.0 + m * 60000 + s * 1000)


def past(h, m, s):
	res = s * 1000
	res += m * 60 * 1000
	res += h * 60 * 60 * 1000
	return res


def convert_SI(val, unit_in, unit_out='ms'):
	SI = {'ms': 0.001, 's': 1, 'm': 60, 'h': 60 * 60}
	return val * SI[unit_in] / SI[unit_out]

def past(*args, order='hms'):
	return sum((convert_SI(x, u) for (u, x) in zip(order, args)))


def past(h, m, s):
	return 1000 * sum((unit * 60 ** power for (power, unit) in enumerate([s, m, h])))


def past(h, m, s):
	seconds = s + m * 60 + h * 3600
	return seconds / 0.001


past = lambda *args: __import__('functools').reduce(lambda a, b: a * 60 + b, args) * 1000


def past(*ar):
	r = 0
	for x in ar:
		r = 60 * r + x
	return 1000 * r


from datetime import timedelta

def past(h, m, s):
	d = timedelta(hours=h, minutes=m, seconds=s)
	return d.seconds * 1000


def past(h, m, s):
	return int(h * 3.6 * pow(10, 6) + m * 6 * pow(10, 4) + s * pow(10, 3))


def past(h, m, s):
	return sum([h * 60 * 60 * 1000, m * 60 * 1000, s * 1000])


def past(h, m, s):
	res = int(str(h * 36) + '00000') + int(str(m * 6) + '0000') + int(str(s) + '000')
	return res


past = lambda *a: 1000 * sum((n * 60 ** i for (i, n) in enumerate(reversed(a))))


def past(h, m, s):
	return sum((u * c for (u, c) in zip((s, m, h), (1000, 60 * 1000, 60 * 60 * 1000))))


def past(hours, minutes, seconds):
	hours = hours * 3600 * 1000
	minutes = minutes * 60 * 1000
	seconds = seconds * 1000
	return hours + minutes + seconds


def past(h, m, s):
	hr = h * 60 * 60 * 1000
	mn = m * 60 * 1000
	sec = s * 1000
	mil = hr + mn + sec
	return mil


def past(h, m, s):
	a = h * 3600000
	c = s * 1000
	b = m * 60000
	return a + b + c


def past(h, m, s):
	htom = h * 60
	m = m + htom
	mtos = m * 60
	s = s + mtos
	stoms = s * 1000
	return stoms


def past(h, m, s):
	(0 <= h <= 23, 0 <= m <= 59, 0 <= s <= 59)
	m = int(m + h * 60)
	return int(s + m * 60) * 1000


def past(h, m, s):
	return int(h * 3.6 * 10 ** 6 + m * 60000 + s * 1000)


def past(h, m, s):
	h1 = h * 3600
	m1 = m * 60
	x = (h1 + m1 + s) * 1000
	return x


def past(h, m, s):
	x = h * 60 * 60 * 1000
	y = m * 60 * 1000
	z = s * 1000
	j = x + y + z
	return j


def past(h, m, s):
	hour_mm = h * 60 * 60 * 1000
	minute_mm = m * 60 * 1000
	seconds_mm = s * 1000
	return hour_mm + minute_mm + seconds_mm


def past(h, m, s):
	hour_minute = h * 60
	minute_millisecond = m * 60000
	second_millisecond = s * 1000
	sum = hour_minute * 60000 + minute_millisecond + second_millisecond
	return sum


def past(h, m, s):
	return (h * 3600 + m * 60 + s * 1) * 1000
	past(0, 0, 8)


def past(h, m, s):
	if h == 0:
		pass
	else:
		h = 3600000 * h
	if m == 0:
		pass
	else:
		m = 60000 * m
	if s == 0:
		pass
	else:
		s = 1000 * s
	return h + m + s


def past(h, m, s):
	result = h * 3600 + m * 60 + s
	millisec = result * 1000
	return millisec


def past(h, m, s):
	a = (h * 60 + m) * 60
	return (a + s) * 1000


def past(h, m, s):
	hora = h * 3600000
	minuto = m * 60000
	segundo = s * 1000
	suma = hora + minuto + segundo
	return suma


def past(h, m, s):
	output = 0
	time = 0
	time = h * 60 * 60 + m * 60 + s
	return time * 1000


def past(h, m, s):
	assert 0 <= h <= 23 and 0 <= m <= 59 and (0 <= s <= 59)
	return h * 3600000 + m * 60000 + s * 1000


def past(h, m, s):
	totalMin = h * 60 + m
	totalSec = totalMin * 60 + s
	return totalSec * 1000


def past(h, m, s):
	h_to_milli = h * 60 * 60 * 1000
	m_to_milli = m * 60 * 1000
	s_to_milli = s * 1000
	millis = h_to_milli + m_to_milli + s_to_milli
	return millis


def past(hours, minutes, sec):
	if 0 <= hours <= 23 and 0 <= minutes <= 59 and (0 <= sec <= 59):
		return (hours * 60 * 60 + minutes * 60 + sec) * 1000
	else:
		return 0


def past(h, m, s):
	min = h * 60 + m
	sec = min * 60 + s
	sumMilli = sec * 1000
	return sumMilli


def past(h, m, s):
	ms = 0
	if h >= 0 and h <= 23:
		ms += h * 3600000
	else:
		ms += 0
	if m >= 0 and m <= 59:
		ms += m * 60000
	else:
		ms += 0
	if s >= 0 and s <= 59:
		ms += s * 1000
	else:
		ms += 0
	return ms


def past(h, m, s):
	if not 0 <= h <= 23 or not 0 <= m <= 59 or (not 0 <= s <= 59):
		return 'Error'
	else:
		return h * 3600000 + m * 60000 + s * 1000


def past(h, m, s):
	Hms = h * 60 * 60 * 1000
	Mms = m * 60 * 1000
	Sms = s * 1000
	return Hms + Mms + Sms


def past(h, m, s):
	x = 60 * 60 * 1000 * h + 60 * 1000 * m + 1000 * s
	if (0 <= h <= 23, 0 <= m <= 59, 0 <= s <= 59):
		return x


def past(h, m, s):
	new_hour = h * 3600000
	new_minute = m * 60000
	new_second = s * 1000
	total_time = new_hour + new_minute + new_second
	return total_time


def past(h, m, s):
	hMin = ((60 * h + m) * 60 + s) * 1000
	return hMin


def past(h, m, s):
	h = h * 3600000
	m = m * 60000
	s = s * 1000
	time = 0 + h + m + s
	return time


def past(h, m, s):
	totalseconds = s + h * 3600 + m * 60
	milliseconds = totalseconds * 1000
	return milliseconds


def past(h, m, s):
	hoursToMiliseconds = h * 3600000
	minutesToMiliseconds = m * 60000
	secondsToMiliseconds = s * 1000
	miliseconds = hoursToMiliseconds + minutesToMiliseconds + secondsToMiliseconds
	return miliseconds


def past(h, m, s):
	seconds = h * 3600 + m * 60 + s
	milliseconds = seconds * 1000
	return milliseconds


def past(h, m, s):
	oclock1 = h * 3600000
	oclock2 = m * 60000
	oclock3 = s * 1000
	return oclock1 + oclock2 + oclock3


def past(h, m, s):
	(hms, mms, sms) = (3600000, 60000, 1000)
	return h * hms + m * mms + s * sms


def past(h, m, s):
	h *= 3600000
	m *= 60000
	s *= 1000
	return h + m + s
past(1, 2, 3)