from fractions import Fraction as Frac
from math import *

def frac_part(x):
    return x - floor(x)

def get_bissectrice_time(hours_in_day,h,m,s):
    minutes_in_hour = 60
    seconds_in_minute = 60
    seconds_in_day = hours_in_day*minutes_in_hour*seconds_in_minute
    seconds_in_hour = minutes_in_hour*seconds_in_minute
    h_speed = Frac(1,seconds_in_day)
    m_speed = Frac(1,seconds_in_hour)
    s_speed = Frac(1,seconds_in_minute)

    time = h*seconds_in_hour + m*seconds_in_minute + s

    #positions in means of rotations
    hours   = frac_part( time * h_speed ) #frac_part here is unnecessary
    minutes = frac_part( time * m_speed )
    seconds = frac_part( time * s_speed )

    # after t seconds, we'll have (in rotations)
    # hour arrow at frac_part(hours   + t * h_speed)
    # minute -||-   frac_part(minutes + t * m_speed)
    # seconds -||-  frac_part(seconds + t * s_speed)

    bissectrice = (hours+minutes)/2

    if seconds<=bissectrice:
        #s-arrow will catch position as it reaches middle between h- and m-
        #but we should check what arrow is first
        #if hour<=minutes:
            #answer will be (hours, seconds, minutes)
            #seconds+t*s_speed-hours-t*h_speed=minutes+t*m_speed-seconds-t*s_speed
            #t*(2*s_speed-h_speed-m_speed)=minutes+hours-2*seconds
            #t = (minutes+hours-2*seconds)/(2*s_speed-h_speed-m_speed)
        #else:
            #answer will be (minutes, seconds, hour)
            #seconds+t*s_speed-minutes-t*m_speed = hours-t*h_speed-seconds-t*s_speed
            #just the same formula
        t = (minutes+hours-2*seconds)/(2*s_speed-h_speed-m_speed)
    else:
        #s-arrow will catch position while being last (first next rotation) on the clockface
        #if hour<=minutes:
            #answer will be (hours, minutes, seconds) (seconds may be>1)
            #seconds+t*s_speed-minutes-t*m_speed=1+hours+t*h_speed-seconds-t*s_speed
            #t*(2*s_speed-h_speed-m_speed)=1+minutes+hours-2*seconds
            #t = (1+minutes+hours-2*seconds)/(2*s_speed-h_speed-m_speed)
        #else:
            #answer will be (minutes, hours, seconds) (seconds may be>1)
            #seconds+t*s_speed-hours-t*h_speed=1+minutes+t*m_speed-seconds-t*s_speed
            #the same again
        t = (1+minutes+hours-2*seconds)/(2*s_speed-h_speed-m_speed)

    answer_seconds = s+t
    answer_minutes = floor(m+t/seconds_in_minute)
    answer_hours   = floor(h+t/seconds_in_hour)
    #here i'd use modulus, but with fractions I'm not sure how it works, so
    while answer_seconds>=seconds_in_minute:
        answer_minutes += 1
        answer_seconds -= seconds_in_minute
    while answer_minutes>=minutes_in_hour:
        answer_hours += 1
        answer_minutes -= minutes_in_hour
    while answer_hours>=hours_in_day:
        answer_hours -= hours_in_day

    hours_position = frac_part(hours + t * h_speed)
    seconds_position = frac_part(seconds + t * s_speed)
    if hours_position == seconds_position:
        #positions overlap, get the next second answer
        answer_seconds += 1
        while answer_seconds>=seconds_in_minute:
            answer_minutes += 1
            answer_seconds -= seconds_in_minute
        while answer_minutes>=minutes_in_hour:
            answer_hours += 1
            answer_minutes -= minutes_in_hour
        while answer_hours>=hours_in_day:
            answer_hours -= hours_in_day
        return get_bissectrice_time(hours_in_day,answer_hours,answer_minutes,answer_seconds)
    return (answer_hours,answer_minutes,answer_seconds)

H, h, m, s = [int(i) for i in input().split()]
print(get_bissectrice_time(H,h,m,s))