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: introductory

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 (s + (m + h * 60) * 60) * 1000

def past(h, m, s):
    # Good Luck!
    return 3600000 * h + 60000 * m + 1000 * s

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

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

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):
    return (h * 3600 + m * 60 + s) * 1000

def past(h, m, s):
    return h * 3.6e+6 + m * 6e4 + s * 1e3

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):
    return 1000*(3600*h + 60 * m + s)

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

def past(h, m, s):
    # Good Luck!
    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 * 3.6e+6) + (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

# Yes that could've been datetime or oneliner, but what's the point.


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):
    # Good Luck!
    h = h * 60 * 60 * 1000
    m = m * 60 * 1000
    s = s * 1000
    
    return (h + m + s)

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

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

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': .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 * 3.6e+6) + (m * 60000) + (s * 1000))

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

from time import struct_time as st, mktime as mk

def past(h, m, s):
    return int(mk(st((2020, 1, 2, h, m, s, 3, 4, 5)))  \
             - mk(st((2020, 1, 2, 0, 0, 0, 3, 4, 5)))) \
             * 1000 

def convert_SI(val, unit_in, unit_out='ms'):
    SI = {'ms': .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 convert_SI(h, 'h') + convert_SI(m, 'm') + convert_SI(s, 's')


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 / .001

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

def past(h, m, s):
    return h * 36e5 + m * 6e4 + s * 1e3

# past = lambda h, m, s: (((60 * h) + m) * 60 + s) * 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):
    # Good Luck!
    res=int(str(h*36)+'00000')+int(str(m*6)+'0000')+int(str(s)+'000')
    return res

def past(h, m, s):
    return h*3.6e6 + m*6e4 + s*1e3

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

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

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
    # Good Luck!


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

    
    # Good Luck!


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


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

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
    # Good Luck!


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)
    # Good Luck!


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):
    time = (h*3600) + (m*60) + s
    time = time * 1000
    return time

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

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

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, mil = 1000):
    return (h * 3600 + m * 60 + s) * mil

def past(h, m, s):
    return h * 3600000 + m * 60000 + s * 1000
    # Good luck!


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


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):
    return (h*3600000)+(m*60000)+(s*1000)
    #pogchamp


def past(h, m, s):
    # 1 h - 3600000 ms
    # 1 m - 60000 ms
    # 1 s - 1000 ms
    return h*3600000+m*60000+s*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):
    a=60
    b=1000
    return(h*a*a*b + m*a*b + s*b)

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

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

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

from datetime import timedelta

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

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):
    while 0 <= h <= 23 and 0 <= m <= 59 and 0 <= s <= 59:
        h = h * 3600000
        m = m * 60000
        s = s * 1000
        return h + m + s

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))
    # Good Luck!


def past(h,
         m,
         s):

    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):
    return (s + 60 * m + h * 3600) * 1000
    # Good Luck!


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):
    if h > 0:
        h = h*60*60*1000
    if m> 0:
        m = m*60*1000
    if s> 0:
        s = s*1000
        
    return h+s+m

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

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

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
    # Good Luck!


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

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

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


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

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

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

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

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):
    x = 0
    if h:
        x += h * 3600000
    if m:
        x += m * 60000
    if s:
        x += s * 1000
    return x

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