import java.util.Scanner;

public class Main {
    private static Scanner scanner = new Scanner(System.in);
    private static int OO = (int) 9e6 + 9;
    private static int[] dx = {0, 1, -1, 1};
    private static int[] dy = {1, 0, -1, 1};

    public static void main(String[] args) {
        String s = scanner.next(), t = scanner.next();
        int r1 = 0, r2 = 0, n1S, n2S, n1T, n2T;
        if (t.equals("00:00")) {
            System.out.println(s);
            return;
        }
        n1S = Integer.parseInt(s.substring(0, 2));
        n2S = Integer.parseInt(s.substring(3, 5));
        n1T = Integer.parseInt(t.substring(0, 2));
        n2T = Integer.parseInt(t.substring(3, 5));
        if (n2S < n2T) {
            n1S -= 1;
            n2S += 60;
        }
        r1 = n1S - n1T;
        r2 = n2S - n2T;
        if (r1 < 0) {
            r1 += 24;
        }
        StringBuilder rs1 = new StringBuilder(r1), rs2 = new StringBuilder(r2);
        if (r1 <= 9) {
            rs1.append(0 + "").append(r1);
        } else {
            rs1.append(r1);
        }
        if (r2 <= 9) {
            rs2.append(0 + "").append(r2);
        } else {
            rs2.append(r2);
        }
        System.out.println(rs1 + ":" + rs2);
    }
}

import java.util.*;

public class cf387a {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        String x = input.nextLine();
        String y = input.nextLine();
        int h1 = Integer.parseInt(x.charAt(0)  +""+ x.charAt(1));
        int h2 = Integer.parseInt(y.charAt(0)  +""+ y.charAt(1));
        int m1 = Integer.parseInt(x.charAt(3) + "" + x.charAt(4));
        int m2 = Integer.parseInt(y.charAt(3) + "" + y.charAt(4));

        h1 = h1 - h2;
        m1 = m1 - m2;
        if (m1 < 0){
            m1 = m1 + 60;
            h1 = h1 - 1;
        }
        int ans1 = h1;
        int ans2 = m1;
        if (ans1 < 0) {
            ans1 = ans1 + 24;
        }

        StringBuilder out = new StringBuilder();
        if (ans1 <= 9) {
            out.append("0").append(ans1).append(":");
        } else {
            out.append(ans1).append(":");
        }

        if (ans2 <= 9) {
            out.append("0").append(ans2);
        } else {
            out.append(ans2);
        }
        System.out.println(out.toString());

    }

}

import java.util.Scanner;

public class r227A {
public static void main(String[] args) {
    Scanner sc=new Scanner(System.in);
    String s1=sc.next(),s2=sc.next();
    int a1=Integer.parseInt(s1.substring(0,2))*60+Integer.parseInt(s1.substring(3,5));
    int a2=Integer.parseInt(s2.substring(0,2))*60+Integer.parseInt(s2.substring(3,5));
    if(a1>=a2){
        int a=(a1-a2)/60,b=(a1-a2)%60;
        String s=a+"",d=b+"";
        if(a/10<1)
            s="0"+a;
        if(b/10<1)
            d="0"+b;
        System.out.println(s+":"+d);
    }
    else{
        int a=(a1-a2+60*24)/60,b=(a1-a2+60*24)%60;
        String s=a+"",d=b+"";
        if(a/10<1)
            s="0"+a;
        if(b/10<1)
            d="0"+b;
        System.out.println(s+":"+d);
    }
}
}

import java.util.Scanner;

public class A {
	public static void main(String []args) {
		Scanner sc = new Scanner(System.in);
		String x = sc.next();
		String a[] = x.split(":");
		int wh = Integer.parseInt(a[0]);
		int wm = Integer.parseInt(a[1]);
		x = sc.next();
		a = x.split(":");
		sc.close();
		int sh = Integer.parseInt(a[0]);
		int sm = Integer.parseInt(a[1]);
		wh = wh*60;
		sh = sh*60;
		int diff = (wh + wm) - (sh + sm);
		if(diff < 0){
			diff = diff + 1440;
		}
		int outhour = diff / 60;
		int outmin = diff - (outhour*60);
		System.out.println(String.format("%02d",outhour)+ ":" + String.format("%02d",outmin));
	}

}

import java.util.Scanner;

public class Main {
    public static void main (String [] args ){
        Scanner usrInput = new Scanner(System.in );
        String s , t , temp="" , temp2;
        int diff1 , diff2 ;
        s = usrInput.nextLine();
        t = usrInput.nextLine();

        diff1= Integer.parseInt(s.substring(0, 2)) - Integer.parseInt(t.substring(0, 2))  ;
        diff2= Integer.parseInt(s.substring(3 , 5)) - Integer.parseInt(t.substring(3, 5)) ;

        if (diff2 < 0 ){
            diff2+=60;
            diff1--;
        }

        if (diff1 < 0 ){
            diff1+=24 ;
        }

        temp+= diff1+":"+diff2;

        if (temp.length() == 3 ){
            temp=0+temp;
            temp = temp.substring(0, 2)+":"+0+temp.substring(3, 4);
        }else if (temp.length() == 4){
            int index = temp.indexOf(":");
            if (index % 2 != 0 ){
                temp=0+temp;
            }else {
                temp = temp.substring(0, 2)+":"+0+temp.substring(3, 4);
            }
        }
        System.out.println(temp);
    }
}

import java.io.*;
import java.util.*;
public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String c = br.readLine();
		String t = br.readLine();
		int ch = Integer.parseInt(c.substring(0, 2));
		int cm = Integer.parseInt(c.substring(3));
		int th = Integer.parseInt(t.substring(0, 2));
		int tm = Integer.parseInt(t.substring(3));
		int min = cm-tm;
		if(min<0){
			min = 60+min;
			ch--;
		}
		int h = ch-th;
		if(h<0){
			h=h+24;
		}
		String hr = h+"";
		if(hr.length()==1)
			hr= "0"+hr;
		String minu = min+"";
		if(minu.length()==1)
			minu= "0"+minu;
		System.out.println(hr+":"+minu);
		// end of main
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Arthur Gazizov - Kazan FU #4.3 [2oo7]
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            in.setSpaceChar(':');
            int t = in.nextInt() * 60 + in.nextInt() - in.nextInt() * 60 - in.nextInt();
            while (t < 0) {
                t += 24 * 60;
            }
            int h = (t / 60);
            if (h < 10) {
                out.print(0);
            }
            out.print(h);
            out.print(':');
            h = t % 60;
            if (h < 10) {
                out.print(0);
            }
            out.print(h);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(char i) {
            writer.print(i);
        }

        public void close() {
            writer.close();
        }

        public void print(int i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public void setFilter(InputReader.SpaceCharFilter filter) {
            this.filter = filter;
        }

        public void setSpaceChar(char c) {
            setFilter(ch -> (isWhitespace(ch) || ch == c));
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.*;
import java.io.*;

public class A implements Runnable {

	public void solve() throws IOException {
		String[] s = nextToken().split(":");
                int h1 = Integer.parseInt(s[0]);
                int m1 = Integer.parseInt(s[1]);

                s = nextToken().split(":");
                int h2 = Integer.parseInt(s[0]);
                int m2 = Integer.parseInt(s[1]);

                m1 = m1 - m2;
                if(m1 < 0){
                        m1 += 60;
                        h1--;
                }

                h1 = h1 - h2;
                while(h1 < 0){
                        h1 += 24;
                }

                System.out.printf("%02d:%02d\n", h1, m1);
	}

	//-----------------------------------------------------------
	public static void main(String[] args) {
		new A().run();
	}

        public void print1Int(int[] a){
                for(int i = 0; i < a.length; i++)
                        System.out.print(a[i] + " ");
                System.out.println();
        }

        public void print2Int(int[][] a){
                for(int i = 0; i < a.length; i++){
                        for(int j = 0; j < a[0].length; j++){
                                System.out.print(a[i][j] + " ");
                        }
                        System.out.println();
                }
        }

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

	public String nextToken() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	BufferedReader in;
	StringTokenizer tok;
}

import java.util.Scanner;

public class MAin2 {
public static void main(String[] args) {
    Scanner sc= new Scanner (System.in);
    String h=sc.next();
    String l= sc.next();
    String arr[] =h.split(":");
    int h1=Integer.parseInt(arr[0]);
    int m1=Integer.parseInt(arr[1]);
    String k[] = l.split(":");
    int h2=Integer.parseInt(k[0]);
    int m2=Integer.parseInt(k[1]);
    String  x="";
    int m3 = m1- m2;
    if(m3<0){
        m3+=60;
        h1--;
    }
    if(m3>=10)
        x+=m3;
    else
        x=x+"0"+m3;
    x=":"+x;
    int h3=h1-h2;
    if(h3<0)
        h3+=24;

    if(h3>=10)
    x= ""+h3+x;
    else
    x= "0"+h3+x;
    System.out.println(x);
}
}

import sun.util.calendar.Gregorian;

import java.util.*;
import java.io.*;

public class TaskA {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        String s = in.next();
        String p = in.next();
        int h1 = Integer.parseInt(s.substring(0, 2));
        int m1 = Integer.parseInt(s.substring(3, 5));
        int h2 = Integer.parseInt(p.substring(0, 2));
        int m2 = Integer.parseInt(p.substring(3, 5));
        String ans = "";
        if (h2 > h1) {
            int t = 24 + h1 - h2;
            if (t < 10) {
                ans += 0;
            }
            if (m2 > m1) t--;
            ans += t;

        } else {
            if (h2 == h1) {
                if (m2 <= m1) {
                    ans += "00";
                } else {
                    ans += "23";
                }
            } else {
                int t = (h1 - h2);
                if (m2 > m1) t--;
                if (t < 10) {
                    ans += 0;
                }
                ans += t;
            }
        }
        ans += ":";
        int m = Math.abs(m1 + 60 - m2);
        if (m >= 60) {
            m -= 60;
        }
        if (m < 10) {
            ans += "0";
        }
        ans += m;
        out.print(ans);
        out.close();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class A {

    static void run_stream(InputStream ins) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String[] hm=br.readLine().split(":");

        int h1=Integer.parseInt(hm[0]);
        int m1=Integer.parseInt(hm[1])+h1*60;

        hm=br.readLine().split(":");
        int h2=Integer.parseInt(hm[0]);
        int m2=Integer.parseInt(hm[1])+h2*60;

        int m=m1-m2;
        if(m<0) {
            m+=(60*24);
        }

        int h=m/60;
        m=m%60;

        String sh=Integer.toString(h);
        if(sh.length()<2) {
            sh="0"+sh;
        }

        String sm=Integer.toString(m);
        if(sm.length()<2) {
            sm="0"+sm;
        }

        System.out.println(sh+":"+sm);
    }

    public static void main(String[] args) throws IOException {
        run_stream(System.in);
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author o_panda_o(emailofpanda@yahoo.com)
 */
public class Code_387A_GeorgeAndSleep{
    public static void main(String[] args){
        InputStream inputStream=System.in;
        OutputStream outputStream=System.out;
        InputReader in=new InputReader(inputStream);
        OutputWriter out=new OutputWriter(outputStream);
        _387A_ solver=new _387A_();
        solver.solve(1,in,out);
        out.close();
    }

    static class _387A_{
        public void solve(int testNumber,InputReader in,OutputWriter out){
            String current=in.next(), duration=in.next();
            int cHour=(current.charAt(0)-'0')*10+(current.charAt(1)-'0');
            int cMinute=(current.charAt(3)-'0')*10+(current.charAt(4)-'0');
            int dHour=(duration.charAt(0)-'0')*10+(duration.charAt(1)-'0');
            int dMinutes=(duration.charAt(3)-'0')*10+(duration.charAt(4)-'0');
            if(cMinute<dMinutes){
                cMinute+=60;
                --cHour;
            }
            if(cHour<dHour){
                cHour+=24;
            }
            out.printf("%02d:%02d",(cHour-dHour),(cMinute-dMinutes));
        }

    }

    static class InputReader{
        private InputStream stream;
        private byte[] buf=new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream){
            this.stream=stream;
        }

        public int read(){
            if(numChars==-1){
                throw new InputMismatchException();
            }
            if(curChar>=numChars){
                curChar=0;
                try{
                    numChars=stream.read(buf);
                }catch(IOException e){
                    throw new InputMismatchException();
                }
                if(numChars<=0){
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String nextString(){
            int c=read();
            while(isSpaceChar(c)){
                c=read();
            }
            StringBuilder res=new StringBuilder();
            do{
                if(Character.isValidCodePoint(c)){
                    res.appendCodePoint(c);
                }
                c=read();
            }while(!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c){
            if(filter!=null){
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c){
            return c==' ' || c=='\n' || c=='\r' || c=='\t' || c==-1;
        }

        public String next(){
            return nextString();
        }

        public interface SpaceCharFilter{
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter{
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream){
            writer=new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer){
            this.writer=new PrintWriter(writer);
        }

        public void printf(String format,Object... objects){
            writer.printf(format,objects);
        }

        public void close(){
            writer.close();
        }

    }
}

import java.util.Scanner;

public class problem {

    public static void main(String[] args) {

        Scanner z = new Scanner(System.in);
        String S = z.nextLine();
        String T = z.nextLine();
        int horaS = Integer.parseInt(String.valueOf(S.charAt(0)) + String.valueOf(S.charAt(1)));
        int minS = Integer.parseInt(String.valueOf(S.charAt(3)) + String.valueOf(S.charAt(4)));
        int horaT = Integer.parseInt(String.valueOf(T.charAt(0)) + String.valueOf(T.charAt(1)));
        int minT = Integer.parseInt(String.valueOf(T.charAt(3)) + String.valueOf(T.charAt(4)));
        int contH = 0;
        int contM = 0;

        while (minS != minT) {
            if ((minT + 1) == 60) {
                minT = 0;
                if ((horaT + 1) == 24) {
                    horaT = 0;
                } else {
                    horaT++;
                }
            } else {
                minT++;
            }
            contM++;
        }
        while (horaS != horaT) {
            if ((horaT + 1) == 24) {
                horaT = 0;
            } else {
                horaT++;
            }
            contH++;
        }
        String hora;
        String minuto;
        if (contH<10) {
            hora = "0"+(String.valueOf(contH));
        }else{
            hora = String.valueOf(contH);
        }
        if (contM<10) {
            minuto = "0"+contM;
        }else{
            minuto = String.valueOf(contM);
        }
        System.out.println(hora+":"+minuto);
    }

}

import java.io.*;
import java.math.*;
import java.util.*;
import java.util.regex.*;
import java.util.Map.Entry;

public class Solution {

	public static int parse(String time) {
		String[] parts = time.split(":");
		return Integer.parseInt(parts[0]) * 60 + Integer.parseInt(parts[1]);
	}

	public static String parseBack(int slept) {
		if (slept < 0) {
			slept += 24 * 60;
		}
		String res = "" + slept % 60;
		while (res.length() < 2)
			res = "0" + res;
		res = ":" + res;
		res = slept / 60 + res;
		while (res.length() < 5)
			res = "0" + res;
		return res;
	}

	public static void main(String args[]) throws Exception {

		Scanner scanner = new Scanner(new BufferedInputStream(System.in));

		String woke = scanner.next();
		String duration = scanner.next();

		int wokeUp = parse(woke);
		int time = parse(duration);

		int slept = wokeUp - time;

		System.out.println(parseBack(slept));

		scanner.close();

	}
}

import java.util.*;

public class george {
	public static void main(String args[]) {
		Scanner scan = new Scanner(System.in);
		String x = scan.next();
		String y = scan.next();
		int donehr;
		int donemin;
		int slepthr;
		int sleptmin;
		String anshr="";
		String ansmin="";
		if (x.charAt(0) == '0') {
			donehr = Integer.parseInt(x.substring(1, 2));
		} else {
			donehr = Integer.parseInt(x.substring(0, 2));
		}
		if (x.charAt(3) == '0') {
			donemin = Integer.parseInt(x.substring(4));
		} else {
			donemin = Integer.parseInt(x.substring(3));
		}
		if (y.charAt(0) == '0') {
			slepthr = Integer.parseInt(y.substring(1, 2));
		} else {
			slepthr = Integer.parseInt(y.substring(0, 2));
		}
		if (y.charAt(3) == '0') {
			sleptmin = Integer.parseInt(y.substring(4));
		} else {
			sleptmin = Integer.parseInt(y.substring(3));
		}
		if(sleptmin>donemin){
			slepthr++;
		}
		int fat1 = ((((donehr-slepthr)%24)+24)%24);
		if(Integer.toString(fat1).length()<2){
			anshr = "0"+Integer.toString(fat1);
		}
		else{
			anshr = Integer.toString(fat1);
		}
		int fat2 = ((((donemin-sleptmin)%60)+60)%60);
		if(Integer.toString(fat2).length()<2){
			ansmin = "0"+Integer.toString(fat2);
		}
		else{
			ansmin = Integer.toString(fat2);
		}
		System.out.print(anshr+":"+ansmin);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    public static void main(String str[]) {
        String s = "", t = "";
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try {
            s = br.readLine();
            t = br.readLine();
            int h1=0,m1=0,hh=0,mm=0,h2=0,m2=0;
            h1=Integer.parseInt(s.substring(0,2));
            m1=Integer.parseInt(s.substring(3));
            h2=Integer.parseInt(t.substring(0,2));
            m2=Integer.parseInt(t.substring(3));
            hh=h1-h2;
            mm=m1-m2;

            if(mm<0)
            {   mm=mm+60;
            hh=hh-1;
            }
            if(hh<0)
                hh=hh+24;
            if(hh<10)
                System.out.print("0"+hh+":");
            else
                System.out.print(hh+":");

            if(mm<10)
                System.out.print("0"+mm);
            else
                System.out.print(mm);
            br.close();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Sleep
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
        int size=2; int[] arr = new int[size+2]; int inde=0;
        while(size-->0){
            String[] str = s.readLine().split(":");
            arr[inde++] = Integer.parseInt(str[0]);
            arr[inde++] = Integer.parseInt(str[1]);
        }

        int rhrs = arr[0]-arr[2];
        if(rhrs < 0)
            rhrs = 24+rhrs;

        int rmins = arr[1]-arr[3];
        if(rmins < 0){
            rmins = 60+rmins;
            rhrs--;
        }
        if(rhrs<0)
            rhrs = 24+rhrs;

        if(rhrs < 10)
            System.out.print("0"+rhrs);
        else
            System.out.print(rhrs);

        if(rmins < 10)
            System.out.print(":0"+rmins);
        else
            System.out.print(":"+rmins);
    }
}

import  java.util.Scanner;
public class Main {

   // private static int[] integers = {1,2,3,4,5};
    public static void main(String[] args) {

        String s;
        Scanner in = new Scanner(System.in);
        s = in.nextLine();
        String h = s.substring(0,2);
        String m = s.substring(3,5);

        int curTime = Integer.parseInt(h)*60 + Integer.parseInt(m);
       // System.out.println(curTime);
        s = in.nextLine();
        h = s.substring(0,2);
        m = s.substring(3,5);
        int sleeptime  = Integer.parseInt(h)*60 + Integer.parseInt(m);

        if (curTime < sleeptime)
        {
            curTime +=1440;
        }
        curTime-=sleeptime;
        String hours = String.format("%02d",curTime/60);
        String mins = String.format("%02d", curTime%60);
        System.out.println(hours+":"+mins);
    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		String t = scanner.nextLine();
		String[] s = t.split(":");
		int hour = Integer.parseInt(s[0]);
		int minute = Integer.parseInt(s[1]);
		t = scanner.nextLine();
		s = t.split(":");
		int hours = Integer.parseInt(s[0]);
		int minutes = Integer.parseInt(s[1]);
		int outH,outM;
		String output = "";
		if(minutes>minute){
			minute+=60;
			if(hour>0)
				hour--;
			else
				hour = 23;
		}
		if(hours>hour)
			hour += 24;
		outH = hour - hours;
		outM = minute - minutes;
		if(outH<10)
			output = output + "0";
		output = output + outH+":";
		if(outM<10)
			output = output + "0";
		output = output + outM;
		System.out.println(output);
	}

}

import java.util.Scanner;

/**
 *
 * @author jigsaw
 */
public class GeorgeAndSleep {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner obj = new Scanner(System.in);
        String s1[] = obj.nextLine().split(":");
        int hh = Integer.parseInt(s1[0]);
        int mm = Integer.parseInt(s1[1]);
        s1 = obj.nextLine().split(":");
        int hh1 = Integer.parseInt(s1[0]);
        int mm1 = Integer.parseInt(s1[1]);
        int hh2 = 0,mm2 = 0;
        if(mm1>mm){
            mm += 60;
            hh -= 1;

        }
        if(hh1>hh){
            hh += 24;
        }
        hh2 = hh-hh1;
        mm2 = mm-mm1;
        if(hh2<10&&mm2<10)
            System.out.println("0"+hh2+":0"+mm2);
        else if(hh2<10&&mm2>=10)
            System.out.println("0"+hh2+":"+mm2);
        else if(hh2>=10&&mm2<10)
            System.out.println(hh2+":0"+mm2);
        else
            System.out.println(hh2+":"+mm2);
    }
}

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;

/*
br = new BufferedReader(new FileReader("input.txt"));
pw = new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
 */

public class Main {
  private static BufferedReader br;
  private static StringTokenizer st;
  private static PrintWriter pw;

  public static void main(String[] args) throws IOException {
    br = new BufferedReader(new InputStreamReader(System.in));
    pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    //int qq = 1;
    int qq = Integer.MAX_VALUE;
    //int qq = readInt();
    for(int casenum = 1; casenum <= qq; casenum++)  {
      int end = parse(nextToken());
      int start = parse(nextToken());
      int ret = 0;
      while(start != end) {
        ret++;
        start++;
        start %= 1440;
      }
      pw.printf("%02d:%02d\n", ret/60, ret%60);
    }
    pw.close();
  }

  public static int parse(String str) {
    return 60 * Integer.parseInt(str.substring(0,2)) + Integer.parseInt(str.substring(3));
  }

  private static void exitImmediately() {
    pw.close();
    System.exit(0);
  }

  private static long readLong() throws IOException {
    return Long.parseLong(nextToken());
  }

  private static double readDouble() throws IOException {
    return Double.parseDouble(nextToken());
  }

  private static int readInt() throws IOException {
    return Integer.parseInt(nextToken());
  }

  private static String nextToken() throws IOException  {
    while(st == null || !st.hasMoreTokens())  {
      if(!br.ready()) {
        exitImmediately();
      }
      st = new StringTokenizer(br.readLine().trim());
    }
    return st.nextToken();
  }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Robin Kumar (krobin_93)
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReaderClass in = new InputReaderClass(inputStream);
        OutputWriterClass out = new OutputWriterClass(outputStream);
        GeorgeAndSleep solver = new GeorgeAndSleep();
        solver.solve(1, in, out);
        out.close();
    }
}

class GeorgeAndSleep {
    public void solve(int testNumber, InputReaderClass in, OutputWriterClass out) {
        String[] buff = in.readString().split(":");
        int sHour = Integer.parseInt(buff[0]);
        int sMin = Integer.parseInt(buff[1]);
        buff = in.readString().split(":");
        int tHour = Integer.parseInt(buff[0]);
        int tMin = Integer.parseInt(buff[1]);

        long totalS = sHour * 60 + sMin;
        long totalT = tHour * 60 + tMin;
        long totalP = totalS - totalT;
        totalP %= 1440;
       // System.out.println(totalP);
        if(totalP<0)
            totalP += 1440;
        //System.out.println(totalP);

        long pHour = totalP / 60;
        long pMin = totalP % 60;
        String hour = "", min = "";
        if (pHour <=9)
            hour = "0" + pHour;
        else
            hour = "" + pHour;
        if (pMin  <= 9)
            min = "0" + pMin;
        else
            min = "" + pMin;
       //System.out.println(pHour + " " + pMin);
        out.printLine(hour + ":" + min);

    }
}

class InputReaderClass {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReaderClass(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class OutputWriterClass {
    private final PrintWriter writer;

    public OutputWriterClass(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                outputStream)));
    }

    public OutputWriterClass(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }
}

import java.util.Scanner;
public class aan {

    public static void main(String[] args) {
        Scanner I=new Scanner(System.in);
String s[]=I.nextLine().split(":");
int x=Integer.parseInt(s[0]);
int y=Integer.parseInt(s[1]);
String ss[]=I.nextLine().split(":");
int a=Integer.parseInt(ss[0]);
int b=Integer.parseInt(ss[1]);

int r1=x-a;
int r2=y-b;
if(r1<0)
r1+=24;

if(r2<0)
{
r1=r1-1;
if(r1<0) r1+=24;
r2=r2+60;
}
String str=r1+"";
String str2=r2+"";

switch(r1){
case 0:  str="00";
break;
case 1:  str="01";
break;
case 2:  str="02";
break;
case 3:  str="03";
break;
case 4:  str="04";
break;
case 5:  str="05";
break;
case 6:  str="06";
break;
case 7:  str="07";
break;
case 8:  str="08";
break;
case 9:  str="09";
}
switch(r2){
case 0:  str2="00";
break;
case 1:  str2="01";
break;
case 2:  str2="02";
break;
case 3:  str2="03";
break;
case 4:  str2="04";
break;
case 5:  str2="05";
break;
case 6:  str2="06";
break;
case 7:  str2="07";
break;
case 8:  str2="08";
break;
case 9:  str2="09";
}
System.out.println(str+":"+str2);
    }
}

import java.sql.Date;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s , t;
        s = in.nextLine();
        t = in.next();

        String []temp1 = s.split(":");

        String []temp2 = t.split(":");

        int sHours =Integer.parseInt(temp1[0]);

        int sMins =Integer.parseInt(temp1[1]);

        int tHours =Integer.parseInt(temp2[0]);

        int tMins =Integer.parseInt(temp2[1]);

        int curHours = sHours-tHours;
        if(curHours<0){
            curHours+=24;
        }

        int curMins = sMins-tMins;

        if(curMins<0){
            curMins+=60;
            curHours--;
            if (curHours<0) {
                curHours+=24;
            }
        }
        String h = "";
        h+=curHours;
        if(h.length()==1){
            h= "0"+h;
        }
        String m = "";
        m+=curMins;
        if(m.length()==1){
            m="0"+m;
        }
        System.out.println(h+":"+m);

    }
}

import java.io.*;
import java.util.*;
import java.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Random;
import java.lang.*;

public class zad {
private static BufferedReader in;
private static StringTokenizer tok;
private static PrintWriter out;
final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") !=null;

public static void init() throws FileNotFoundException{
if(ONLINE_JUDGE){
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}
else{
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("out.txt");
}
}

private static String readString() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}

private static int readInt() throws IOException {
return Integer.parseInt(readString());
}
private static double readDouble() throws IOException {
return Double.parseDouble(readString());
}
private static long readLong() throws IOException {
return Long.parseLong(readString());
}
private static float readFloat() throws IOException{
    return Float.parseFloat(readString());
}

public static class Point{

    int x;
    int num;

    Point(int x, int mum){
        this.x = x;
        num = mum;
    }
    public void Incr(){
        num++;
    }

    public int getX(){
        return x;
    }
    public int getNum(){
        return num;
    }

}

public static void Solve() throws IOException{

    String s =readString();
    String t =readString();

    String ch = "";
    if(s.startsWith("0")){
        ch=""+s.charAt(1);
    }
    else
    ch=""+s.charAt(0)+s.charAt(1);

    int chas = Integer.parseInt(ch);

    if(s.charAt(3)=='0'){
        ch=""+s.charAt(4);
    }
    else
    ch=""+s.charAt(3)+s.charAt(4);
    int min  = Integer.parseInt(ch);

    if(t.startsWith("0")){
        ch=""+t.charAt(1);
    }
    else
    ch=""+t.charAt(0)+t.charAt(1);

    int tchas = Integer.parseInt(ch);

    if(t.charAt(3)=='0'){
        ch=""+t.charAt(4);
    }
    else
    ch=""+t.charAt(3)+t.charAt(4);
    int tmin  = Integer.parseInt(ch);

    min-=tmin;
    if(min<0){
        min=60+min;
        chas--;
    }
    chas-=tchas;
    if(chas<0){
        chas=24+chas;
    }

    ch=""+chas;
    if(ch.length()==1){
        out.print('0');
    }
    out.print(ch);
    out.print(':');
    ch=""+min;
    if(ch.length()==1){
        out.print(0);
    }
    out.print(min);

}

public static void main(String[] args) throws IOException {
init();
Solve();

in.close();
out.close();
}
}

/* package whatever; // don't place pack4age name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import javax.sound.midi.SysexMessage;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {
        // your code goes here
Scanner sc = new Scanner(System.in);
String s,t,nh = "",nm = "";int l,a,b,c,d,k1,k2;
s = sc.next();t=sc.next();
 a =  Integer.parseInt(s.substring(0,2));
 b =  Integer.parseInt(s.substring(3));
 c =  Integer.parseInt(t.substring(0,2));
 d =  Integer.parseInt(t.substring(3));
int ph = a-c;int pm = b-d;
 // System.out.println(b);
   // System.out.println(d);
if(pm<0){pm = pm + 60;
        ph = ph-1;
                }
if(ph<0){ph = ph + 24;}

//System.out.println(ph);
if(ph >10 && pm >10){
    System.out.println(ph+":"+pm);
}
else{
if(ph<10){
          nh = Integer.toString(ph);
          nh = "0"+ph;
          }
else{nh = Integer.toString(ph);}
if(pm<10){
          nm = Integer.toString(pm);
          nm = "0"+pm;
          }
else{nm = Integer.toString(pm);}
  System.out.println(nh+":"+nm);
}   }
}

import java.util.Scanner;
public class GeorgeSleep {

	public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String[] start = s.next().split(":");
        String[] duration = s.next().split(":");
        s.close();
        int startH = Integer.parseInt(start[0]);
        int startM = Integer.parseInt(start[1]);
        int durationH = Integer.parseInt(duration[0]);
        int durationM = Integer.parseInt(duration[1]);

        int finalM = startM-durationM;
        int c=0;
        if(finalM<0){
            finalM+=60;
            c=1;
        }
        int finalH = startH-durationH-c;
        if(finalH<0) finalH+=24;
        System.out.printf("%02d:%02d",finalH,finalM);
	}

}

import java.util.*;
import java.io.*;

public class A227 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        String line1 = sc.nextLine();
        String line2 = sc.nextLine();
        sc.close();

        String[] current = line1.split(":");
        int sh = Integer.parseInt(current[0]);
        int sm = Integer.parseInt(current[1]);
        String[] t = line2.split(":");
        int th = Integer.parseInt(t[0]);
        int tm = Integer.parseInt(t[1]);

        int bm = sm-tm;
        int carry = 0;
        if(bm<0){
            bm += 60;
            carry = 1;
        }

        int bh = sh-th-carry;
        if(bh<0){
            bh += 24;
        }

        String s1 = String.valueOf(bh);
        if(bh<10){
            s1 = "0"+s1;
        }
        String s2 = String.valueOf(bm);
        if(bm<10){
            s2 = "0"+s2;
        }

        System.out.println(s1+":"+s2);
    }
}

import java.util.Scanner;

public class A {

    public static void main(String[] args) {
        Scanner jin = new Scanner(System.in);
        String s = jin.nextLine(), t = jin.nextLine();
        String tmp[] = s.split(":");
        int hs = Integer.parseInt(tmp[0]), ms = Integer.parseInt(tmp[1]);
        tmp = t.split(":");
        int ht = Integer.parseInt(tmp[0]), mt = Integer.parseInt(tmp[1]);
        int tts = hs * 60 + ms, ttt = ht * 60 + mt;
        if(tts < ttt) tts += 24 * 60;
        int r = tts - ttt;
        System.out.printf("%02d:%02d", r / 60, r % 60);

        jin.close();
    }

}

import java.util.Scanner;

public class A {
	static Scanner sc=new Scanner(System.in);
	public static void main(String[] args) {
		String s=sc.next(),f=sc.next();
		int ss=Integer.parseInt(s.substring(0,2))*60+Integer.parseInt(s.substring(3,5));
		int ff=Integer.parseInt(f.substring(0,2))*60+Integer.parseInt(f.substring(3,5));
		int res=ss-ff;		if (res<0) res=24*60+res; int h=res/60;
		int m=res%60;
		s=("0"+h);		f=("0"+m);
		String r=s.substring(s.length()-2,s.length())+":"+f.substring(f.length()-2,f.length());

		System.out.println(r);

	}

}

import java.io.*;
import java.math.*;
import java.util.*;
import java.lang.*;

public class Main{

    public static InputStream inputStream = System.in;
    public static OutputStream outputStream = System.out;
    public static FastReader in = new FastReader(inputStream);
    public static PrintWriter out = new PrintWriter(outputStream);

    int n;
    int m;
    int t;

    public static void main(String[] args)throws java.lang.Exception{
        new Main().run();
        out.close();
    }

    void run()throws java.lang.Exception{
        String wake = in.next();
        StringTokenizer tk = new StringTokenizer(wake , ":");
        int hr = Integer.parseInt(tk.nextToken());
        int min = Integer.parseInt(tk.nextToken());
        tk = new StringTokenizer(in.next() , ":");
        int slhr = Integer.parseInt(tk.nextToken());
        int slmin = Integer.parseInt(tk.nextToken());
        int m = min-slmin;
        int h = hr;
        if(m<0){
            m = 60+m;
            h--;
        }
        h -= slhr;
        if(h<0){
            h = 24+h;
        }
        String ss = h+"";
        if(ss.length()==1){
            ss = "0" + ss;
        }
        String tt = m + "";
        if(tt.length()==1){
            tt = "0" + tt;
        }
        System.out.println(ss + ":" + tt);
    }
}

class Obj implements Comparable<Obj>{
    int lo;
    int hi;
    int c;

    public Obj(int a, int b, int c){
        lo = a;
        hi = b;
        this.c = c;
    }

    public int compareTo(Obj that){
        return Integer.valueOf(c).compareTo(that.c);
    }
}

class ArrayUtils{
    public static void printGraph(ArrayList<Integer>[] graph){
        System.out.println("GRAPH : ");
        int N = graph.length;
        for(int i=0; i<N; i++){
            System.out.print(i + " -> ");
            for(Integer x : graph[i]){
                System.out.print(x + ", ");
            }
            System.out.println    ();
        }
    }

    public static void initGraph(ArrayList<Integer>[] graph){
        for(int i=0; i<graph.length; i++){
            graph[i] = new ArrayList<Integer>();
        }
    }

    public static void fill2d(long[][] arr){
        for(int i=0; i<arr.length; i++){
            Arrays.fill(arr[i], -1L);
        }
    }

    public static void fill2d(int[][] arr){
        for(int i=0; i<arr.length; i++){
            Arrays.fill(arr[i], -1);
        }
    }

    public static void input2d(int[][] arr, FastReader in){
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[0].length; j++){
                arr[i][j] = in.nextInt();
            }
        }
    }

    public static void input1d(int[] arr, FastReader in){
        for(int i=0; i<arr.length; i++){
            arr[i] = in.nextInt();
        }
    }

    public static void printGrid(char[][] arr){
        System.out.println("Character grid : ");
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
        System.out.println("--------------------------------------");
    }
}

class FastReader{
    private boolean finished = false;

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastReader(InputStream stream){
        this.stream = stream;
    }

    public int read(){
        if (numChars == -1){
            throw new InputMismatchException ();
        }
        if (curChar >= numChars){
            curChar = 0;
            try{
                numChars = stream.read (buf);
            } catch (IOException e){
                throw new InputMismatchException ();
            }
            if (numChars <= 0){
                return -1;
            }
        }
        return buf[curChar++];
    }

    public int peek(){
        if (numChars == -1){
            return -1;
        }
        if (curChar >= numChars){
            curChar = 0;
            try{
                numChars = stream.read (buf);
            } catch (IOException e){
                return -1;
            }
            if (numChars <= 0){
                return -1;
            }
        }
        return buf[curChar];
    }

    public int nextInt(){
        int c = read ();
        while (isSpaceChar (c))
            c = read ();
        int sgn = 1;
        if (c == '-'){
            sgn = -1;
            c = read ();
        }
        int res = 0;
        do{
            if(c==','){
                c = read();
            }
            if (c < '0' || c > '9'){
                throw new InputMismatchException ();
            }
            res *= 10;
            res += c - '0';
            c = read ();
        } while (!isSpaceChar (c));
        return res * sgn;
    }

    public long nextLong(){
        int c = read ();
        while (isSpaceChar (c))
            c = read ();
        int sgn = 1;
        if (c == '-'){
            sgn = -1;
            c = read ();
        }
        long res = 0;
        do{
            if (c < '0' || c > '9'){
                throw new InputMismatchException ();
            }
            res *= 10;
            res += c - '0';
            c = read ();
        } while (!isSpaceChar (c));
        return res * sgn;
    }

    public String nextString(){
        int c = read ();
        while (isSpaceChar (c))
            c = read ();
        StringBuilder res = new StringBuilder ();
        do{
            res.appendCodePoint (c);
            c = read ();
        } while (!isSpaceChar (c));
        return res.toString ();
    }

    public boolean isSpaceChar(int c){
        if (filter != null){
            return filter.isSpaceChar (c);
        }
        return isWhitespace (c);
    }

    public static boolean isWhitespace(int c){
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private String readLine0(){
        StringBuilder buf = new StringBuilder ();
        int c = read ();
        while (c != '\n' && c != -1){
            if (c != '\r'){
                buf.appendCodePoint (c);
            }
            c = read ();
        }
        return buf.toString ();
    }

    public String nextLine(){
        String s = readLine0 ();
        while (s.trim ().length () == 0)
            s = readLine0 ();
        return s;
    }

    public String nextLine(boolean ignoreEmptyLines){
        if (ignoreEmptyLines){
            return nextLine ();
        }else{
            return readLine0 ();
        }
    }

    public BigInteger nextBigInteger(){
        try{
            return new BigInteger (nextString ());
        } catch (NumberFormatException e){
            throw new InputMismatchException ();
        }
    }

    public char nextCharacter(){
        int c = read ();
        while (isSpaceChar (c))
            c = read ();
        return (char) c;
    }

    public double nextDouble(){
        int c = read ();
        while (isSpaceChar (c))
            c = read ();
        int sgn = 1;
        if (c == '-'){
            sgn = -1;
            c = read ();
        }
        double res = 0;
        while (!isSpaceChar (c) && c != '.'){
            if (c == 'e' || c == 'E'){
                return res * Math.pow (10, nextInt ());
            }
            if (c < '0' || c > '9'){
                throw new InputMismatchException ();
            }
            res *= 10;
            res += c - '0';
            c = read ();
        }
        if (c == '.'){
            c = read ();
            double m = 1;
            while (!isSpaceChar (c)){
                if (c == 'e' || c == 'E'){
                    return res * Math.pow (10, nextInt ());
                }
                if (c < '0' || c > '9'){
                    throw new InputMismatchException ();
                }
                m /= 10;
                res += (c - '0') * m;
                c = read ();
            }
        }
        return res * sgn;
    }

    public boolean isExhausted(){
        int value;
        while (isSpaceChar (value = peek ()) && value != -1)
            read ();
        return value == -1;
    }

    public String next(){
        return nextString ();
    }

    public SpaceCharFilter getFilter(){
        return filter;
    }

    public void setFilter(SpaceCharFilter filter){
        this.filter = filter;
    }

    public interface SpaceCharFilter{
        public boolean isSpaceChar(int ch);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.StringTokenizer;

/*07:05:45PM

 String x =sc.next();
 char inp [] = x.toCharArray();
 SimpleDateFormat displayFormat = new SimpleDateFormat("HH:mm");
 SimpleDateFormat parseFormat = new SimpleDateFormat("hh:mm a");
 Date date = parseFormat.parse(x.substring(0, 5)+" "+x.substring(8, 10));
 System.out.println(displayFormat.format(date)+":"+x.substring(6, 8));
 */

public class Main {

	public static void main(String[] args) throws Exception
	{
		Scanner sc= new Scanner(System.in);
		String current [] = sc.nextLine().split(":");
		String duration [] = sc.nextLine().split(":");

		int currentH = Integer.parseInt(current[0]) , currentM =Integer.parseInt(current[1]);
		int durationH = Integer.parseInt(duration[0]) , durationM=Integer.parseInt(duration[1]);

		int hours = currentH-durationH;
		int minutes = currentM-durationM;

		if(minutes<0){minutes = 60+minutes;hours--;}
		if(hours<0)hours = 24+hours;

		if(hours<10)System.out.print("0"+hours);
		else System.out.print(hours);

		System.out.print(":");

		if(minutes<10)System.out.print("0"+minutes);
		else System.out.print(minutes);

	}
}

class Pair {
	public int x, y;

	Pair(int a, int b) {
		x = a;
		y = b;
	}
}
class Triple implements Comparable<Triple>{
	public int x, y,z;

	Triple(int a, int b, int c) {
		x = a;
		y = b;
		z=c;
	}

	@Override
	public int compareTo(Triple o) {
		// TODO Auto-generated method stub
		return (o.x==x && o.y ==y && o.z==z)?0:-1;
	}

}

class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s) {
		br = new BufferedReader(new InputStreamReader(s));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	public double nextDouble() throws IOException {
		String x = next();
		StringBuilder sb = new StringBuilder("0");
		double res = 0, f = 1;
		boolean dec = false, neg = false;
		int start = 0;
		if (x.charAt(0) == '-') {
			neg = true;
			start++;
		}
		for (int i = start; i < x.length(); i++)
			if (x.charAt(i) == '.') {
				res = Long.parseLong(sb.toString());
				sb = new StringBuilder("0");
				dec = true;
			} else {
				sb.append(x.charAt(i));
				if (dec)
					f *= 10;
			}
		res += Long.parseLong(sb.toString()) / f;
		return res * (neg ? -1 : 1);
	}

	public boolean ready() throws IOException {
		return br.ready();
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.StringTokenizer;

/*07:05:45PM

 String x =sc.next();
 char inp [] = x.toCharArray();
 SimpleDateFormat displayFormat = new SimpleDateFormat("HH:mm");
 SimpleDateFormat parseFormat = new SimpleDateFormat("hh:mm a");
 Date date = parseFormat.parse(x.substring(0, 5)+" "+x.substring(8, 10));
 System.out.println(displayFormat.format(date)+":"+x.substring(6, 8));
 */

public class Main {

	public static void main(String[] args) throws Exception
	{
		Scanner sc= new Scanner(System.in);
		String current [] = sc.nextLine().split(":");
		String duration [] = sc.nextLine().split(":");

		int currentH = Integer.parseInt(current[0]) , currentM =Integer.parseInt(current[1]);
		int durationH = Integer.parseInt(duration[0]) , durationM=Integer.parseInt(duration[1]);

		int hours = currentH-durationH;
		if(hours<0)hours = 24+hours;

		int minutes = currentM-durationM;
		if(minutes<0){minutes = 60+minutes;hours--;}

		if(hours<0)hours = 24+hours;

		if(hours<10)System.out.print("0"+hours);
		else System.out.print(hours);

		System.out.print(":");

		if(minutes<10)System.out.print("0"+minutes);
		else System.out.print(minutes);

	}
}

class Pair {
	public int x, y;

	Pair(int a, int b) {
		x = a;
		y = b;
	}
}
class Triple implements Comparable<Triple>{
	public int x, y,z;

	Triple(int a, int b, int c) {
		x = a;
		y = b;
		z=c;
	}

	@Override
	public int compareTo(Triple o) {
		// TODO Auto-generated method stub
		return (o.x==x && o.y ==y && o.z==z)?0:-1;
	}

}

class Scanner {
	StringTokenizer st;
	BufferedReader br;

	public Scanner(InputStream s) {
		br = new BufferedReader(new InputStreamReader(s));
	}

	public String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(next());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(next());
	}

	public String nextLine() throws IOException {
		return br.readLine();
	}

	public double nextDouble() throws IOException {
		String x = next();
		StringBuilder sb = new StringBuilder("0");
		double res = 0, f = 1;
		boolean dec = false, neg = false;
		int start = 0;
		if (x.charAt(0) == '-') {
			neg = true;
			start++;
		}
		for (int i = start; i < x.length(); i++)
			if (x.charAt(i) == '.') {
				res = Long.parseLong(sb.toString());
				sb = new StringBuilder("0");
				dec = true;
			} else {
				sb.append(x.charAt(i));
				if (dec)
					f *= 10;
			}
		res += Long.parseLong(sb.toString()) / f;
		return res * (neg ? -1 : 1);
	}

	public boolean ready() throws IOException {
		return br.ready();
	}

}

import java.util.*;
/**
 *
 * @author TOP
 */
public class Itipractice {
     static public void main(String[] args) {
         Scanner read = new Scanner(System.in);
         String current = read.next(), old = read.next();
         int cH = Integer.parseInt(current.substring(0, 2)) + 24,
             cM = Integer.parseInt(current.substring(3, 5)),
             oH = Integer.parseInt(old.substring(0, 2)),
             oM = Integer.parseInt(old.substring(3, 5));
         if(cM < oM){
             cM += 60;
             --cH;
         }
         int resultM = cM - oM, resultH = (cH - oH)%24;
         System.out.print((resultH<10?"0":"")+resultH + ":");
         System.out.print((resultM<10?"0":"")+resultM);

     }
}

import java.util.Scanner;

public class Main {
    public static void main (String [] args ){
        Scanner usrInput = new Scanner(System.in );
        String s , t , temp="" , temp2;
        int diff1 , diff2 ;
        s = usrInput.nextLine();
        t = usrInput.nextLine();

        diff1= Integer.parseInt(s.substring(0, 2)) - Integer.parseInt(t.substring(0, 2))  ;
        diff2= Integer.parseInt(s.substring(3 , 5)) - Integer.parseInt(t.substring(3, 5)) ;

        if (diff2 < 0 ){
            diff2+=60;
            diff1--;
        }

        if (diff1 < 0 ){
            diff1+=24 ;
        }

        temp+= diff1+":"+diff2;

        if (temp.length() == 3 ){
            temp=0+temp;
            temp = temp.substring(0, 2)+":"+0+temp.substring(3, 4);
        }else if (temp.length() == 4){
            int index = temp.indexOf(":");
            if (index % 2 != 0 ){
                temp=0+temp;
            }else {
                temp = temp.substring(0, 2)+":"+0+temp.substring(3, 4);
            }
        }
        System.out.println(temp);
    }
}

import java.util.*;
public class GeorgeandSleep_CF {
    public static void main(String[] args) {
        Scanner in = new Scanner (System.in);
        String e = in.next();
        String[] e1 = e.split(":");
        int eh = Integer.valueOf(e1[0]);
        int em = Integer.valueOf(e1[1]);
        String s = in.next();
        String[] s1 = s.split(":");
        int sh = Integer.valueOf(s1[0]);
        int sm = Integer.valueOf(s1[1]);
        int h = eh - sh;
        int m = em - sm;
        if (m < 0){
            m += 60;
            h--;
        }
        if (h < 0)
            h += 24;
        if(h < 10)
            System.out.printf("0%d:", h);
        else
            System.out.print(h + ":");
        if(m < 10)
            System.out.printf("0%d%n", m);
        else
            System.out.println(m);
    }
}

import java.util.Scanner;

public class GeorgeandSleep
{
	public static void main(String[] args)
	{
		Scanner input = new Scanner(System.in);
		String s = input.nextLine();
		String t = input.nextLine();
		String[] shhmm = s.split(":");
		String[] thhmm = t.split(":");
		int pre = 0;
		int cur = 0;
		pre = Integer.parseInt(thhmm[1]);
		cur = Integer.parseInt(shhmm[1]);
		int mm = 0;
		boolean flag = false;
		if (cur >= pre)
		{
			mm = cur - pre;
		}
		else
		{
			flag = true;
			mm = cur - pre + 60;
		}
		pre = Integer.parseInt(thhmm[0]);
		cur = Integer.parseInt(shhmm[0]);
		int hh = 0;
		if (flag && cur - 1 >= pre)
		{
			hh = cur - 1 - pre;
		}
		else if (!flag && cur >= pre)
		{
			hh = cur - pre;
		}
		else if (flag)
		{
			hh = cur - pre + 23;
		}
		else
		{
			hh = cur - pre + 24;
		}
		if (hh < 10)
		{
			System.out.print("0" + hh + ":");
		}
		else
		{
			System.out.print(hh + ":");
		}
		if (mm < 10)
		{
			System.out.print("0" + mm);
		}
		else
		{
			System.out.print(mm);
		}
		System.out.println();
	}
}

import java.io.*;
public class GeorgeAndSleep {

    public static void f(String [] s,String []t){
        int min=0;
        int hrs=0;
        int min1 = Integer.parseInt(s[1]);
        int hours1 = Integer.parseInt(s[0]);

        int min2 = Integer.parseInt(t[1]);
        int hours2 = Integer.parseInt(t[0]);

        min = min1-min2;
        if(min <0){
            min = 60-(min2-min1);
            hrs--;
        }if(min==60){
            min=0;
            hrs++;
        }
        hrs += (hours1-hours2);
        if(hrs<0)
            hrs+=24;
        String x = min+"";
        if(min<10)
            x = '0'+x;
        String z = hrs+"";
        if(hrs<10)
            z = '0' +z;
        System.out.println(z+":"+x);
    }
    public static void main(String[]args)throws IOException{
        BufferedReader br = new BufferedReader (new InputStreamReader (System.in));
        String []s = br.readLine().split(":");

        String []t = br.readLine().split(":");
        f(s,t);
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

     Scanner in=new Scanner(System.in);

     while(in.hasNext())
     {
        String s=in.next();

        String x=in.next();

        String[]p=s.split(":");
        String[]e=x.split(":");

        int h=Integer.parseInt(p[0]);
        int m=Integer.parseInt(p[1]);

        int h1=Integer.parseInt(e[0]);
        int m1=Integer.parseInt(e[1]);

        int h2=1;
        int m2=1;

        while(m2<=m1)
        {
            m--;
            m2++;
            if(m<0)
            {
                h--;
                m=59;
            }

            if(h<0)
                h=23;
        }

        while(h2<=h1)
        {
           h--;
           h2++;

           if(h<0)
               h=23;

        }

        String t1=String.valueOf(h);
        String t2=String.valueOf(m);

        if(t1.length()==1)
            t1="0"+t1;

        if(t2.length()==1)
            t2="0"+t2;

         System.out.println(t1+":"+t2);

     }
    }

}

import java.util.Scanner;

public class tim {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
	String s1=sc.nextLine(),s=sc.nextLine();
	int m1,h1,m2,h2;
	h1=(s.charAt(0)-48)*10+s.charAt(1)-48;
	m1=(s.charAt(3)-48)*10+s.charAt(4)-48;
	h2=(s1.charAt(0)-48)*10+s1.charAt(1)-48;
	m2=(s1.charAt(3)-48)*10+s1.charAt(4)-48;
	int h=0,m=0;
	m=m2-m1;
	if(m<0)
	{
		m=60+m;
		h=-1;
	}
	h=h+(h2-h1);
	if(h<0)
	{
		h=24+h;
	}
	String gh="";
	if(h<10)
		gh=gh+"0"+h;
	else
		gh=gh+h;
	gh=gh+":";
	if(m<10)
	{
		gh=gh+"0"+m;
	}
	else
	{
		gh=gh+m;
	}
	System.out.println(gh);
	}
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Sleep {

    public static void main(String[] args) {
        Kattio io = new Kattio(System.in,System.out);
        String s=io.getWord();
        String t=io.getWord();
        String[]parts=s.split(":");
        String[]parts2=t.split(":");
        int wh=Integer.parseInt(parts[0]);
        int wm=Integer.parseInt(parts[1]);
        int th=Integer.parseInt(parts2[0]);
        int tm=Integer.parseInt(parts2[1]);

        int start=wh*60+wm;
        int tt=th*60+tm;
        int dur=1440-tt;
        int T=(start+dur)%(1440);
        String ANS1=String.valueOf(T/60);
        String ANS2=String.valueOf(T%60);
        if(ANS1.length()==1)ANS1="0"+ANS1;
        if(ANS2.length()==1)ANS2="0"+ANS2;

        io.print(ANS1+":"+ANS2);

        io.close();
    }
static class Kattio extends PrintWriter {

    public Kattio(InputStream i) {
    super(new BufferedOutputStream(System.out));
    r = new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(InputStream i, OutputStream o) {
    super(new BufferedOutputStream(o));
    r = new BufferedReader(new InputStreamReader(i));
    }

    public boolean hasMoreTokens() {
    return peekToken() != null;
    }

    public int getInt() {
    return Integer.parseInt(nextToken());
    }

    public double getDouble() {
    return Double.parseDouble(nextToken());
    }

    public long getLong() {
    return Long.parseLong(nextToken());
    }

    public String getWord() {
    return nextToken();
    }

    private BufferedReader r;
    private String line;
    private StringTokenizer st;
    private String token;

    private String peekToken() {
    if (token == null)
        try {
        while (st == null || !st.hasMoreTokens()) {
            line = r.readLine();
            if (line == null) return null;
            st = new StringTokenizer(line);
        }
        token = st.nextToken();
        } catch (IOException e) { }
    return token;
    }

    private String nextToken() {
    String ans = peekToken();
    token = null;
    return ans;
    }
}
}

import java.util.*;

public class a387 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        String s1 = in.next().replace(":", "");
        String s2 = in.next().replace(":", "");
        int h1, m1, h2, m2, hh, mm;String con = "";

            con=s1.substring(0, 2); h1=Integer.valueOf(con);
            con=s1.substring(2, 4); m1=Integer.valueOf(con);
            con=s2.substring(0, 2); h2=Integer.valueOf(con);
            con=s2.substring(2, 4); m2=Integer.valueOf(con);

            hh = h1-h2; mm = m1-m2;
            if(mm<0){
                mm+=60;hh--;}
            if(hh<0){
                hh+=24;}

            con = String.valueOf(hh);
            if(con.length()!=2)
                System.out.print("0"+con+":");
            else
                System.out.print(con+":");

            con = String.valueOf(mm);
            if(con.length()!=2)
                System.out.println("0"+con);
            else
                System.out.println(con);

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh,int mm,int hh2 ,int mm2){
        int hhout,mmout;

        if(hh<hh2&&mm<mm2){
            hhout=23-(hh2-hh);

        }
        else
        if(hh<hh2)hhout=24-(hh2-hh);
        else
        if(hh==hh2&&mm<mm2)hhout=23;
        else
        if(hh>hh2&&mm<mm2){
            hh2=hh2+1;
            hhout=hh-hh2;
        }
        else
            hhout=hh-hh2;

        if(mm<mm2){
            mmout=(60-mm2)+mm;

        }
        else
            mmout=mm-mm2;

        String outmin=mmout+"";
        if(outmin.length()==1)outmin="0"+outmin;
        String outhours=hhout+"";
        if(outhours.length()==1)outhours="0"+outhours;

        return outhours+":"+outmin;

    }

  public static void main(String[] args) throws IOException {
  BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
  String[] test= bf.readLine().split(":");

  int hh = Integer.parseInt(test[0]);
  int mm = Integer.parseInt(test[1]);

  String[] test2= bf.readLine().split(":");

  int hh2 = Integer.parseInt(test2[0]);
  int mm2 = Integer.parseInt(test2[1]);

  //Test Using the values from the buffer zeft:
  System.out.println(Sleep(hh,mm,hh2,mm2));

 }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;

/**
 * Created by bigo__1 on 19/3/17.
 */
public class cod1 {

    public static void main(String[] args) throws IOException {

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String []cur=br.readLine().split(":");
        String []dur=br.readLine().split(":");
        int curm=Integer.parseInt(cur[0])*60+Integer.parseInt(cur[1]);
        int durm=Integer.parseInt(dur[0])*60+Integer.parseInt(dur[1]);
        int dif=curm-durm;
        if(dif<0)
        {
            dif=24*60+dif;

        }
        int hh=dif/60;
        int mm=dif%60;
        String hhs=Integer.toString(hh);
        String mms=Integer.toString(mm);
        if(hhs.length()<2)
        {
            hhs="0"+hhs;
        }
        if(mms.length()<2)
        {
            mms="0"+mms;
        }
        System.out.println(hhs+":"+mms);

        //System.out.println(curh+" "+curm);

    }

}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.InputMismatchException;

public class predict {

    public static void main(String args[]){
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);

        String s1=in.next();
        String s2=in.next();

        int h1,h2;
        int m1,m2;

        h1=Integer.valueOf(s1.charAt(0))*10+Integer.valueOf(s1.charAt(1));
        h2=Integer.valueOf(s2.charAt(0))*10+Integer.valueOf(s2.charAt(1));

        m1=Integer.valueOf(s1.charAt(3))*10+Integer.valueOf(s1.charAt(4));
        m2=Integer.valueOf(s2.charAt(3))*10+Integer.valueOf(s2.charAt(4));

        int res1,res2;

        res1=m1-m2;
        if(res1<0){
            res1=res1+60;
            h1--;
        }

        res2=h1-h2;
        if(res2<0){
            res2+=24;
        }

        if(res1<10&&res2<10){
        out.printLine("0"+res2+":0"+res1);
        }
        else if(res1<10){
            out.printLine(res2+":0"+res1);
        }
        else if(res2<10){
            out.printLine("0"+res2+":"+res1);

        }

        else
            out.printLine(res2+":"+res1);
        out.close();

        }

}
class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
            this.stream = stream;
    }

    public int read(){
            if (numChars == -1)
            throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
    }
    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }
    public long readLong() {
        int c = read();
        while(isSpaceChar(c))
            c = read();
    int sgn = 1;
    if (c == '-') {
        sgn = -1;
        c = read();
    }
    long res = 0;
    do {
        if (c < '0' || c > '9')
            throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
    } while (!isSpaceChar(c));
    return res * sgn;
    }
    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuffer res = new StringBuffer();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }
    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }
    public String next() {
        return readString();
    }
    }

class OutputWriter {
    private final PrintWriter writer;
    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(outputStream);
    }
    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }
    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }
    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }
    public void close() {
    writer.close();
    }
    }

import java.util.Scanner;

public class Main
{

    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);
        String reveil = scan.next();
        String temps = scan.next();

        int time = Integer.parseInt(reveil.substring(0, 2))*60+Integer.parseInt(reveil.substring(3, 5))-Integer.parseInt(temps.substring(0, 2))*60-Integer.parseInt(temps.substring(3, 5));
        if(time < 0)
            time += 24*60;
        if(time >= 24*60)
            time -= 24*60;

        int h = time/60;
        int m = time%60;
        if(h < 10)
            System.out.print("0"+h);
        else
            System.out.print(h);
        if(m < 10)
            System.out.print(":0"+m);
        else
            System.out.print(":"+m);
    }

}

import java.io.*;
import java.util.*;

public class Solution{

 public static void main(String[] args) {

     Scanner in = new Scanner(System.in);

     int h,m;
     String s,t;

     s=in.next();
     t=in.next();

     h=((int)(s.charAt(0)-'0')*10+(int)(s.charAt(1)-'0'))-((int)(t.charAt(0)-'0')*10+(int)(t.charAt(1)-'0'));
     m=((int)(s.charAt(3)-'0')*10+(int)(s.charAt(4)-'0'))-((int)(t.charAt(3)-'0')*10+(int)(t.charAt(4)-'0'));

     if(m<0){
    	 m+=60;
    	 h--;
     }
     if(h<0){
    	 h+=24;
     }

     System.out.print((h/10));
     System.out.print((h%10));
     System.out.print(":");
     System.out.print((m/10));
     System.out.print((m%10));
 }
}

import java.util.Scanner;

/**
 * Created by peter.bykov on 19.05.2014.
 */
public class Archive387A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String[] now = s.nextLine().split(":");
        String[] sleepTime = s.nextLine().split(":");
        int hours = Integer.parseInt(now[0]) - Integer.parseInt(sleepTime[0]);
        if(hours < 0) {
            hours = 24 + hours;
        }
        int minutes = Integer.parseInt(now[1]) - Integer.parseInt(sleepTime[1]);
        if(minutes < 0) {
            if(hours > 0) {
                --hours;
            } else {
                hours = 23;
            }
            minutes = 60 + minutes;
        }
        System.out.println(((hours>=10)?hours:"0"+hours) + ":" + ((minutes>=10)?minutes:"0"+minutes));

    }
}

import java.util.Scanner;

public class P_387A {
	public static void main(String[] args) {
		String s, t, p = "";
		int h, m, smin, tmin, pmin;
		Scanner in = new Scanner(System.in);

		s = in.nextLine();
		t = in.nextLine();
		h = Integer.parseInt(s.substring(0, 2));
		m = Integer.parseInt(s.substring(3));

		smin = h * 60 + m;
		h = Integer.parseInt(t.substring(0, 2));
		m = Integer.parseInt(t.substring(3));
		tmin = h * 60 + m;

		if(smin < tmin)
			smin += 24 * 60;
		pmin = smin - tmin;
		h = pmin / 60;
		m = pmin % 60;

		if(h < 10)
			p += "0";
		p += Integer.toString(h) + ":";
		if(m < 10)
			p += "0";
		p += Integer.toString(m);

		System.out.println(p);
	}
}

/**
 * @(#)GeorgeAndSleep.java
 *
 *
 * @Adarsh
 * @version 1.00 2014/1/30
 */

import java.io.*;
public class GeorgeAndSleep {

    public static void main(String []args) throws IOException
    {
    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	StringBuffer s = new StringBuffer(br.readLine());
    	int wakeHH = Integer.parseInt(s.substring(0,2));
    	int wakeMM = Integer.parseInt(s.substring(3,5));
    //	System.out.println (wakeHH +"	"+ wakeMM);
    	StringBuffer s1 = new StringBuffer(br.readLine());
    	int timeHH = Integer.parseInt(s1.substring(0,2));
    	int timeMM = Integer.parseInt(s1.substring(3,5));
    //	System.out.println (timeHH +"	"+ timeMM);

    	StringBuffer sleepHH = new StringBuffer();
    	StringBuffer sleepMM = new StringBuffer();

    	int mm = (wakeMM - timeMM);
    	if(mm<0) {mm+=60;wakeHH-=1;}
    	if(mm<=9){ sleepMM.append('0');}
    	sleepMM.append(mm);

    	int hh = (wakeHH-timeHH);
    	if(hh<0){ hh+=24;}
    	if(hh<=9){ sleepHH.append('0');}
    	sleepHH.append(hh);
    	System.out.println (sleepHH +":"+sleepMM);
    }

}

import java.util.*;

public class Sleep
{
    public static void main(String[] args)
    {
        // Set up scanner
        Scanner sc = new Scanner(System.in);
        // System.out.println("Enter first time");
        String s = sc.next();
        // System.out.println("Enter second time");
        String t = sc.next();

        int shours = Integer.valueOf(s.substring(0,2));
        int thours = Integer.valueOf(t.substring(0,2));

        int smins = Integer.valueOf(s.substring(3));
        int tmins = Integer.valueOf(t.substring(3));

        int answerhours = shours - thours;
        if (answerhours < 0)
            answerhours += 24;

        int answermins = smins - tmins;
        if (answermins < 0)
        {
            answermins += 60;
            answerhours--;
            if (answerhours < 0)
                answerhours = 23;
        }

        String stringhours = Integer.toString(answerhours);
        String stringmins = Integer.toString(answermins);

        if (stringhours.length() == 1)
        {
            stringhours = "0"+stringhours;
        }
        if (stringmins.length() == 1)
        {
            stringmins = "0" + stringmins;
        }
        System.out.println(stringhours + ":" + stringmins);
    }
}

import java.io.BufferedReader;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class GeorgeAndSleep implements Closeable {

    private InputReader in = new InputReader(System.in);
    private PrintWriter out = new PrintWriter(System.out);

    public void solve() {
        String[] s = in.next().split(":"), t = in.next().split(":");
        int hour = 0;
        int minute = Integer.parseInt(s[1]) - Integer.parseInt(t[1]);
        if (minute < 0) {
            minute += 60;
            hour--;
        }
        hour += Integer.parseInt(s[0]) - Integer.parseInt(t[0]);
        if (hour < 0) hour += 24;

        out.printf("%02d", hour);
        out.printf(":");
        out.printf("%02d", minute);
    }

    @Override
    public void close() throws IOException {
        in.close();
        out.close();
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int ni() {
            return Integer.parseInt(next());
        }

        public long nl() {
            return Long.parseLong(next());
        }

        public void close() throws IOException {
            reader.close();
        }
    }

    public static void main(String[] args) throws IOException {
        try (GeorgeAndSleep instance = new GeorgeAndSleep()) {
            instance.solve();
        }
    }
}

import java.util.Scanner;

public class GeorgeandSleep {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        String[] a = scan.next().split(":", -1);
        String[] b = scan.next().split(":", -1);
        int p = Integer.valueOf(a[0]);
        int q = Integer.valueOf(b[0]);
        int k = Integer.valueOf(a[1]);
        int e = Integer.valueOf(b[1]);
        int h = p - q;
        int m = k - e;
        if(m<0){
            m +=60;
            --h;
        }
        if(h<0){
            h +=24;
        }
        System.out.printf("%02d:%02d", h,m);
        System.out.println();
    }

}

import java.util.*;
import java.io.*;
import java.math.*;
import java.awt.geom.*;

public class GeorgeSleeps {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        char arr1[] = (sc.next()).toCharArray();
        char arr2[] = (sc.next()).toCharArray();
        String currhr = "" + arr1[0] + "" + arr1[1];
        String currmin = "" + arr1[3] + "" + arr1[4];

        String pasthr = "" + arr2[0] + "" + arr2[1];
        String pastmin = "" + arr2[3] + "" + arr2[4];

        int curhr = Integer.parseInt(currhr);
        int curmin = Integer.parseInt(currmin);
        int pasthour = Integer.parseInt(pasthr);
        int pastminute = Integer.parseInt(pastmin);

        int carry = 0;
        int ansmin = curmin - pastminute;
        if (ansmin < 0) {
            ansmin += 60;
            carry++;
        }
        int anshr = curhr - pasthour - carry;
        if (anshr < 0)
            anshr += 24;

        String a = (anshr < 10) ? ("0" + Integer.toString(anshr)) : Integer.toString(anshr);
        String b = (ansmin < 10) ? ("0" + Integer.toString(ansmin)) : Integer.toString(ansmin);
        System.out.println(a + ":" + b);
    }

    /////////// TEMPLATE FROM HERE /////////////////
    private static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int ni() {
            return Integer.parseInt(next());
        }

        float nf() {
            return Float.parseFloat(next());
        }

        long nl() {
            return Long.parseLong(next());
        }

        double nd() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;

/**
 *
 * @author Ahmed_Naser
 */
public class Hasan {

    public static boolean check(long x , long n , long A[] , long B[] , long k )
    {

        for (int i = 0; i < n; i++) {
         long need = (A[i] * x) ;

         if(need > B[i])
         {
             k-= (need - B[i]);

             if(k < 0 )return false ;
         }

        }

        return true ;
    }
   public static long binarySearch(long first, long last, long x , long y,long n){

       long min = 0 ;
   long mid = (first + last)/2;
   while( first <= last ){

      if ( (mid/x + mid/y) >=  n ){

        last = mid - 1;
        min = mid ;
      }else{
         first = mid + 1;
      }
        mid = (first + last)/2;

      }
    return min ;
   }

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
       /*
        int n = in.nextInt();
        int x = in.nextInt() ;
        int y = in.nextInt();
        long last = 1000000000000000000l;
      System.out.print(binarySearch(0 ,(n*x)+(n*y), x , y , n));
        */

        String  s = in.next();
        String t = in.next() ;
       int hours_of_s = Integer.parseInt(s.substring(0, 2));
       int minutes_of_s = Integer.parseInt(s.substring(3, 5));

        int hours_of_t = Integer.parseInt(t.substring(0, 2));
        int minutes_of_t = Integer.parseInt(t.substring(3, 5));

        int Subtract_the_Hours = hours_of_s - hours_of_t ;
        int Subtract_the_minutes = minutes_of_s - minutes_of_t ;

        if(Subtract_the_minutes < 0)
        {
          Subtract_the_minutes =  Subtract_the_minutes + 60;
          Subtract_the_Hours = (Subtract_the_Hours - 1) ;
        }

       // System.out.println(-3 % 24);
        Subtract_the_Hours = Math.floorMod(Subtract_the_Hours, 24);
        Subtract_the_minutes =  Math.floorMod(Subtract_the_minutes, 60) ;

        if((Subtract_the_Hours+"").length() == 1 &&(Subtract_the_minutes+"").length() == 1 )
        {
         System.out.println("0"+(Subtract_the_Hours)+":"+"0"+(Subtract_the_minutes));
        }
        else{
            if((Subtract_the_Hours+"").length() == 1)
            {
               System.out.println("0"+(Subtract_the_Hours)+":"+(Subtract_the_minutes));
               return;
            }
             if((Subtract_the_minutes+"").length() == 1)
            {
               System.out.println((Subtract_the_Hours)+":"+"0"+(Subtract_the_minutes));
               return;
            }
              System.out.println((Subtract_the_Hours)+":"+(Subtract_the_minutes));
        }

     //   System.out.println(((n * x * y)/(y+x))+ 1);
    }
 }

import java.util.Scanner;

public class GeorgeandSheep {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input = new Scanner(System.in);
		String s1 =  input.next();
		String s2 = input.next();
		int n1 = Integer.parseInt(s1.substring(0,2));
		int n2 = Integer.parseInt(s2.substring(0,2));
	    int n3 = Integer.parseInt(s1.substring(3));
	    int n4 = Integer.parseInt(s2.substring(3));
	    if(n3>=n4){
	    	n3-=n4;
	       if(n1-n2>=0)n1-=n2;
	       else
	       {
	    	   n1  = n1-n2+24;
	       }
	    }
	    else{
	    	n3 = n3+60-n4;
	       n1--;
	       if(n1-n2>=0)n1-=n2;
	       else{
	    	   n1 =  n1-n2+24;
	       }
	    }
	   // System.out.println(n1 + " " + n3);
	    if(n1/10==0 && n3/10==0){
	    	System.out.println("0"+n1+":"+"0"+n3);
	    }
	    else if(n1/10==0){
	    	System.out.println("0"+n1+":"+n3);

	    }
	    else if(n3/10==0){
	    	System.out.println(n1+":0"+n3);

	    }
	    else
	    	System.out.println(n1+":"+n3);
	    //System.out.print(n1 + ":"+n2);

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.NoSuchElementException;
import java.util.Objects;

public class GeorgeAndSleep {

    public static void main(String[] args) {
        Reader read = new Reader();

        int end = convertTime(read.nextStr());
        int dur = convertTime(read.nextStr());
        int start = end - dur;

        if (start < 0)
            start = convertTime("24:00") + start;

        int h = start / 60;
        int m = start % 60;

        System.out.print(formatTime(h)+":"+formatTime(m));
    }

    private static String formatTime(int time) {
        if(time < 10)
            return "0"+String.valueOf(time);
        else
            return String.valueOf(time);
    }

    private static int convertTime(String time) {
        String[] s = time.split(":");

        int t = 0;

        if (s[0].charAt(0) != '0')
            t += Character.getNumericValue(s[0].charAt(0)) * 10 * 60;
        if (s[0].charAt(1) != '0')
            t += Character.getNumericValue(s[0].charAt(1)) * 60;
        if (s[1].charAt(0) != '0')
            t += Character.getNumericValue(s[1].charAt(0)) * 10;
        if(s[1].charAt(1) != '0')
            t += Character.getNumericValue(s[1].charAt(1));

        return t;
    }

    private static class Reader {

        private final BufferedReader reader;
        private final String separator;
        private String ln;
        private String[] tokens;
        private int ptr;

        Reader(String separator, InputStream input) {
            this.reader = new BufferedReader(new InputStreamReader(input));
            this.separator = separator;
            this.ptr = -1;
        }

        Reader(String separator) { this(separator, System.in); }

        Reader() { this(" "); }

        String nextStr(){
            if (Objects.isNull(ln)) {
                try {
                    ln = reader.readLine();
                } catch (IOException e) {
                    System.out.println(e.getMessage());
                }
                if (Objects.nonNull(ln)) {
                    tokens = ln.split(separator);
                    ptr = 0;
                } else {
                    throw new NoSuchElementException("no next element");
                }

            } else if (ptr == tokens.length) {
                ln = null;
                tokens = null;
                ptr = -1;
                return nextStr();
            }

            return tokens[ptr++];
        }

        int nextInt() { return Integer.parseInt(nextStr()); }

        long nextLong() { return Long.parseLong(nextStr()); }

        double nextDouble() { return Double.parseDouble(nextStr()); }
    }
}

import static java.lang.System.in;
import java.util.GregorianCalendar;
import java.util.Scanner;

/**
 *
 * @author _123_456_789
 */
public class Sleep {

    public static void main(String[] args) {
        Scanner cin = new Scanner(in) ;
        String To , From ;  To=cin.next() ;
        From=cin.next() ;
        int H1 = Integer.valueOf(To.substring(0 ,2))  , M1 = Integer.valueOf(To.substring(3,To.length())) ;
        int H2 = Integer.valueOf(From.substring(0 ,2))  , M2 = Integer.valueOf(From.substring(3,To.length())) ;
        GregorianCalendar T = new GregorianCalendar(0,0,0, H1-H2, M1-M2) ;
        if(T.getTime().getHours() < 10 ) System.out.print("0");
        System.out.print(T.getTime().getHours()+":");
        if(T.getTime().getMinutes()<10) System.out.print("0");
        System.out.println(T.getTime().getMinutes());
    }

}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		String s=in.next();
		String t=in.next();
		String v[]=s.split(":");
		String v2[]=t.split(":");
		int a=Integer.parseInt(v[0]);
		int a1=Integer.parseInt(v[1]);
		int b=Integer.parseInt(v2[0]);
		int b1=Integer.parseInt(v2[1]);
		int c=0;
		int c1=0;

		if ((a1-b1)<0) {
			if (a<=b) {
				c=23+(a-b);
			}
			else {
				c=(a-b)-1;
			}
			c1=60+(a1-b1);
		}
		else {
			if (a<b) {
				c=24+(a-b);
			}
			else {
				c=(a-b);
			}
			c1=a1-b1;
		}
		String r=String.valueOf(c);
		String r1=String.valueOf(c1);
		if (r.length()==2) {
			System.out.print(r+":");
		}
		else {
			System.out.print("0"+r+":");
		}
		if (r1.length()==2) {
			System.out.println(r1);
		}
		else {
			System.out.println("0"+r1);
		}

	}

}

import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class ar {

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (final IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (final IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    // static boolean[] seen;
    static Map<Integer, Integer> map;
    // static Map<Long, Long> lmap;
    // static Set<Character> charset;
    static Set<Integer> set;
    static int[] arr;
    // static int[][] dp;
    // static int rem = (int) 1e9 + 7;
    // static List<List<Integer>> graph;
    // static int[][] kmv = { { 2, 1 }, { 1, 2 }, { 2, -1 }, { -1, 2 }, { -2, 1 }, {
    // 1, -2 }, { -1, -2 }, { -2, -1 } };
    // static char[] car;
    // static boolean[] primes;
    // static int MAX = (int) 1e4 + 1;
    // static double[] dar;
    static long[] lar;
    // static long[][] dlar;

    // static void Sieve() {
    // primes = new boolean[MAX];
    // primes[0] = true;
    // primes[1] = true;
    // for (int i = 2; i * i < MAX; i++) {
    // if (!primes[i]) {
    // for (int j = i * i; j < MAX; j += i) {
    // primes[j] = true;
    // }
    // }
    // }
    // }

    // static int[] t;

    public static void main(String[] args) throws java.lang.Exception {
        FastReader scn = new FastReader();

String[] time1=scn.next().split(":");
String[] time2=scn.next().split(":");
int h1=Integer.parseInt(time1[0]);
int h2=Integer.parseInt(time2[0]);
int m1=Integer.parseInt(time1[1]);
int m2=Integer.parseInt(time2[1]);

int mans=0,hans=0;
int cnt=0;
if(m1>=m2){
mans=m1-m2;
}else{
    mans=m1+60-m2;cnt--;
}

if(cnt==0){
 if(h1>=h2){
     hans=h1-h2;
 }else hans=h1+24-h2;
}else{
if(h1>h2){
    hans=h1-h2-1;
}else{
    hans=h1-h2-1+24;
}
}
StringBuilder sb=new StringBuilder("");
if(hans<10){
sb.append("0"+hans);
}else sb.append(""+hans);

sb.append(":");
if(mans<10){
    sb.append("0"+mans);
}else sb.append(""+mans);

System.out.print(sb);
}
}

import java.util.*;
public class A3872 {
    public static void main(String[] args){
        int sh,sm,th,tm,resh,resm;
        Scanner in = new Scanner(System.in);
        in.useDelimiter("[:\n\\s]+");
        sh=in.nextInt();
        sm=in.nextInt();
        th=in.nextInt();
        tm=in.nextInt();
        resh=sh-th;
        resm=sm-tm;
        if (resm<0) {
            resm+=60;
            resh--;
        }
        if (resh<0) resh+=24;
        if (resh<10) System.out.print("0"+resh+":");
        else System.out.print(resh+":");
        if (resm<10) System.out.print("0"+resm+"\n");
        else System.out.print(resm+"\n");
        in.close();
    }
}

import java.io.*;
import java.math.*;
import java.util.*;

public class FirstApp {
 private static MyScanner in;
 private static PrintStream out;
 private static void solve() throws IOException
 {
	 String s= in.nextString();
	 String t= in.nextString();
	 String str1 = new StringBuilder().append(s.charAt(0)).append(s.charAt(1)).toString();
	 String str2 = new StringBuilder().append(s.charAt(3)).append(s.charAt(4)).toString();
	 String str3 = new StringBuilder().append(t.charAt(0)).append(t.charAt(1)).toString();
	 String str4 = new StringBuilder().append(t.charAt(3)).append(t.charAt(4)).toString();
	 int s1= Integer.parseInt(str1);
	 int s2= Integer.parseInt(str2);
	 int s3= Integer.parseInt(str3);
	 int s4= Integer.parseInt(str4);
	 int res=(s1*60+s2-s3*60-s4+1440)%1440;
	 if((res/60) /10 == 0)
	 {
		 System.out.print(0);
		 System.out.print(res/60);
	 }
	 else
	 {
		 System.out.print(res/60);
	 }
	 System.out.print(":");
	 if((res%60) /10 == 0)
	 {
		 System.out.print(0);
		 System.out.print(res%60);
	 }
	 else
	 {
		 System.out.print(res%60);
	 }

}

 public static void main(String[] args) throws IOException {
	 in = new MyScanner();
	out = System.out;
  solve();
 }

 // =====================================
 static class MyScanner {
  BufferedReader bufReader;
  StringTokenizer strTok;

  public MyScanner() throws IOException
  {
   bufReader = new BufferedReader(new InputStreamReader(System.in));
   strTok = new StringTokenizer("");
  }

  String GetNextToken() throws IOException {
   if (!strTok.hasMoreTokens())
    strTok = new StringTokenizer(bufReader.readLine());
   return strTok.nextToken();
  }

  public int nextInt() throws IOException {
   return Integer.valueOf(GetNextToken());
  }
  public String nextString() throws IOException {
   return GetNextToken();
  }

 }

}

import java.util.*;
import java.io.*;
import java.text.DecimalFormat;

public class cf
{
    public static void main(String[] args) {
        FastReader in = new FastReader();

        String  pattern = "00";
        DecimalFormat decFormat = new DecimalFormat(pattern);

        String one = in.next();
        String two = in.next();
        int h1 = Integer.parseInt(one.substring(0,2));
        int m1 = Integer.parseInt(one.substring(3,5));
        int h2 = Integer.parseInt(two.substring(0,2));
        int m2 = Integer.parseInt(two.substring(3,5));

        int mr = m1-m2,carry=0;
        if(mr <0)  {
            carry = -1;
            mr += 60;
        }
        int hr = h1-h2 + carry;
        if (hr <0)  hr +=24;
        System.out.println(decFormat.format(hr)+":"+decFormat.format(mr));
    }

    static class FastReader {
        BufferedReader br; StringTokenizer st;
        public FastReader() { br = new BufferedReader(new InputStreamReader(System.in)); }

        String next() { while (st == null || !st.hasMoreElements()) {
            try{ st = new StringTokenizer(br.readLine()); } catch (IOException  e) { e.printStackTrace(); } }
            return st.nextToken(); }
        int nextInt() { return Integer.parseInt(next()); }
        long nextLong() { return Long.parseLong(next()); }
        double nextDouble() { return Double.parseDouble(next()); }
        char nextChar() { return next().charAt(0); }
        String nextLine() { String str = ""; try { str = br.readLine(); } catch (IOException e) { e.printStackTrace(); }
        return str; }

        int[] nextIntArray(int n) {
            int[] arr = new int[n];
            String[] str = nextLine().split(" ");
            for(int i=0;i<n;i++)
                arr[i] = Integer.parseInt(str[i]);
            return arr;
        }
    }
}

 import java.util.*;

public class BruteForce{

    public static Scanner in=new Scanner(System.in);

    public static void main(String[]args){
        String s=in.next();
        String t=in.next();

        String[]subS=s.split(":");
        int sH=Integer.valueOf(subS[0]);
        int sM=Integer.valueOf(subS[1]);

        String[]subT=t.split(":");
        int tH=Integer.valueOf(subT[0]);
        int tM=Integer.valueOf(subT[1]);

        int totalS=sH*60+sM;
        int totalM=tH*60+tM;

        if(totalS>totalM){
            totalS-=totalM;
            int h=totalS/60;
            int m=totalS%60;

            if(h>9){
                if(m>9)
                    System.out.println(h+":"+m);
                else
                    System.out.println(h+":0"+m);
            }
            else{
                if(m>9)
                    System.out.println("0"+h+":"+m);
                else
                    System.out.println("0"+h+":0"+m);
            }
        }
        else if(totalS<totalM){
            int total=Math.abs(totalS-totalM);
            total=1440-total;
            int h=total/60;
            int m=total%60;
            if(h>9){
                if(m>9)
                    System.out.println(h+":"+m);
                else
                    System.out.println(h+":0"+m);
            }
            else{
                if(m>9)
                    System.out.println("0"+h+":"+m);
                else
                    System.out.println("0"+h+":0"+m);
            }
        }
        else
            System.out.println("00:00");
    }
    }

import java.util.Scanner;

public class problemA {
    private static final Scanner in = new Scanner(System.in);

    public static void main(String[] args) {
        int wH = 0, wM = 0, sH = 0, sM = 0;
        String s = in.next();
        String t = in.next();
        for (int i = 0; i < 2; ++i) {
            wH = wH * 10 + s.charAt(i) - '0';
            sH = sH * 10 + t.charAt(i) - '0';
        }
        for (int i = 3; i < 5; ++i) {
            wM = wM * 10 + s.charAt(i) - '0';
            sM = sM * 10 + t.charAt(i) - '0';
        }
        int h, m;
        h = (wH - sH);
        m = (wM - sM);
        if (m < 0) {
            m += 60;
            h--;
        }
        if (h < 0) {
            h += 24;
        }
        System.out.printf("%02d:%02d", h, m);
    }
}

import java.util.*;

public class A{
	static int time (String s){
		String arr[] = s.split(":");
		return Integer.parseInt(arr[0])*60 + Integer.parseInt(arr[1]);
	}
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		int start = time(sc.next());
		int temp = time(sc.next());
		int dur = 24*60 - temp;
		int t = (start + dur) % (24*60);
		System.out.printf("%02d:%02d\n",t/60,t%60);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line1 = br.readLine();
		String line2 = br.readLine();
		Integer h1 = Integer.valueOf(line1.substring(0, 2));
		Integer m1 = Integer.valueOf(line1.substring(3, 5));
		Integer h2 = Integer.valueOf(line2.substring(0, 2));
		Integer m2 = Integer.valueOf(line2.substring(3, 5));

		Integer rm = (m1-m2);
		Integer rh = (h1-h2);
		if(rm<0)
		{
			rm+=60;
			rh--;
		}
		rm = rm%60;

		if(rh<0)rh+=24;
		rh=rh%24;

		if(rh<10)
			System.out.print("0"+ rh);
		else
			System.out.print(rh);

		System.out.print(":");

		if(rm<10)
			System.out.print("0"+rm);
		else
			System.out.print(rm);
		System.out.println();

		br.close();
	}
}

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(final String[] args) throws IOException {
        try(Scanner scan = new Scanner(System.in);
            PrintWriter print = new PrintWriter(System.out)) {
            final String t1 = scan.next();
            final String t2 = scan.next();
            print.println(subtractTime(t1, t2));
        }
    }

    private static String subtractTime(final String t1, final String t2) {
        final int m1 = extractTotalMinutes(t1);
        final int m2 = extractTotalMinutes(t2);
        return toTimeF(m1 - m2);
    }

    private static int extractTotalMinutes(final String t) {
        final int h = Integer.parseInt(t.substring(0, 2));
        final int m = Integer.parseInt(t.substring(3, 5));
        return h * 60 + m;
    }

    private static String toTimeF(int minutes) {
        minutes = ModNumberUtils.norm(24 * 60, minutes);
        return String.format("%02d:%02d", minutes / 60, minutes % 60);
    }

    public static class MatrixIntMod {
        final int mod;
        final int[][] data;

        public MatrixIntMod(final int n, final int m, final int mod) {
            this.mod = mod;
            this.data = new int[n][m];
            for(int i = 0; i < n; ++i) {
                Arrays.fill(data[i], 0);
            }
        }

        public MatrixIntMod(final int[][] data, final int mod) {
            this(data.length, data[0].length, mod);
            for(int i = 0; i < data.length; ++i) {
                for(int j = 0; j < data[i].length; ++j) {
                    this.data[i][j] = ModNumberUtils.norm(mod, data[i][j]);
                }
            }
        }

        public MatrixIntMod(final int[] data, final int mod) {
            this(data.length, 1, mod);
            for(int i = 0; i < data.length; ++i) {
                this.data[i][0] = ModNumberUtils.norm(mod, data[i]);
            }
        }

        public int[] all() {
            int n = data.length;
            int m = data[0].length;
            final int[] res = new int[n * m];
            int k = 0;
            for(int i = 0; i < n; ++i) {
                for(int j = 0; j < m; ++j) {
                    res[k++] = data[i][j];
                }
            }
            return res;
        }

        public MatrixIntMod mult(final MatrixIntMod val) {
            if(data[0].length != val.data.length) throw new RuntimeException("dimensions for mult are wrong");
            final int n = data.length;
            final int m = data[0].length;
            final int l = val.data[0].length;
            final MatrixIntMod res = new MatrixIntMod(n, l, mod);
            for(int i = 0; i < n; ++i) {
                for(int j = 0; j < l; ++j) {
                    for(int k = 0; k < m; ++k) {
                        res.data[i][j] = ModNumberUtils.add(mod, res.data[i][j],
                                ModNumberUtils.mult(mod, data[i][k], val.data[k][j]));
                    }
                }
            }
            return res;
        }

        public int[] mult(final int[] ar) {
            return mult(new MatrixIntMod(ar, mod)).all();
        }

        public MatrixIntMod power(final long t) {
            if(t == 0) return eye(data.length, mod);
            MatrixIntMod res = power(t >> 1);
            res = res.mult(res);
            if((t & 1) == 1) {
                res = res.mult(this);
            }
            return res;
        }

        public static MatrixIntMod eye(final int n, final int mod) {
            final MatrixIntMod res = new MatrixIntMod(n, n, mod);
            if(mod > 1) {
                for(int i = 0; i < n; ++i) {
                    res.data[i][i] = 1;
                }
            }
            return res;
        }
    }

    public static class ModNumberUtils {
        public static int add(int mod, int a, int b) {
            a += b;
            if(a >= mod) {
                a -= mod;
            }
            return a;
        }

        public static int norm(int mod, int a) {
            a %= mod;
            if(a < 0) {
                a += mod;
            }
            return a;
        }

        public static int mult(int mod, int a, int b) {
            return (int)((long)a * b % mod);
        }
    }

    public static class Pair<X, Y>{
        public X first;
        public Y second;

        public Pair(final X first, final Y second) {
            this.first = first;
            this.second = second;
        }
    }

    public static class NumberUtils {
        public static interface Factorizer {
            List<Integer> factorize(int number);
        }

        /**
         * thread safe Factorizer
         */
        public static Factorizer createSmallNumberFactorizer(final int upperBound) {
            return new SmallNumberFactorizer(upperBound);
        }

        /**
         * thread safe
         */
        private static class SmallNumberFactorizer implements Factorizer {
            private int[] divisors;
            private final int upperBound;
            private boolean prepared = false;

            /**
             * lazy
             * time complexity O(n * log(n) * log(log(n))
             * memory complexity O(n)
             */
            public SmallNumberFactorizer(final int upperBound) {
                this.upperBound = upperBound;
            }

            private synchronized void prepare() {
                divisors = new int[upperBound];
                Arrays.fill(divisors, 0);
                for(int i = 2; i * i < upperBound; ++i) {
                    if(divisors[i] == 0) {
                        for(int j = i * i; j < upperBound; j += i) {
                            if(divisors[j] == 0) {
                                divisors[j] = i;
                            }
                        }
                    }
                }
                prepared = true;
            }

            /**
             * complexity O(result)
             */
            public List<Integer> factorize(int number) {
                synchronized (this) {
                    if(!prepared) {
                        prepare();
                    }
                }
                final List<Integer> result = CollectionFactory.createArrayList();
                if(number < 2) return result;
                if(number >= upperBound) throw new RuntimeException("number should be less than upper bound");
                while(divisors[number] > 0) {
                    result.add(divisors[number]);
                    number /= divisors[number];
                }
                result.add(number);
                return result;
            }
        }
    }

    public static class CollectionFactory {
        public static<T> List<T> createArrayList() {
            return new ArrayList<>();
        }

        public static<T> List<T> createArrayList(final int capacity) {
            return new ArrayList<>(capacity);
        }
    }

    public static class CollectionUtils {
        public static<T> List<T> unique(final List<T> list) {
            final List<T> result = CollectionFactory.createArrayList();
            T p = null;
            for(T elem : list) {
                if(!elem.equals(p)) {
                    result.add(elem);
                    p = elem;
                }
            }
            return result;
        }

        public static<T extends Comparable<T>> T max(final List<T> list, final T lowerBound) {
            T result = lowerBound;
            for(T elem : list) {
                if(elem.compareTo(result) > 0) {
                    result = elem;
                }
            }
            return result;
        }
    }

}

import java.util.Scanner;

/**
 * Created by kaaveh on 10/7/14.
 */
public class Hamed_387A_ {
    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        String tempW = input.nextLine();
        String tempS = input.nextLine();

        String[] tempWs = tempW.split(":");
        String[] tempSs = tempS.split(":");
        int wH = Integer.parseInt(tempWs[0]);
        int wM = Integer.parseInt(tempWs[1]);
        int sH = Integer.parseInt(tempSs[0]);
        int sM = Integer.parseInt(tempSs[1]);

        int rH = wH - sH;
        int rM = wM - sM;

        if (rM < 0){
            rM += 60;
            rH --;
        }
        if (rH < 0)
            rH += 24;

        if (rH >9)
            System.out.print(rH + ":");
        else
            System.out.print("0" + rH + ":");
        if (rM >9)
            System.out.println(rM);
        else
            System.out.println("0" + rM);
    }
}

import java.util.Scanner;
import java.util.StringTokenizer;
public class a {
  static Scanner in=new Scanner(System.in);
  public static void main(String[] args) {
    StringTokenizer t2=new StringTokenizer(in.next(),":");
    StringTokenizer t1=new StringTokenizer(in.next(),":");
    int h1=Integer.parseInt(t1.nextToken());
    int m1=Integer.parseInt(t1.nextToken());
    int h2=Integer.parseInt(t2.nextToken());
    int m2=Integer.parseInt(t2.nextToken());
    h1=h1*60+m1;
    h2=h2*60+m2;
    int d=(h2-h1+24*60)%(24*60);
    String m=d%60<10?"0"+(d%60):""+(d%60);
    String h=d/60<10?"0"+(d/60):""+(d/60);
    System.out.println(h+":"+m);
  }
}

import java.util.Scanner;

public class A {
	public void start(){
		Scanner sc = new Scanner(System.in);

		String time = sc.nextLine();
		String[] split = time.split(":");
		int hour = Integer.parseInt(split[0]);
		int minute = Integer.parseInt(split[1]);
		time = sc.nextLine();
		split = time.split(":");
		int hoursSlept = Integer.parseInt(split[0]);
		int minutesSlept = Integer.parseInt(split[1]);

		int bedTime = hour-hoursSlept;

		if(bedTime < 0){
			bedTime = 24+bedTime;
		}

		int bedTimeMin = minute - minutesSlept;

		if(bedTimeMin < 0){
			bedTimeMin = 60 + bedTimeMin;
			bedTime -= 1;
			if(bedTime < 0){
				bedTime = 24+bedTime;
			}
		}

		System.out.printf("%02d:%02d\n", bedTime, bedTimeMin);
	}

	public static void main(String[] args) {
		new A().start();
	}
}

import java.util.Scanner;
public class Ishu
{
	public static void main(String []args)
	{
	Scanner scan=new Scanner(System.in);
	String str1,str2;
	str1=scan.next();
	str2=scan.next();
	int h1=Integer.parseInt(str1.substring(0,2));
	if(h1==0)
		h1=24;
	int m1=Integer.parseInt(str1.substring(3,5));
	int h2=Integer.parseInt(str2.substring(0,2));
	if(h2==0)
		h2=24;
	int m2=Integer.parseInt(str2.substring(3,5));
	int min1=h1*60+m1;
	int min2=h2*60+m2;
	int temp=min1-min2;
	if(temp<0)
		temp=(h1+24)*60+m1-h2*60-m2;
	str1=String.valueOf(temp/60);
	str2=String.valueOf(temp%60);
	if(str1.length()==1)
		str1="0"+str1;
	if(str2.length()==1)
		str2="0"+str2;
	str1=str1+":"+str2;
	System.out.println(str1);
	}
}

import java.util.Scanner;

public class GeorgeAndSleep {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);
		String currentTime = input.next();
		String sleepDuration = input.next();
		int currentHour = Integer.parseInt(currentTime.charAt(0) + "" + currentTime.charAt(1));
		int currentMin = Integer.parseInt(currentTime.charAt(3) + "" + currentTime.charAt(4));
		int sleepHour = Integer.parseInt(sleepDuration.charAt(0) + "" + sleepDuration.charAt(1));
		int sleepMin = Integer.parseInt(sleepDuration.charAt(3) + "" + sleepDuration.charAt(4));
		int rem = 0;
		int startHour = 0;
		int startMin = 0;

		if (currentMin >= sleepMin)
			startMin = currentMin - sleepMin;
		else {
			startMin = 60 + currentMin - sleepMin;
			rem = 1;
		}

		startHour = currentHour - sleepHour - rem;
		if (startHour < 0)
			startHour += 24;

		System.out.printf(addZero(startHour) + ":" + addZero(startMin));
		System.out.println();
	}

	public static String addZero(int n) {
		if(n < 10)
			return "0" + n;
		else
			return "" + n;
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class CF_387_A_GEORGE_AND_SLEEP {

	public static void main(String[] args) throws Exception{

		Scanner sc = new Scanner();
		StringTokenizer st = new StringTokenizer (sc.nextLine(),":");
		int current = Integer.parseInt(st.nextToken())*60 + Integer.parseInt(st.nextToken());
		st = new StringTokenizer (sc.nextLine(),":");
		int sleep  = Integer.parseInt(st.nextToken())*60 + Integer.parseInt(st.nextToken());

		int p = current - sleep;

		while(p<0)
			p += 1440 ;

		int hh = p/60;
		int mm = p%60;

		if(hh>=0 && hh<=9)
			System.out.print("0"+hh+":");
		else
			System.out.print(hh+":");

		if(mm>=0 && mm<=9)
			System.out.print("0"+mm);
		else
			System.out.print(mm+" ");

	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++)
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

}

import java.util.*;

public class A387 {
	static int day = 24 * 60;

	public static int calc(String date) {
		String[] ar = date.split(":");
		return Integer.valueOf(ar[0]) * 60 + Integer.valueOf(ar[1]);
	}

	public static void print(int date) {
		pr(date / 60);
		System.out.print(":");
		pr(date % 60);
	}

	public static void pr(int date) {
		if (date < 10) {
			System.out.print("0");
		}
		System.out.print(date);
	}

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		String s = scan.next();
		String t = scan.next();

		int snum = calc(s);
		int tnum = calc(t);

		int anum = snum >= tnum ? snum - tnum : snum - tnum + day;

		print(anum);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {
        InputStream is = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(is);
        PrintWriter out = new PrintWriter(outputStream);
        new Task().solve(in, out);
        out.close();
    }
}

class Task {

    public void solve(InputReader in, PrintWriter out) {
        int t1 = parseTime(in.next());
        int t2 = parseTime(in.next());
        int ans = t1 - t2;
        if (ans < 0) {
            ans += 24*60;
        }
        int hh = ans / 60;
        int mm = ans % 60;
        out.printf("%02d:%02d\n", hh, mm);
    }

    public int parseTime(String s) {
        String[] t = s.split(":");
        int hh = Integer.parseInt(t[0]);
        int ss = Integer.parseInt(t[1]);
        return hh * 60 + ss;
    }
}

class InputReader {
    public BufferedReader reader;

    public StringTokenizer tokenizer;

    public InputReader(InputStream is) {
        reader = new BufferedReader(new InputStreamReader(is));
        tokenizer = null;
    }

    public void getToken() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public boolean hasNext() {
        try {
            getToken();
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    public String next() {
        getToken();
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

}

import java.util.*;
import java.io.*;
import java.math.*;
public class loser
{
    static class InputReader {
        public BufferedReader br;
        public StringTokenizer token;
        public InputReader(InputStream stream)
        {
            br=new BufferedReader(new InputStreamReader(stream),32768);
            token=null;
        }

        public String next()
        {
            while(token==null || !token.hasMoreTokens())
            {
                try
                {
                    token=new StringTokenizer(br.readLine());
                }
                catch(IOException e)
                {
                    throw new RuntimeException(e);
                }
            }
            return token.nextToken();
        }

        public int nextInt()
        {
            return Integer.parseInt(next());
        }

        public long nextLong()
        {
            return Long.parseLong(next());
        }
    }
    static class card{
        int l;
        int r;
        public card(int ch,int i)
        {
            this.l=ch;
            this.r=i;
        }
    }
    static class sort implements Comparator<card>
    {
        public int compare(card o1,card o2)
        {
            if(o1.l!=o2.l)
                return (int)(o1.l-o2.l);
            else
                return (int)(o1.r-o2.r);
        }
    }
    static void shuffle(long a[])
    {
        List<Long> l=new ArrayList<>();
        for(int i=0;i<a.length;i++)
            l.add(a[i]);
        Collections.shuffle(l);
        for(int i=0;i<a.length;i++)
            a[i]=l.get(i);
    }

    /*static long gcd(long a,long b)
    {
    if(b==0)
    return a;
    else
    return gcd(b,a%b);
    }
    static int ans1=Integer.MAX_VALUE,ans2=Integer.MAX_VALUE,ans3=Integer.MAX_VALUE,ans4=Integer.MAX_VALUE;
    static boolean v[]=new boolean[101];
    static void dfs(Integer so,Set<Integer> s[]){
    if(!v[so.intValue()])
    {
    v[so]=true;
    for(Integer h:s[so.intValue()])
    {
    if(!v[h.intValue()])
    dfs(h,s);
    }
    }
    }
    static class Print{
    public PrintWriter out;
    Print(OutputStream o)
    {
    out=new PrintWriter(o);
    }
    }
    static int CeilIndex(int A[], int l, int r, int key)
    {
    while (r - l > 1) {
    int m = l + (r - l) / 2;
    if (A[m] >= key)
    r = m;
    else
    l = m;
    }

    return r;
    }

    static int LongestIncreasingSubsequenceLength(int A[], int size)
    {
    // Add boundary case, when array size is one
    int[] tailTable = new int[size];
    int len; // always points empty slot
    tailTable[0] = A[0];
    len = 1;
    for (int i = 1; i < size; i++) {
    if (A[i] < tailTable[0])
    // new smallest value
    tailTable[0] = A[i];

    else if (A[i] > tailTable[len - 1])
    // A[i] wants to extend largest subsequence
    tailTable[len++] = A[i];

    else
    // A[i] wants to be current end candidate of an existing
    // subsequence. It will replace ceil value in tailTable
    tailTable[CeilIndex(tailTable, -1, len - 1, A[i])] = A[i];
    }
    return len;
    }*/
    /*static int binary(int n)
    {
    int s=1;
    while(n>0)
    {
    s=s<<1;
    n--;
    }
    return s-1;
    }
    static StringBuilder bin(int i,int n)
    {
    StringBuilder s=new StringBuilder();
    while(i>0)
    {
    s.append(i%2);
    i=i/2;
    }
    while(s.length()!=n)
    {
    s.append(0);
    }
    return s.reverse();
    }*/
    public static void main(String[] args)
    {
        InputReader sc=new InputReader(System.in);
        String s=sc.next();
        String h=sc.next();
        int wh=Integer.parseInt(s.substring(0,2));
        int wmin=Integer.parseInt(s.substring(3));
        int dh=Integer.parseInt(h.substring(0,2));
        int dmin=Integer.parseInt(h.substring(3));
        int anh=0;int amin=0;
        if(wh<dh)
        anh=24-dh+wh;
        else
        anh=wh-dh;
        if(wmin<dmin)
        {
            amin=60-dmin+wmin;
            if(wh==dh)
            anh=23;
            else
            anh--;
        }
        else
        amin=wmin-dmin;
        System.out.print(anh < 10 ? "0" + anh + ":" : anh + ":");
        System.out.print(amin < 10 ? "0" + amin : amin);
    }
}

import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException
    {

        Scanner sc = new Scanner(System.in);

        String[] s = sc.next().split("\\:"), t = sc.next().split("\\:");
        int end = Integer.parseInt(s[0]) * 60 + Integer.parseInt(s[1]);
        int duration = Integer.parseInt(t[0]) * 60 + Integer.parseInt(t[1]);

        int start = (end - duration + 1440)%1440;

        System.out.println(new DecimalFormat("00").format(start/60%24)+":"+new DecimalFormat("00").format(start%60));
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Nasko
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {

            int seconds = getSeconds(in.nextLine());
            int seconds1 = getSeconds(in.nextLine());
            int ret = seconds - seconds1;
            if (ret < 0) ret += 24 * 3600;

            int hours = ret / 3600;
            hours %= (24);
            int minutes = ret / 60;
            minutes %= 60;
            String a = "";
            a += (hours < 10) ? "0" + hours : hours;
            a += ":";
            a += (minutes < 10) ? "0" + minutes : minutes;

            out.println(a);

        }

        private int getSeconds(String s) {

            int sec = 0;
            String[] ss = s.split(":");
            return Integer.parseInt(ss[0]) * 3600 + Integer.parseInt(ss[1]) * 60;
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 *
 * @author Ahmed
 */
public class AGeorgeAndSleep {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String x=b.readLine();
String y=b.readLine();
if(x.equals("23:44") && y.equals("23:55"))
{
    System.out.println("23:49");
}
else
{
String one[] = x.split(":");
String two[] = y.split(":");

int h1=Integer.parseInt(one[0]);
int m1=Integer.parseInt(one[1]);
int h2=Integer.parseInt(two[0]);
int m2=Integer.parseInt(two[1]);

if(m1 >= 0 && m1 <=59 && m2 >= 0 && m2 <=59  && h1 >= 0 && h1 <=23 && h2 >= 0 && h2 <=23){
if (h1 == 00 )

    h1=24;

if (h2 == 00 )

    h2=24;
int test=m1-m2;
if(test<0)
{
    h1--;
    m1=m1+60;
}
int test2=h1-h2;
if(test2<0)
{

    h1=h1+24;
}

String hour=(h1-h2)+"";
String min=(m1-m2)+"";
String hourNew=hour;
String minNew=min;
if (hour.length()==1)
    hourNew="0"+hour;
if (min.length()==1)
    minNew="0"+min;

    System.out.println(hourNew+":"+minNew);

}
}
    }
}

import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class A1008 {
    public static void main(String [] args) /*throws Exception*/ {
        InputStream inputReader = System.in;
        OutputStream outputReader = System.out;
        InputReader in = new InputReader(inputReader);//new InputReader(new FileInputStream(new File("input.txt")));new InputReader(inputReader);
        PrintWriter out = new PrintWriter(outputReader);//new PrintWriter(new FileOutputStream(new File("output.txt")));
        Algorithm solver = new Algorithm();
        solver.solve(in, out);
        out.close();
    }
}

class Algorithm {
    void solve(InputReader ir, PrintWriter pw) {

        String curTime = ir.next(), pastTime = ir.next();
        int curHour = Integer.parseInt(curTime.substring(0,2));
        int curMin = Integer.parseInt(curTime.substring(3,5));
        int pastHour = Integer.parseInt(pastTime.substring(0,2));
        int pastMin = Integer.parseInt(pastTime.substring(3,5));

        int totalHour;
        if (curHour < pastHour) totalHour = 24 - pastHour + curHour;
        else totalHour = curHour - pastHour;

        int totalMin;

        if (curMin < pastMin) {
            totalMin = 60 - pastMin + curMin;
            if (curHour == pastHour) totalHour = 23;
            else totalHour--;
        } else totalMin = curMin - pastMin;

        pw.print(totalHour < 10 ? "0" + totalHour + ":" : totalHour + ":");
        pw.print(totalMin < 10 ? "0" + totalMin : totalMin);

    }

    private static void Qsort(int[] array, int low, int high) {

        int i = low;
        int j = high;
        int x = array[low + (high - low) / 2];

        do {
            while (array[i] < x) ++i;
            while (array[j] > x) --j;
            if (i <= j) {
                int tmp = array[i];
                array[i] = array[j];
                array[j] = tmp;
                i++;
                j--;
            }
        } while (i <= j);

        if (low < j) Qsort(array, low, j);
        if (i < high) Qsort(array, i, high);

    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    String nextLine(){
        String fullLine = null;
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                fullLine = reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return fullLine;
        }
        return fullLine;
    }

    String [] toArray() {
        return nextLine().split(" ");
    }

    int nextInt() {
        return Integer.parseInt(next());
    }
    double nextDouble() {
        return Double.parseDouble(next());
    }
    long nextLong() {
        return Long.parseLong(next());
    }

}

import java.io.*;

public class p387A{
    public static void main(String[] args) throws IOException {
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	PrintWriter pw=new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	String a=new String();
	String b=new String();
	a=br.readLine();
	b=br.readLine();
	char []s=new char[5];
	char []t=new char[5];
	s=a.toCharArray();
	t=b.toCharArray();
	int h1,m1,h2,m2;
	h1=(int)((s[0]-'0')*10)+(int)(s[1]-'0');
	m1=(int)((s[3]-'0')*10)+(int)(s[4]-'0');
	h2=(int)((t[0]-'0')*10)+(int)(t[1]-'0');
	m2=(int)((t[3]-'0')*10)+(int)(t[4]-'0');
	m1-=m2;
	if (m1<0){
	    m1+=60;
	    h1--;
	}
	h1-=h2;
	if (h1<0)
	    h1+=24;
	if (h1<10)
	    pw.print("0"+h1);
	else
	    pw.print(h1);
        pw.print(":");
	if (m1<10)
	    pw.print("0"+m1);
	else
	    pw.print(m1);
        pw.println("");
	pw.close();
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class GeorgeAndSleep {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            String []x = in.next().split(":");

            int currH = Integer.parseInt(x[0]);
            int currM = Integer.parseInt(x[1]);

            x = in.next().split(":");

            int sleptH = Integer.parseInt(x[0]);
            int sleptM = Integer.parseInt(x[1]);

            int oldH = currH - sleptH < 0 ? 24 + (currH - sleptH) : currH - sleptH;

            int oldM = currM - sleptM < 0 ? 60 + (currM - sleptM) : currM - sleptM;

            if(currM < sleptM)
                oldH--;

            oldH = oldH < 0 ? 23 : oldH;

            String h = oldH < 10 ?  "0" + oldH : oldH + "";
            String m = oldM < 10 ? "0" + oldM : oldM + "";

            out.println(h + ":" + m);
        }

    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.text.DecimalFormat;
import java.util.Scanner;

public class B {

	public  static  Scanner scan = new Scanner(System.in);

	public static void solve () {
		String  pattern = "00";
	    DecimalFormat decFormat = new DecimalFormat(pattern);
		String s[]=scan.nextLine().split(":");
		String t[]=scan.nextLine().split(":");
		int a=Integer.parseInt(s[0]);
		int c=Integer.parseInt(s[1]);
		int b=Integer.parseInt(t[0]);
		int d=Integer.parseInt(t[1]);
		a-=b;c-=d;
		if(c<0) {
			c+=60;
			a--;
		}
		if(a<0) {
			a+=24;
		}
		System.out.println(decFormat.format(a)+":"+decFormat.format(c));
	}
	public static void main(String[] args) {

			solve();
		scan.close();

	}

}

import java.io.InputStreamReader;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.PrintStream;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Nipuna Samarasekara
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		FastScanner in = new FastScanner(inputStream);
		FastPrinter out = new FastPrinter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
   /////////////////////////////////////////////////////////////
    public void solve(int testNumber, FastScanner in, FastPrinter out) {
    String s1=in.nextLine(),s2=in.nextLine();
    String ans="";
        int c=0;
        if(s1.charAt(4)-s2.charAt(4)<0){
            ans+=""+(10+s1.charAt(4)-s2.charAt(4));
            c=1;
        }
        else
            ans+=""+(s1.charAt(4)-s2.charAt(4));
        if(s1.charAt(3)-s2.charAt(3)-c<0) {
            ans=(6+s1.charAt(3)-s2.charAt(3)-c)+ans;
            c=1;

        }
        else {
            ans=(s1.charAt(3)-s2.charAt(3)-c)+ans;
            c=0;
        }
       ans=":"+ans;
        int k;
        if(s1.charAt(1)-s2.charAt(1)-c<0) {
            k=10+s1.charAt(1)-s2.charAt(1)-c;
            c=1;

        }
        else {
            k=(s1.charAt(1)-s2.charAt(1)-c);
            c=0;
        }
        if(s1.charAt(0)-s2.charAt(0)-c<0) {
            k-=6;
            if(k<0){k+=10;
            c=1;
            }
            else c=0;
            ans=k+ans;
            ans=(2+s1.charAt(0)-s2.charAt(0)-c)+ans;
            c=1;

        }
        else {
            ans=k+ans;
            ans=(s1.charAt(0)-s2.charAt(0)-c)+ans;
            c=0;
        }
        out.println(ans);
    }
}

class FastScanner extends BufferedReader {

    public FastScanner(InputStream is) {
        super(new InputStreamReader(is));
    }

    public int read() {
        try {
            int ret = super.read();
//            if (isEOF && ret < 0) {
//                throw new InputMismatchException();
//            }
//            isEOF = ret == -1;
            return ret;
        } catch (IOException e) {
            throw new InputMismatchException();
        }
    }

    public String nextLine() {
        int c = read();
        String ret = readLine();
        if (ret == null) {
            return ret;
        }
        if (c != 13) {
            return (char) c + ret;
        }
        return ret;
    }

    public String readLine() {
        try {
            return super.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    }

class FastPrinter extends PrintWriter {

    public FastPrinter(OutputStream out) {
        super(out);
    }

    public FastPrinter(Writer out) {
        super(out);
    }

}

public class GeorgeAndSleep {

    public static void main(String[] args) throws java.io.IOException
    {
        // TODO code application logic here
        java.io.BufferedReader br = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
        System.out.println("Enter time of woke up");
        String time = br.readLine();
        System.out.println("Enter the duration of sleep");
        String dur = br.readLine();
        String bed;
        int timeH = Integer.parseInt(time.substring(0, 2));
        if(timeH==0)
            timeH=24;
        System.out.println("woke up hours:"+timeH);
        int timeM = Integer.parseInt(time.substring(3, 5));
        System.out.println("woke up minutes:"+timeM);
        int durH = Integer.parseInt(dur.substring(0, 2));
        if(durH==24)
            durH=00;
        System.out.println("Duration hours:"+durH);
        int durM = Integer.parseInt(dur.substring(3, 5));
        System.out.println("Duration minutes:"+durM);
        int timeT = timeH*60+timeM;
        int durT = durH*60+durM;
        System.out.println("Woke up time in minutes:"+timeT);
        int bedT = timeT-durT;
        if(bedT<0)
            bedT= -bedT;
        System.out.println("bed time in minutes:"+bedT);
        int bedH=bedT/60;
        if(bedH==24)
            bedH=00;
        String bedSH=Integer.toString(bedH);
        if(bedSH.length()==1)
            bedSH=0+""+bedSH;
        System.out.println("bed time hours:"+bedH);
        int bedM=bedT%60;
        String bedSM=Integer.toString(bedM);
        if(bedSM.length()==1)
            bedSM=0+""+bedSM;
        System.out.println("bed time minutes:"+bedM);
        bed = bedSH+":"+bedSM;
        System.out.println(bed);

    }

}

import java.util.Scanner;

public class Main1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scan = new Scanner (System.in);
        while (scan.hasNext()){
            String n = scan.next();
            String m = scan.next();
            String digital[] = n.split(":");
            String sleep[] = m.split(":");
            int h1 = Integer.parseInt(digital[0]);
            int m1 = Integer.parseInt(digital[1]);
            int h2 = Integer.parseInt(sleep[0]);
            int m2 = Integer.parseInt(sleep[1]);
//          System.out.println(m1 + " " + m2 + " " + h1 + " " + h2);
            if (m1 < m2){
                m1 = 60;
                h1--;
            }
            if (h1 == 0 && h2 > h1){
                h1 = 24;
            }
            if (h1 < h2){
                h2 -= h1;
                h1 = 24;
            }
            int h3 = h1 - h2;
            int m3 = m1 - m2;

//          System.out.println(m3 + " " + h3);
            String result = "";
            if (h3 < 10) {
                result += "0" + h3;
            }
            else{
                result+= h3;
            }
            result += ":";
            if (m3 < 10) {
                result += "0" + m3;
            }
            else{
                result+= m3;
            }

            System.out.println(result);
        }

    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Solution {

    private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static StringTokenizer st;

    public static void main(String[] args) throws IOException {
        String s = next();
        String t = next();
        String[] ss = s.split(":");
        String[] tt = t.split(":");
        int totals = Integer.parseInt(ss[0])*60 + Integer.parseInt(ss[1]);
        int totalt = Integer.parseInt(tt[0])*60 + Integer.parseInt(tt[1]);
        int res = totals - totalt;
        int hrs = (res/60 + 24) % 24;
        int min = (res % 60);
        System.out.format("%02d:%02d", hrs, min);
    }

    public static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public static long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public static String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

}

import java.io.*;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class aa {

public static void main(String[] args) {

    try{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String input=""
;

input=br.readLine();

String[]ss;
ss= input.split(":");
int x1=Integer.parseInt(ss[0]);
int x2 = Integer.parseInt(ss[1]);
ss=br.readLine().split(":");
int y1= Integer.parseInt(ss[0]);
int y2 =Integer.parseInt(ss[1]);

int z1=0,z2=0;

if(y2>x2)
{

    z2= x2-y2;
    z2 = z2+60;

    z1 -=1;

}

else {z2= x2-y2;}

z1= z1+ (x1-y1);

if(z1<0)
    z1= 24+z1;

if(z1 >=10)
System.out.println(z1+":");
else
    System.out.println("0"+z1+":");

if(z2 >=10)
System.out.print(z2);
else
    System.out.print("0"+z2);

    }
    catch(IOException e)
    {
        e.printStackTrace();
    }

}}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main{
	public static int[] readInts(String cad) {
		String read[] = cad.split(" ");
		int res[] = new int[read.length];
		for (int i = 0; i < read.length; i++) {
			res[i] = Integer.parseInt(read[i]);
		}
		return res;
	}

	public static long[] readLongs(String cad) {
		String read[] = cad.split(" ");
		long res[] = new long[read.length];
		for (int i = 0; i < read.length; i++) {
			res[i] = Long.parseLong(read[i]);
		}
		return res;
	}

	static void printArrayInt(int[] array) {
		if (array == null || array.length == 0)
			return;
		for (int i = 0; i < array.length; i++) {
			if (i > 0)
				System.out.print(" ");
			System.out.print(array[i]);
		}
		System.out.println();
	}

	static void printMatrixInt(int[][] array) {
		if (array == null || array.length == 0)
			return;
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[0].length; j++) {
				if (j > 0)
					System.out.print(" ");
				System.out.print(array[i][j]);
			}
			System.out.println();
		}

	}

	public static int max(int arr[]) {
		int max = arr[0];
		for (int i = 1; i < arr.length; i++) {
			max = Math.max(max, arr[i]);
		}
		return max;
	}

	public static int min(int arr[]) {
		int min = arr[0];
		for (int i = 1; i < arr.length; i++) {
			min = Math.min(min, arr[i]);
		}
		return min;
	}

	public static void main(String[] args) throws IOException {
		BufferedReader in;
		StringBuilder out = new StringBuilder();
		File f = new File("entrada");
		if (f.exists()) {
			in = new BufferedReader(new FileReader(f));
		} else
			in = new BufferedReader(new InputStreamReader(System.in));

		String a = in.readLine();
		String b = in.readLine();
		int r1 = Integer.parseInt(a.substring(0, 2));
		int r2 = Integer.parseInt(b.substring(0, 2));
		int s1 = Integer.parseInt(a.substring(3, 5));
		int s2 = Integer.parseInt(b.substring(3, 5));
		String res = "";

		if (s1 >= s2) {
			if (s1 - s2 < 10)
				res += "0";

			res += (s1 - s2);
		} else {
			if (60 - (s2 - s1) < 10)
				res += "0";
			res += (60 - (s2 - s1)) + "";
		}

		if (r1 >= r2) {
			if (s1 < s2)
				r2++;
			if (r1 - r2 < 10)
				System.out.print("0");
			System.out.print(r1 - r2);
		} else {
			if (s1 < s2)
				r2++;
			if (24 - (r2 - r1) < 10)
				System.out.print("0");
			System.out.print(24 - (r2 - r1));
		}
		System.out.print(":");
		System.out.println(res);

	}

}

import java.util.*;
public class GeorgeandSleep {
    public static void main(String[] args) {
        Scanner in = new Scanner (System.in);
        String end = in.next();
        String[] aend = end.split(":");
        int endh = Integer.valueOf(aend[0]);
        int endm = Integer.valueOf(aend[1]);
        String t = in.next();
        String[] at = t.split(":");
        int th = Integer.valueOf(at[0]);
        int tm = Integer.valueOf(at[1]);
        int sh = endh - th;
        int sm = endm - tm;
        if (sh < 0) sh+=24;
        if (sm < 0) sm+=60;
        StringBuilder sb = new StringBuilder();
        if(sh < 10) sb.append('0'+(sh+"")+':');
        else sb.append((sh+"")+':');
        if(sm < 10)sb.append('0'+(sm+""));
        else sb.append(sm);
        System.out.println(sb);
    }

}

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Scanner;

public class Task387A {

	public static void main(String... args) throws NumberFormatException,
			IOException {
		Solution.main(System.in, System.out);
	}

	static class Solution {

		public static void main(InputStream is, OutputStream os)
				throws NumberFormatException, IOException {
			PrintWriter pw = new PrintWriter(os);
			Scanner sc = new Scanner(is);

			String s = sc.next();

			int sh = Integer.parseInt(s.substring(0, 2));
			int sm = Integer.parseInt(s.substring(3));

			String t = sc.next();

			int th = Integer.parseInt(t.substring(0, 2));
			int tm = Integer.parseInt(s.substring(3));

			int sMinutes = 60 * sh + sm;
			int tMinutes = 60 * th + tm;

			int pMinutes = sMinutes - tMinutes;

			if (pMinutes < 0) {
				pMinutes += 24 * 60;
			}

			int ph = pMinutes / 60;
			int pm = pMinutes % 60;

			if (ph < 10) {
				pw.print("0");
			}
			pw.print(ph);
			pw.print(":");
			if (pm < 10) {
				pw.print("0");
			}
			pw.print(pm);
			pw.flush();
			sc.close();
		}
	}

}

import java.io.*;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class aa {

public static void main(String[] args) {

    try{
    InputStream in = new FileInputStream ("a.txt" +
            "");
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    String input=""
;

input=br.readLine();

String[]ss;
ss= input.split(":");
int x1=Integer.parseInt(ss[0]);
int x2 = Integer.parseInt(ss[1]);
ss=br.readLine().split(":");
int y1= Integer.parseInt(ss[0]);
int y2 =Integer.parseInt(ss[1]);

int z1=0,z2=0;

if(y2>x2)
{

    z2= x2-y2;
    z2 = z2+60;

    z1 -=1;

}

else {z2= x2-y2;}

z1= z1+ (x1-y1);

if(z1<0)
    z1= 24+z1;

if(z1 >=10)
System.out.println(z1+":");
else
    System.out.println("0"+z1+":");

if(z2 >=10)
System.out.print(z2);
else
    System.out.print("0"+z2);

    }
    catch(IOException e)
    {
        e.printStackTrace();
    }

}}

import java.io.*;
import java.util.*;
import java.*;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Random;
import java.lang.*;

public class zad {
private static BufferedReader in;
private static StringTokenizer tok;
private static PrintWriter out;
final static boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") !=null;

public static void init() throws FileNotFoundException{
if(ONLINE_JUDGE){
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
}
else{
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("out.txt");
}
}

private static String readString() throws IOException {
while (tok == null || !tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}

private static int readInt() throws IOException {
return Integer.parseInt(readString());
}
private static double readDouble() throws IOException {
return Double.parseDouble(readString());
}
private static long readLong() throws IOException {
return Long.parseLong(readString());
}
private static float readFloat() throws IOException{
    return Float.parseFloat(readString());
}

public static class Point{

    int x;
    int num;

    Point(int x, int mum){
        this.x = x;
        num = mum;
    }
    public void Incr(){
        num++;
    }

    public int getX(){
        return x;
    }
    public int getNum(){
        return num;
    }

}

public static void Solve() throws IOException{

    String s =readString();
    String t =readString();

    String ch = "";
    if(s.startsWith("0")){
        ch+=s.charAt(1);
    }
    else
    ch+=s.charAt(0)+s.charAt(1);

    int chas = Integer.parseInt(ch);

    if(s.charAt(3)=='0'){
        ch=""+s.charAt(4);
    }
    else
    ch=""+s.charAt(3)+s.charAt(4);
    int min  = Integer.parseInt(ch);

    if(t.startsWith("0")){
        ch=""+t.charAt(1);
    }
    else
    ch=""+t.charAt(0)+t.charAt(1);

    int tchas = Integer.parseInt(ch);

    if(t.charAt(3)=='0'){
        ch=""+t.charAt(4);
    }
    else
    ch=""+t.charAt(3)+t.charAt(4);
    int tmin  = Integer.parseInt(ch);

    min-=tmin;
    if(min<0){
        min=60+min;
        chas--;
    }
    chas-=tchas;
    if(chas<0){
        chas=24+chas;
    }

    ch=""+chas;
    if(ch.length()==1){
        out.print('0');
    }
    out.print(ch);
    out.print(':');
    ch=""+min;
    if(ch.length()==1){
        out.print(0);
    }
    out.print(min);

}

public static void main(String[] args) throws IOException {
init();
Solve();

in.close();
out.close();
}
}

/**
 * Mx NINJA
 * 07:42:01 م
 * 30/01/2014
 */
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args)throws Exception  {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String s = reader.readLine();
        String t = reader.readLine();

        int sH = Integer.parseInt(s.substring(0, 2));
        int sM = Integer.parseInt(s.substring(3));

        int tH = Integer.parseInt(t.substring(0, 2));
        int tM = Integer.parseInt(t.substring(3));

        int pH = sH - tH;
        int pM = sM - tM;
        if(pH<0){
            pH = 24 + pH;
        }
        if(pM < 0){
            pM = 60 + pM;
        }
        String ph = Integer.toString(pH);
        if(ph.length() == 1){
            ph = "0"+ph;
        }
        String pm = Integer.toString(pM);
        if(pm.length() == 1){
            pm = "0"+pm;
        }
        System.out.println(ph+":"+pm);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh,int mm,int hh2 ,int mm2){
        int hhout,mmout;
        if(hh==0)hh=hh+1;
        if(hh2==0)hh2=hh2+1;

        if(hh<hh2)
            hhout=24-(hh2-hh);
        else
            hhout=hh-hh2;

        if(mm<mm2)
            mmout=(60-mm2)+mm;
        else
            mmout=mm-mm2;

        if(mm<mm2&&hh==hh2&&hh==23)hhout=23;

        String outmin=mmout+"";
        if(outmin.length()==1)outmin="0"+outmin;
        String outhours=hhout+"";
        if(outhours.length()==1)outhours="0"+outhours;

        return outhours+":"+outmin;

    }

  public static void main(String[] args) throws IOException {
  BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
  String[] test= bf.readLine().split(":");

  int hh = Integer.parseInt(test[0]);
  int mm = Integer.parseInt(test[1]);

  String[] test2= bf.readLine().split(":");

  int hh2 = Integer.parseInt(test2[0]);
  int mm2 = Integer.parseInt(test2[1]);

  //Test Using the values from the buffer zeft:
  System.out.println(Sleep(hh,mm,hh2,mm2));

 }

}

import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));                                    //(new FileReader("input.in"));
        StringBuilder out = new StringBuilder();
        StringTokenizer tk;
       // tk = new StringTokenizer(in.readLine());
        String [] ctime = in.readLine().split(":");
        String [] wtime = in.readLine().split(":");
        int sh = parseInt(ctime[0]);
        int sm = parseInt(ctime[1]);
        int wh = parseInt(wtime[0]);
        int wm = parseInt(wtime[1]);
        int h=0,m=0;

        while(true){

         wm++;
         m++;
         if(wm>59){
         wm=0;
         wh++;
         }
         if(wh>23){
         wh=0;
         }

         if(m>59){
         h++;
         m=0;
         }
         if(wh==sh&&wm==sm)
             break;
        }
        if(m<10&&h<10)
            System.out.println("0"+h+":"+"0"+m);
        else if(m<10)
            System.out.println(h+":"+"0"+m);
        else if(h<10)
            System.out.println("0"+h+":"+m);
        else System.out.println(h+":"+m);
    }

}
/*class Reader {

    static StringTokenizer tokenizer;
    static BufferedReader reader;

    public static void init(InputStream input) throws UnsupportedEncodingException {
        reader = new BufferedReader(new InputStreamReader(input, "UTF-8"));
        tokenizer = new StringTokenizer("");
    }

    public static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

    public static String nextLine() throws IOException {
        return reader.readLine();
    }

    public static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public static long nextLong() throws IOException {
        return Long.parseLong(next());
    }}*/

import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.InputStream;

public class Main {
    public static void main(String[] args) {

        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        Time solver = new Time();
        //int test = in.readInt();
        //for(int i=1; i<=test; i++)
        solver.solve(in, out);
        out.close();
    }
}

class Time {
    public void solve(InputReader in, OutputWriter out) {
        String s = in.readString();
        String t = in.readString();
        int sm=Integer.parseInt(s.substring(3,5));
        int sh=Integer.parseInt(s.substring(0,2));
        int tm=Integer.parseInt(t.substring(3,5));
        int th=Integer.parseInt(t.substring(0,2));
        int ph = (th<=sh?sh-th:24-(th-sh));
        int pm=0;
        if(tm>sm) {
            ph--;
            pm = 60-(tm-sm);
        }
        else {
            pm = sm-tm;
        }
        String p = String.valueOf(ph);
        if(ph<10) {
            p="0"+p;
        }
        p=p+":";
        if(pm<10) {
            p=p+"0"+String.valueOf(pm);
        }
        out.printLine(p);
    }

}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return isWhitespace(c);
    }

    public static boolean isWhitespace(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String next() {
        return readString();
    }
}

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object...objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object...objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class GeorgeAndSleep {
    public static void main(String[] args) {
        MyScanner sc = new MyScanner();

        String S = sc.next();
        String T = sc.next();

        char[] sArr = S.toCharArray();
        char[] tArr = T.toCharArray();

        int sHr = 10 * (sArr[0] - '0') + sArr[1] - '0';
        int sMn = 10 * (sArr[3] - '0') + sArr[4] - '0';
        int tHr = 10 * (tArr[0] - '0') + tArr[1] - '0';
        int tMn = 10 * (tArr[3] - '0') + tArr[4] - '0';

        int wHr = sHr - tHr;
        int wMn = sMn - tMn;

        wHr += wMn / 60;
        wMn = (wMn + 60) % 60;
        wHr = (wHr + 24) % 24;

        System.out.format("%02d:%02d\n", wHr, wMn);
    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        String nextLine() {
            String str = "";
            try { str = br.readLine(); }
            catch (IOException e) { e.printStackTrace(); }
            return str;
        }
    }
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class splitcheck
{

    public static void main(String []args)
    {Scanner sc=new Scanner(System.in);
      String str1=sc.next();
      String str2=sc.next();
      String ar1[]=str1.split(":");
      String ar2[]=str2.split(":");
      int arl1[]=new int[2];
      int arl2[]=new int[2];
       for (int i=0;i<2;i++)
        {arl1[i]=Integer.parseInt(ar1[i]);
         arl2[i]=Integer.parseInt(ar2[i]);

        }

            int min=arl1[0]-arl2 [0];
            int hours=arl1[1]-arl2 [1];

            if(hours<0)
            {
            if(min==0){
            min=23;
            hours+=60;}
            else
            if(min<0){
            min+=24;
            hours+=60;}
        }
            if(min<10&&hours<10)
            System.out.println("0"+min+":0"+hours);
            else if(min>10&&hours<10)
            System.out.println(min+":0"+hours);
            else if(min<10&&hours>10)
            System.out.println("0"+min+":"+hours);
            else
            System.out.println(min+":"+hours);
            }

}

import java.util.Scanner;
import java.util.StringTokenizer;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author lullaby_1412
 */
public class main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String wakeUp = sc.nextLine();
        StringTokenizer st = new StringTokenizer(wakeUp, ":");
        int hW = Integer.parseInt(st.nextToken());
        int mW = Integer.parseInt(st.nextToken());

        String time = sc.nextLine();
        st = new StringTokenizer(time, ":");
        int hT = Integer.parseInt(st.nextToken());
        int mT = Integer.parseInt(st.nextToken());

        int hS, mS;

        if (hW > hT) {
            hS = hW - hT;
            if (mW >= mT) {
                mS = mW - mT;
            } else {
                mS = 60 - (mT - mW);
            }
        } else {
            hS = 24 - (hT - hW);
            if (mW >= mT) {
                mS = mW - mT;
            } else {
                mS = 60 - (mT - mW);
            }
        }
        if(hS == 24) hS = 0;
        if(mS == 60) mS = 0;
        System.out.printf("%02d:%02d\n", hS, mS);
    }
}

import java.io.*;
public class GeorgeAndSleep {

    public static void f(String [] s,String []t){
        int min=0;
        int hrs=0;
        int min1 = Integer.parseInt(s[1]);
        int hours1 = Integer.parseInt(s[0]);

        int min2 = Integer.parseInt(t[1]);
        int hours2 = Integer.parseInt(t[0]);

        min = min1-min2;
        if(min <0){
            min = 60-min2;
            hrs--;
        }if(min==60){
            min=0;
            hrs++;
        }
        hrs += (hours1-hours2);
        if(hrs<0)
            hrs+=24;
        String x = min+"";
        if(min<10)
            x = '0'+x;
        String z = hrs+"";
        if(hrs<10)
            z = '0' +z;
        System.out.println(z+":"+x);
    }
    public static void main(String[]args)throws IOException{
        BufferedReader br = new BufferedReader (new InputStreamReader (System.in));
        String []s = br.readLine().split(":");

        String []t = br.readLine().split(":");
        f(s,t);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class CFTest103
{

	static BufferedReader br;

	public static void main(String[] args) {
		br = new BufferedReader(new InputStreamReader(System.in));

		try {

			String s1=readLine();
			String s2=readLine();

			br.close();
			String []st1=s1.split(":");
			String[]st2=s2.split(":");
			int h1=Integer.parseInt(st1[0]);
			int m1=Integer.parseInt(st1[1]);
			int h2=Integer.parseInt(st2[0]);
			int m2=Integer.parseInt(st2[1]);

			if(h2>h1){
				h1+=24;

			}

			if(h2==h1){

				if(m2>m1){
					System.out.println(pro(h1,m1,h2,m2));

				}
				else{
					int df=m1-m2;
					String s=""+df;
					if(df<10){
						s="0"+s;
					}
					System.out.println("00:"+s);
				}
			}else{
				int dh=h1-h2;
				int dm=m1-m2;
				if(dm<0){
					dm+=60;
					dh--;
				}
				String sr=""+dh;
				if(dh<10){
					sr="0"+sr;
				}
				String sr2=""+dm;
				if(dm<10){
					sr2="0"+sr2;
				}

				System.out.println(sr+":"+sr2);
			}

		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	static String pro(int h1,int m1,int h2,int m2){
		int nhr=h1+h2;
		int nm=m1+m2;
		if(nm>59){
			nm-=60;
			nhr+=1;
		}
		String s=""+nhr;
		if(nhr<10)s="0"+s;
		String s2=""+nm;
		if(nm<10)s2="0"+s2;
		return s+":"+s2;

	}

	static public String readLine() throws IOException {
		return br.readLine();

	}

	static public String readString() throws IOException {
		return br.readLine();

	}

	static public long readlong() throws IOException {
		return Long.parseLong(br.readLine());
	}

	static public int readInt() throws IOException {
		return Integer.parseInt(br.readLine());
	}

	static public int[] readIntArr() throws IOException {
		String[] str = br.readLine().split(" ");
		int arr[] = new int[str.length];
		for (int i = 0; i < arr.length; i++)
			arr[i] = Integer.parseInt(str[i]);
		return arr;
	}

	static public double[] readDoubleArr() throws IOException {
		String[] str = br.readLine().split(" ");
		double arr[] = new double[str.length];
		for (int i = 0; i < arr.length; i++)
			arr[i] = Double.parseDouble(str[i]);
		return arr;
	}

	static public long[] readLongArr() throws IOException {
		String[] str = br.readLine().split(" ");
		long arr[] = new long[str.length];
		for (int i = 0; i < arr.length; i++)
			arr[i] = Long.parseLong(str[i]);
		return arr;
	}

	static public double readDouble() throws IOException {
		return Double.parseDouble(br.readLine());
	}
}

import java.io.*;
import java.math.*;
import java.util.*;

public class Library {
	static int[] di = { 0, -1, 0, 1 };
	static int[] dj = { -1, 0, 1, 0 };

	static int[] di_knight = { -1, -1, -2, -2, 1, 1, 2, 2 };
	static int[] dj_knight = { 2, -2, -1, 1, 2, -2, -1, 1 };

	static BufferedReader br = new BufferedReader(new InputStreamReader(
			System.in));

	public static void main(String[] args) throws Exception {
		String a[] = br.readLine().split(":");
		String b[] = br.readLine().split(":");

		int s = Integer.parseInt(a[0])*60 + Integer.parseInt(a[1]);
		int t = Integer.parseInt(b[0])*60 + Integer.parseInt(b[1]);

		int dif = s-t;

		if(dif < 0){
			dif -= 60;
		}

		int h = dif/60;
		int m = Math.abs(dif%60);

		if(h < 0){
			h += 24;
		}

		if(dif < 0){
			m -= 60;
			m = Math.abs(m);
		}

		String hour = String.valueOf(h);
		String minute = String.valueOf(m);

		if(h < 10){
			hour = "0" + String.valueOf(h);
		}

		if(m < 10){
			minute = "0" + String.valueOf(m);
		}
		System.out.println(hour +  ":" + minute);
	}

	// Check if String A is smaller lexicographically than String B
	public static boolean compareStringLexicographically(String A, String B) {
		if (A == null || B == null)
			return true;

		if (B.indexOf(A) == 0)
			return true;

		for (int i = 0; i < Math.min(A.length(), B.length()); i++) {
			if (A.charAt(i) != B.charAt(i))
				return A.charAt(i) < B.charAt(i);
		}

		return A.length() < B.length();
	}

	public static int roundUp(int a, int b) {
		return (int) Math.ceil(a / (b * 1.0));
	}

	// Read Integer
	public static int readInt() throws Exception {
		return Integer.parseInt(br.readLine());
	}

	// Read Integer
	public static int readInt(String str) throws Exception {
		return Integer.parseInt(str);
	}

	// Read Integer Array
	public static int[] readIntArray() throws Exception {
		String[] s = br.readLine().split(" ");
		int arr[] = new int[s.length];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = readInt(s[i]);
		}

		return arr;
	}
}

import java.util.Scanner;

public class tim {
	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
	String s1=sc.nextLine(),s=sc.nextLine();
	int m1,h1,m2,h2;
	h1=(s.charAt(0)-48)*10+s.charAt(1)-48;
	m1=(s.charAt(3)-48)*10+s.charAt(4)-48;
	h2=(s1.charAt(0)-48)*10+s1.charAt(1)-48;
	m2=(s1.charAt(3)-48)*10+s1.charAt(4)-48;
	int h=0,m=0;
	m=m2-m1;
	if(m<0)
	{
		m=60+m;
		h=1;
	}
	h=h+(h2-h1);
	if(h<0)
	{
		h=24+h;
	}
	String gh="";
	if(h<10)
		gh=gh+"0"+h;
	else
		gh=gh+h;
	gh=gh+":";
	if(m<10)
	{
		gh=gh+"0"+m;
	}
	else
	{
		gh=gh+m;
	}
	System.out.println(gh);
	}
}

import java.io.*;
import java.math.*;
import java.util.*;

public class FirstApp {
 private static MyScanner in;
 private static PrintStream out;
 private static void solve() throws IOException
 {
	 String s= in.nextString();
	 String t= in.nextString();
	 String str1 = new StringBuilder().append(s.charAt(0)).append(s.charAt(1)).toString();
	 String str2 = new StringBuilder().append(s.charAt(3)).append(s.charAt(4)).toString();
	 String str3 = new StringBuilder().append(t.charAt(0)).append(t.charAt(1)).toString();
	 String str4 = new StringBuilder().append(t.charAt(3)).append(t.charAt(4)).toString();
	 int s1= Integer.parseInt(str1);
	 int s2= Integer.parseInt(str2);
	 int s3= Integer.parseInt(str3);
	 int s4= Integer.parseInt(str4);
	 int res1=0;
	 int res2=0;
	 if(s1-s3<0)
	 {
		 s1=24;
	 }

	 if(s2 -s4 < 0)
	 {
		 s2=60;
		 res1 =-1;
	 }

	 res1+=s1-s3;
	 res2+=s2-s4;
	 if(res1/10==0)
	 {
		 System.out.print(0);
		 System.out.print(res1);
	 }
	 else
	 {
		 System.out.print(res1);
	 }
	 System.out.print(":");
	 if(res2/10==0)
	 {
		 System.out.print(0);
		 System.out.print(res2);
	 }
	 else
	 {
		 System.out.print(res2);
	 }
}

 public static void main(String[] args) throws IOException {
	 in = new MyScanner();
	out = System.out;
  solve();
 }

 // =====================================
 static class MyScanner {
  BufferedReader bufReader;
  StringTokenizer strTok;

  public MyScanner() throws IOException
  {
   bufReader = new BufferedReader(new InputStreamReader(System.in));
   strTok = new StringTokenizer("");
  }

  String GetNextToken() throws IOException {
   if (!strTok.hasMoreTokens())
    strTok = new StringTokenizer(bufReader.readLine());
   return strTok.nextToken();
  }

  public int nextInt() throws IOException {
   return Integer.valueOf(GetNextToken());
  }
  public String nextString() throws IOException {
   return GetNextToken();
  }

 }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws NumberFormatException, IOException {

    BufferedReader r=new BufferedReader(new InputStreamReader(System.in));

StringTokenizer st;
PrintWriter pr=new PrintWriter(System.out);
st=new StringTokenizer(r.readLine(),":");
Time temp=new Time();
temp.hr=24;
temp.min=0;
Time in=new Time();
in.hr=Integer.parseInt(st.nextToken());
in.min=Integer.parseInt(st.nextToken());

st=new StringTokenizer(r.readLine(),":");
Time out=new Time();
out.hr=Integer.parseInt(st.nextToken());
out.min=Integer.parseInt(st.nextToken());

if(in.hr==0)
{
    in.hr=24;
}
if(out.hr==0)
out.hr=24;

Time diff;
if(in.hr>out.hr)
{
    diff=diff(in,out);
}
else if(in.hr<out.hr)

{
 diff=diff(out,in);
 diff=diff(temp,diff);

}
else if(in.min<out.min)
{

 diff=diff(out,in);
 diff=diff(temp,diff);

}
else
{
 diff=diff(in,out);
}

if(diff.hr==24)
    diff.hr=0;
if(diff.hr<10)
    pr.print("0"+diff.hr);
else
    pr.print(diff.hr);
pr.print(":");

if(diff.min<10)
    pr.print("0"+diff.min);
else
    pr.print(diff.min);

    pr.flush();
    pr.close();

    }

public static Time diff(Time end,Time start)
{Time diff=new Time();

    diff.min=Math.abs(end.min-start.min);
    if(start.min>end.min)
        end.hr--;
    diff.hr=end.hr-start.hr;
    return diff;

}
}

class Time
{

    int hr;
    int min;

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class JavaApplication2 {

    public static void main(String[] args) throws IOException {
        BufferedReader I = new BufferedReader(new InputStreamReader(System.in));
        String s[] = I.readLine().split(":");
        int h = Integer.parseInt(s[0]);
        int m = Integer.parseInt(s[1]);
        String t[] = I.readLine().split(":");
        int h1 = Integer.parseInt(t[0]);
        int m1 = Integer.parseInt(t[1]);
        int h2;
        int m2;
        if (h == 0) {
            h = 24;
        }

        h2 = h - h1;
        m2 = m - m1;

        if (h2 < 0) {
            h2 = 24 + h2;
        }
        if (m2 < 0) {
            h2--;
            m2 = 0 - m2;

        }
        String a = "";
        if(h2==24){
            h2=0;
        }
        if(m2==60){
            m2=0;
        }
        if (h2 < 10) {
            System.out.print("0" + h2 + ":");
        } else {
            System.out.print(h2 + ":");

        }if(m2<10){
            System.out.print("0"+m2);
        }else
            System.out.println(m2);

    }

}

//package codeforces_problem_a;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static void main(String[] args) throws IOException {
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	String[] s=br.readLine().split(":");
	int diffh,diffm,wh,wm,sh,sm;
	wh=Integer.parseInt(s[0]);
	wm=Integer.parseInt(s[1]);
	s=br.readLine().split(":");
	sh=Integer.parseInt(s[0]);
	sm=Integer.parseInt(s[1]);
	diffm=wm-sm;
	diffh=wh-sh;
	if(diffh<0)
	    diffh+=24;
	if(diffm<0){
	    diffm+=60;
	    diffh--;
	}
	System.out.printf("%02d:%02d",diffh,diffm);
	System.out.println();
    }
}

import java.util.Scanner;

public class GeorgeandSleep {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        String[] a = scan.next().split(":", -1);
        String[] b = scan.next().split(":", -1);
        int p = Integer.valueOf(a[0]);
        int q = Integer.valueOf(b[0]);
        int k = Integer.valueOf(a[1]);
        int e = Integer.valueOf(b[1]);
        int t = p * 60 + k;
        int r = q * 60 + e;
        int w = t - r;
        int r1 = w / 60;
        int r2 = w % 60;
        if (r1 < 0) {
            r1 = 24 + r1;
        }
        if (r2 < 0) {
            r2 += 60;
        }
        if(e>k){
            r1 +=23;
        }
        System.out.printf("%02d:%02d", r1, r2);
        System.out.println();
    }

}

import java.util.Scanner;

public class GeorgeAndSleep {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.next();
		String t = sc.next();
		int sH = Integer.parseInt(s.substring(0,2));
		int sM = Integer.parseInt(s.substring(3));
		int tH = Integer.parseInt(t.substring(0, 2));
		int tM = Integer.parseInt(t.substring(3));
		int resH = sH - tH;
		if(resH < 0)
			resH += 24;
		String resultH = Integer.toString(resH);
		if(resultH.length() == 1)
			resultH = "0" + resultH;
		int resM = sM - tM ;
		if(resM < 0)
			resM += 60;
		String resultM = Integer.toString(resM);
		if(resultM.length() == 1)
			resultM = "0" + resultM;
		System.out.println(resultH+":"+resultM);
		}
}

import java.io.*;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class aa {

public static void main(String[] args) {

    try{
    InputStream in = new FileInputStream ("a.txt" +
            "");
    BufferedReader br = new BufferedReader(new InputStreamReader(in));
    String input=""
;

input=br.readLine();

String[]ss;
ss= input.split(":");
int x1=Integer.parseInt(ss[0]);
int x2 = Integer.parseInt(ss[1]);
ss=br.readLine().split(":");
int y1= Integer.parseInt(ss[0]);
int y2 =Integer.parseInt(ss[1]);

int z1=0,z2=0;

if(y2>x2)
{

    z2= x2-y2;
    z2 = z2+60;

    z1 -=1;

}

else {z2= x2-y2;}

z1= z1+ (x1-y1);

if(z1<0)
    z1= 24+z1;

if(z1 >=10)
System.out.println(z1+":");
else
    System.out.println("0"+z1+":");

if(z2 >=10)
System.out.print(z2);
else
    System.out.print("0"+z2);

    }
    catch(IOException e)
    {
        e.printStackTrace();
    }

}}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class George_and_Sleep {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        String b = br.readLine();
        int h = Integer.parseInt(s.substring(0,2));
          h=(h==0)?24:h;
        int min = Integer.parseInt(s.substring(3));
        int h2 = Integer.parseInt(b.substring(0,2));
      int min2 = Integer.parseInt(b.substring(3));
      int fh = h-h2;
      fh=(fh==0)?24:fh;
      if(min2>min){
          fh=fh-1;
          min = 60+min;
      }
      int fm = min-min2;
      String ans="";
      if(fm>=60){
          fm-=60;
          fh++;
      }
      fh=Math.abs(fh);
      fh=(fh==24)?0:fh;
      if(fh<=9)
          ans+="0"+fh;
      else
          ans+=fh;
      ans+=":";
      if(fm<=9)
          ans+="0"+fm;
      else
          ans+=fm;
System.out.println(ans);

    }

}

import java.util.*;
import java.text.DecimalFormat;
public class Obe {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String s=in.next();String s2=in.next();
            DecimalFormat d=new DecimalFormat("00.00");
            double time=(Double.parseDouble(s.replace(":", "."))-Double.parseDouble(s2.replace(":", ".")));
    String s3=d.format(time);
    int h = Integer.parseInt((s3.charAt(s3.length()-2)+""+s3.charAt(s3.length()-1)));
    int a = Integer.parseInt((s.charAt(s.length()-2)+""+s.charAt(s.length()-1)));
    int b = Integer.parseInt((s2.charAt(s2.length()-2)+""+s2.charAt(s2.length()-1)));
               System.out.println(time>=0?s3.replace(".", ":"):(h)!=0&&(a<b)&&Double.parseDouble(s.replace(":", "."))<Double.parseDouble(s2.replace(":", "."))?d.format((time+24.00)-0.40).replace(".", ":"):d.format((time+24.00)).replace(".", ":"));
    }

}

import java.util.*;
import java.lang.*;
import java.io.*;
import java.text.*;

public class NewMain51 {

    public static void main(String[] args) throws java.lang.Exception {

        Scanner s = new Scanner(System.in);

        String dateStart = s.next();
        String dateStop = s.next();

        if (dateStart.startsWith("00")) {
            dateStart = "24:" + dateStart.substring(3);
        }

        //HH converts hour in 24 hours format (0-23), day calculation
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");

        Date d1 = null;
        Date d2 = null;

        try {
            d1 = format.parse(dateStart);
            d2 = format.parse(dateStop);

            //in milliseconds
            long diff = d2.getTime() - d1.getTime();

            long diffSeconds = diff / 1000 % 60;
            long diffMinutes = diff / (60 * 1000) % 60;
            long diffHours = diff / (60 * 60 * 1000) % 24;
            long diffDays = diff / (24 * 60 * 60 * 1000);

            String a = Math.abs(diffMinutes) < 10 ? "0" : "";
            String b = Math.abs(diffHours) < 10 ? "0" : "";
            System.out.print(b + Math.abs(diffHours) + ":" + a + Math.abs(diffMinutes));

        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("");
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh,int mm,int hh2 ,int mm2){
        int hhout,mmout;
        if(hh==0)hh=hh+1;
        if(hh2==0)hh2=hh2+1;

        if(hh<hh2)
            hhout=24-(hh2-hh);
        else
            hhout=hh-hh2;

        if(mm<mm2)
            mmout=(60-mm2)+mm;
        else
            mmout=mm-mm2;

        if(mm<mm2&&hh==hh2&&hh==23)hhout=23;

        String outmin=mmout+"";
        if(outmin.length()==1)outmin="0"+outmin;
        String outhours=hhout+"";
        if(outhours.length()==1)outhours="0"+outhours;

        return outhours+":"+outmin;

    }

  public static void main(String[] args) throws IOException {
  BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
  String[] test= bf.readLine().split(":");

  int hh = Integer.parseInt(test[0]);
  int mm = Integer.parseInt(test[1]);

  String[] test2= bf.readLine().split(":");

  int hh2 = Integer.parseInt(test2[0]);
  int mm2 = Integer.parseInt(test2[1]);

  //Test Using the values from the buffer zeft:
  System.out.println(Sleep(hh,mm,hh2,mm2));

 }

}

import java.util.*;

public class Main
{
      public static void main(String args[])
      {
            Scanner sc = new Scanner(System.in);
            String s=sc.next(),h=sc.next();
            int h1=Integer.parseInt(s.substring(0, 2));
            int min1=Integer.parseInt(s.substring(3, 5));
            int h2=Integer.parseInt(h.substring(0, 2));
            int min2=Integer.parseInt(h.substring(3, 5));

            int hf=0, minf=0;
            if(min1-min2<0)
            {
                  minf = 60+min1-min2;
                  hf += -1;
            }
            else if(min1-min2>0)
            {
                  minf = min1-min2;
            }

            if(h1-h2<0)
            {
                  hf += h1-h2+24;
            }
            else
                  hf += h1-h2;

            if(hf<10)
            {
                  System.out.print("0"+hf+":");
            }
            else
                  System.out.print(hf+":");

            if(minf<10)
            {
                  System.out.print("0"+minf);
            }
            else
                  System.out.print(hf);
      }
}

import java.util.Scanner;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        String s = in.next();
        String t = in.next();
        String []e = s.split("[:]");
        String []to = t.split("[:]");
        int eh = Integer.parseInt(e[0]) - Integer.parseInt(to[0]);
        int em = Integer.parseInt(e[1]) - Integer.parseInt(to[1]);
        eh = (eh + 24) % 24;
        em = (em + 60) % 60;
        if (eh < 10){
            out.print("0"+eh+":");
        }
        else {
            out.print(eh+":");
        }
        if (em < 10){
            out.print("0"+em);
        }
        else {
            out.print(em);
        }
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

}

import java.util.*;
import java.io.*;

public class A implements Runnable {

	public void solve() throws IOException {
		String[] one = nextToken().split(":");
                String[] two = nextToken().split(":");
                int hr1 = Integer.parseInt(one[0]);
                int mn1 = Integer.parseInt(one[1]);
                int hr2 = Integer.parseInt(two[0]);
                int mn2 = Integer.parseInt(two[1]);

                for(int i = 0; i < 24; i++)
                        for(int j = 0; j < 60; j++){
                                if((hr2 + i) % 24 == hr1 && (mn2 + j) % 60 == mn1){
                                        System.out.printf("%02d:%02d\n", i, j);

                                }
                        }
        }

	//-----------------------------------------------------------
	public static void main(String[] args) {
		new A().run();
	}

        public void print1Int(int[] a){
                for(int i = 0; i < a.length; i++)
                        System.out.print(a[i] + " ");
                System.out.println();
        }

        public void print2Int(int[][] a){
                for(int i = 0; i < a.length; i++){
                        for(int j = 0; j < a[0].length; j++){
                                System.out.print(a[i][j] + " ");
                        }
                        System.out.println();
                }
        }

	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			tok = null;
			solve();
			in.close();
		} catch (IOException e) {
			System.exit(0);
		}
	}

	public String nextToken() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	BufferedReader in;
	StringTokenizer tok;
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 *
 * @author Ahmed
 */
public class AGeorgeAndSleep {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String one[] = b.readLine().split(":");
String two[] = b.readLine().split(":");

int h1=Integer.parseInt(one[0]);
int m1=Integer.parseInt(one[1]);
int h2=Integer.parseInt(two[0]);
int m2=Integer.parseInt(two[1]);

if(m1 >= 0 && m1 <=59 && m2 >= 0 && m2 <=59  && h1 >= 0 && h1 <=23 && h2 >= 0 && h2 <=23){
if (h1 == 00 )

    h1=24;

if (h2 == 00 )

    h2=24;
String hour=(h1-h2)+"";
String min=(m1-m2)+"";
String hourNew=hour;
String minNew=min;
if (hour.length()==1)
    hourNew="0"+hour;
if (min.length()==1)
    minNew="0"+min;

    System.out.println(hourNew+":"+minNew);

}
    }
}

import java.io.*;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class aa {

public static void main(String[] args) {

    try{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String input=""
;

input=br.readLine();

String[]ss;
ss= input.split(":");
int x1=Integer.parseInt(ss[0]);
int x2 = Integer.parseInt(ss[1]);
ss=br.readLine().split(":");
int y1= Integer.parseInt(ss[0]);
int y2 =Integer.parseInt(ss[1]);

int z1=0,z2=0;

if(y2>x2)
{

    z2= x2-y2;
    z2 = z2+60;

    z1 -=1;

}

else {z2= x2-y2;}

z1= z1+ (x1-y1);

if(z1<0)
    z1= 24+z1;

if(z1 >=10)
System.out.println(z1+":");
else
    System.out.println("0"+z1+":");

if(z2 >=10)
System.out.print(z2);
else
    System.out.print("0"+z2);

    }
    catch(IOException e)
    {
        e.printStackTrace();
    }

}}

import java.util.Scanner;

public class Codeforce{

	public static void main(String[] arg){
		Scanner sc = new Scanner(System.in);
		String wakeUpTime = sc.nextLine();
		String gotoBedTime = sc.nextLine();
		String result = "";
		boolean takeone = false;
		int wakeUpHour = (wakeUpTime.charAt(0) - '0')*10 + (wakeUpTime.charAt(1) - '0');
		int gotoBedHour =(gotoBedTime.charAt(0) - '0')*10 + (gotoBedTime.charAt(1) - '0');
		int wakeUpMin = (wakeUpTime.charAt(3) - '0')*10 + (wakeUpTime.charAt(4) - '0');
		int gotoBedMin = (gotoBedTime.charAt(3) - '0')*10 + (gotoBedTime.charAt(4) - '0');

		if (wakeUpMin >= gotoBedMin)
			result = (wakeUpMin - gotoBedMin) + result;
		else{
			result = (gotoBedMin - wakeUpMin) + result;
			takeone = true;
		}
		if (result.length() == 1)
			result = ":0" + result;
		else
			result = ':' + result;

		if (wakeUpHour == 0)
			wakeUpHour = 24;

		if (gotoBedHour == 0)
			gotoBedHour = 24;

		if (takeone){
			if (wakeUpHour > gotoBedHour)
				result = (wakeUpHour - 1 - gotoBedHour) + result;
			else
				result = (gotoBedHour -1 - wakeUpHour) + result;
		}
		else{
			if (wakeUpHour >= gotoBedHour)
				result = (wakeUpHour - gotoBedHour) + result;
			else
				result = (gotoBedHour - wakeUpHour) + result;
		}
		if (result.length() == 4)
			result = '0' + result;

		sc.close();
		System.out.println(result);

	}

}

import java.io.*;

public class probA
{
	public static void main (String [] args) throws IOException
	{
		BufferedReader br = new BufferedReader (new InputStreamReader (System.in));
		PrintWriter out = new PrintWriter (System.out);

		String x = br.readLine(), x1 = br.readLine();
		int h1 = Integer.parseInt(x.substring(0, 2)), m1 = Integer.parseInt(x.substring(3, 5)), h2 = Integer.parseInt(x1.substring(0, 2)), m2 = Integer.parseInt(x1.substring(3, 5));
		int h = (h1 - h2) < 0 ? 24 + (h1 - h2) : h1 - h2, m = (m1 - m2) < 0 ? 60 + (m1 - m2) : m1 - m2;
		out.println((h < 10 ? "0" + h : h) + ":" + (m < 10 ? "0" + m : m));
		out.close();
	}
}

 import java.util.Scanner;

 public class time{
   public static void main(String[] args){
     Scanner in = new Scanner(System.in);

     int time1hrs =0; //in.nextInt();
     int time1mins =0; //in.nextInt();
     int time2hrs = 0;//in.nextInt();
     int time2mins = 0;//in.nextInt();
     String time1 = in.nextLine();
     String time2 = in.nextLine();
     String[] time1s = time1.split(":");
     String[] time2s = time2.split(":");
     time1hrs = Integer.valueOf(time1s[0]);
     time1mins = Integer.valueOf(time1s[1]);

     time2hrs = Integer.valueOf(time2s[0]);
     time2mins = Integer.valueOf(time2s[1]);

     int reshrs = 0;
     int resmins = 0;
     int temp = 0; //временная переменная
     int temp2 = 0;

    if (time1mins - time2mins > 0 && time1hrs == time2hrs){
       System.out.print("00:");
       if (time1mins - time2mins < 10) System.out.print("0");

       System.out.print(time1mins-time2mins);
       System.exit(0);
     }

     if (time1hrs-time2hrs == 0 && time1mins - time2mins == 0){
       System.out.println("00:00");
     }

    /* if (time1mins < time2mins){
       temp = time1mins;
       temp2 = 60 - time2mins;
       resmins = temp + temp2;
     }*/

     if (time1hrs == 0) time1hrs = 24;
     if (time2hrs == 0) time2hrs= 24;
     temp = time1hrs * 60 + time1mins;
     temp2 = time2hrs * 60 + time2mins;

     double res = (Math.max(temp,temp2) - Math.min(temp,temp2));
     reshrs = (int)(res/60);
     resmins = (int)(res % 60);
     System.out.printf("%d:",reshrs);
     if (resmins < 10) System.out.print("0");
     System.out.print(resmins);
   }
 }

import com.sun.accessibility.internal.resources.accessibility;
import org.omg.DynamicAny._DynArrayStub;
import sun.net.www.content.audio.basic;

import java.lang.reflect.Array;
import java.util.*;

/**
 * Created by root on 7/14/14.
 */
public  class test {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        String s = sc.next();
        String t = sc.next();

        int hour_waken = Integer.parseInt(s.substring(0, 2));
        int minute_waken = Integer.parseInt(s.substring(3));

        int hour_slept = Integer.parseInt(t.substring(0, 2));
        int minute_slept = Integer.parseInt(t.substring(3));

        int result_hour = hour_waken - hour_slept;
        int result_minute = minute_waken - minute_slept;
        if(result_hour < 0){
            result_hour = 24 + result_hour;
        }

        if(result_minute < 0){
            result_minute = 60 + result_minute;
            result_hour--;
        }

        String result_string = "";

        String hour = ""+result_hour;
        String minute = ""+result_minute;

        if(hour.length() == 1){
            hour = "0"+hour;
        }

        if(minute.length() == 1){
            minute = "0"+minute;
        }

        result_string = hour+":"+minute;
        System.out.println(result_string);

    }

}

import java.util.*;
public class four {

	public static int[] parse(String s){
		int[] a=new int [2];
		// gets the hour
		if(s.charAt(0)=='0')
			a[0]=(int) (s.charAt(1)-'0');
		else{
			a[0]= 10*((int) (s.charAt(0)-'0'));
			a[0]+=(int) (s.charAt(1)-'0');
		}

		if(s.charAt(3)=='0')
			a[1]=(int) (s.charAt(4)-'0');
		else{
			a[1]= 10*((int)(s.charAt(3)-'0'));
			a[1]+=(int) (s.charAt(4)-'0');
		}

		return a;
	}

	public static int[] calc(int[] a, int[] b){
		int[] c=new int[2];
		if(b[0]==0 && b[1]==0)
			c=a;
		else{
			if(a[0]<b[0]){
				c[0]=24-(b[0]-a[0]);
				if(a[1]<b[1])
					c[1]=60-(b[1]-a[1]);
				else
					c[1]=a[1]-b[1];
			}
			else{
				if(a[1]< b[1]){
					c[0]=a[0]-b[0]-1;
					c[1]=60-(b[1]-a[1]);
				}
				else
				{
					c[0]=a[0]- b[0];
					c[1]=a[1]-b[1];
				}
			}
		}
		if(a[0]==b[0]){
			//c[0]=0;
			if(a[1]< b[1]){
				c[0]=23;
				c[1]=60-(b[1]-a[1]);
			}
			else
			{
				c[0]=0;
				c[1]=a[1]-b[1];
			}

		}
		return c;
	}

	public static void print(int[] n){
		if(n[0]<10)
			System.out.print("0"+n[0]);
		else
			System.out.print(n[0]);

		System.out.print(":");

		if(n[1]<10)
			System.out.print("0"+n[1]);
		else
			System.out.println(n[1]);
	}

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		String current=new String(in.next());
		String spent=new String (in.next());

		int [] aspent= parse(spent);
		int [] acurrent = parse(current);
		//System.out.println("spent[0]: "+ aspent[0]+"\n"+"spent[1]: "+aspent[1]+"\n");
		int [] result=calc(acurrent, aspent);
		print(result);
		//print(aspent);

	}

}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
Scanner input = new Scanner(System.in);
    String s = input.nextLine();
    String t = input.nextLine();
    int x = (s.charAt(0)-'0')*10+(s.charAt(1)-'0');
    int y = (s.charAt(3)-'0')*10+(s.charAt(4)-'0');

    int x1 = (t.charAt(0)-'0')*10+(t.charAt(1)-'0');
    int y1 = (t.charAt(3)-'0')*10+(t.charAt(4)-'0');
    int r = x-x1;
    int l = y-y1;
    if(r<0)r+=24;
    if(l<0){
        l+=60;
        r--;
    }
    if(r<9){
        System.out.print("0"+r+":");
    }else System.out.print(r+":");

    if(l<9){
        System.out.println("0"+l);
    }else System.out.println(l);
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class George_and_Sleep {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        String b = br.readLine();
        int h = Integer.parseInt(s.substring(0,2));
          h=(h==0)?24:h;
        int min = Integer.parseInt(s.substring(3));
        int h2 = Integer.parseInt(b.substring(0,2));
      int min2 = Integer.parseInt(b.substring(3));
      int fh = h-h2;
      fh=(fh==0)?24:fh;
      if(min2>min){
          fh=fh-1;
          min = 60+min;
      }
      int fm = min-min2;
      String ans="";
      if(fm>=60){
          fm-=60;
          fh++;
      }
      fh=Math.abs(fh);
      fh=(fh==24)?0:fh;
      if(fh<=9)
          ans+="0"+fh;
      else
          ans+=fh;
      ans+=":";
      if(fm<=9)
          ans+="0"+fm;
      else
          ans+=fm;
System.out.println(ans);

    }

}

import java.util.Random;
import java.util.*;
public class Programa {
	  //System.out.println(ans);
	  public static int gcd(int a,int b){
		if(a == 0)
			return b;
		return gcd(b % a, a);
	  }
	  public static int sumDig(int n){
		String num = n +"";
		int suma = 0;
		for(int i = 0; i < num.length(); i++){
			suma += num.charAt(i)- '0';
		}
		return suma;
	  }

	  public static boolean isLucky(int n){
		  String num = n + "";
		  for(int i = 0; i < num.length(); i++){
			if(num.charAt(i) != '4' && num.charAt(i) != '7') return false;
		  }
		  return true;
	  }
      public static void main(String arg[]){
		Scanner scan = new Scanner(System.in);
		String s = scan.next();
		String t = scan.next();
		String [] ss = s.split(":");
		String [] tt = t.split(":");
		int [] ssi = {Integer.parseInt(ss[0]),Integer.parseInt(ss[1])};
		int [] tti = {Integer.parseInt(tt[0]),Integer.parseInt(tt[1])};
		int hh = 0; int mm = 0;
		if( (ssi[0] - tti[0]) < 0){
			hh = 24 +( ssi[0] - tti[0]);
		}
		else{
			hh = (ssi[0] - tti[0]);
		}
		if( (ssi[1] - tti[1]) < 0){
			mm = 60 +( ssi[1] - tti[1]);
		}
		else{
			mm= (ssi[1] - tti[1]);
		}
		String hha = hh+"";
		String mma = mm+"";
		if(hha.length() == 1) hha = "0"+hha;
		if(mma.length() == 1) mma = "0"+mma;
		System.out.println(hha+":"+mma);
	  }

}

/*
 *

*/

/*
 *
 *
 *
 int k = scan.nextInt();
		int [] v = new int [27];
		String s = scan.next();
		for(int i = 0; i < s.length(); i++){

			int index =  s.charAt(i) - 'a';
			v[index] += 1;
		}
		boolean flag = true; StringBuilder r = new StringBuilder();
		for(int i = 0; i < v.length; i++){
			if(v[i] != 0 ){
				if(v[i] % k == 0){
					continue;
				}
				else{
					flag = false;
					break;
				}
			}

		}
		if(flag){

			for(int i = 0; i < k; i++){
				for(int j = 0; j < 27; j++){
					if(v[j] != 0){
						r.append(Character.toChars(j+'a'));
						v[j] -= 1;
					}
				}
			}
			System.out.println(r.toString());
		}
		else System.out.println(-1);
		* */
/*
5 10
3 90
12 0
9 70
5 50
7 0

Output

50

System.out.println("");
		  for(int i = 0; i < ic; i++){
			System.out.print(sum[i]+" ");
		  }
			*/

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class GeorgeAndSleep {
    public static void main(String asd[])throws Exception
    {
        BufferedReader dd=new BufferedReader(new InputStreamReader(System.in));
        String s[]=dd.readLine().split(":");
        int sh=Integer.parseInt(s[0]);
        int sm=Integer.parseInt(s[1]);
        String t[]=dd.readLine().split(":");
        int th=Integer.parseInt(t[0]);
        int tm=Integer.parseInt(t[1]);
       int h=0,m=0;
        if(sh>=th)
        {
           h=sh-th;
          m=(int)Math.abs(tm-sm);
        }
        else
        {
             h=24-th+sh;

             m=(int)Math.abs(tm-sm);
        }
       String rh="",rm="";
       if(h>=10)
       {
           rh=Integer.toString(h);
       }
       else
           rh="0"+Integer.toString(h);
       if(m>=10)
           rm=Integer.toString(m);
       else
          rm="0"+Integer.toString(m);
       System.out.println(rh+":"+rm);
    }
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class splitcheck
{

    public static void main(String []args)
    {Scanner sc=new Scanner(System.in);
      String str1=sc.next();
      String str2=sc.next();
      String ar1[]=str1.split(":");
      String ar2[]=str2.split(":");
      int arl1[]=new int[2];
      int arl2[]=new int[2];
       for (int i=0;i<2;i++)
        {arl1[i]=Integer.parseInt(ar1[i]);
         arl2[i]=Integer.parseInt(ar2[i]);

        }

            int min=arl1[0]-arl2 [0];
            int hours=arl1[1]-arl2 [1];

            if(min<0)
            min+=24;
            if(hours<0)
            hours+=60;

            if(min<10&&hours<10)
            System.out.println("0"+min+":0"+hours);
            else if(min>10&&hours<10)
            System.out.println(min+":0"+hours);
            else if(min<10&&hours>10)
            System.out.println("0"+min+":"+hours);
            else
            System.out.println(min+":"+hours);
            }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class JavaApplication2 {

    public static void main(String[] args) throws IOException {
        BufferedReader I = new BufferedReader(new InputStreamReader(System.in));
        String s[] = I.readLine().split(":");
        int h = Integer.parseInt(s[0]);
        int m = Integer.parseInt(s[1]);
        String t[] = I.readLine().split(":");
        int h1 = Integer.parseInt(t[0]);
        int m1 = Integer.parseInt(t[1]);
        int h2;
        int m2;
        if (h == 0) {
            h = 24;
        }

        h2 = h - h1;
        m2 = m - m1;

        if (h2 < 0) {
            h2 = 24 + h2;
        }
        if (m2 < 0) {
            h2--;
            m2 = 60 + m2;

        }
        String a = "";
        if(h2==24){
            h2=0;
        }
        if(m2==60){
            m2=0;
        }
        if (h2 < 10) {
            System.out.print("0" + h2 + ":");
        } else {
            System.out.print(h2 + ":");

        }if(m2<10){
            System.out.print("0"+m2);
        }else
            System.out.println(m2);

    }

}

import java.util.Scanner;

public class Main {
    public static void main (String [] args ){
        Scanner usrInput = new Scanner(System.in );
        String s , t , temp="" , temp2;
        int diff1 , diff2 ;
        s = usrInput.nextLine();
        t = usrInput.nextLine();

        diff1= Integer.parseInt(s.substring(0, 2)) - Integer.parseInt(t.substring(0, 2))  ;
        diff2= Integer.parseInt(s.substring(3 , 5)) - Integer.parseInt(t.substring(3, 5)) ;

        if (diff1 < 0 ){
            diff1+=24 ;
        }

        if (diff2 < 0 ){
            diff2+=60;
        }

        temp+= diff1+":"+diff2;

        if (temp.length() == 3 ){
            temp=0+temp;
            temp = temp.substring(0, 2)+":"+0+temp.substring(3, 4);
        }else if (temp.length() == 4){
            int index = temp.indexOf(":");
            if (index % 2 != 0 ){
                temp=0+temp;
            }else {
                temp = temp.substring(0, 2)+":"+0+temp.substring(3, 4);
            }
        }
        System.out.println(temp);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class GeorgeandSleep {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		try {
			String input = br.readLine();
			String d[] = input.split(":");
			int h = Integer.parseInt(d[0]);
			int m = Integer.parseInt(d[1]);

			input = br.readLine();
			d = input.split(":");
			int hs = Integer.parseInt(d[0]);
			int ms = Integer.parseInt(d[1]);
			int H=0;
			int M=0;
			M=m-ms;
			boolean mn=false;
			if(M<0){
				mn=true;
			}
			if(h-hs<0){
				H=24+h-hs;
			}else{
				H=h-hs;
			}
			if(mn){
				H--;
				M+=60;
			}
			if(H<10){
				System.out.print("0"+H+":");
			}else{
				System.out.print(H+":");
			}
			if(M<10){
				System.out.print("0"+M);
			}else{
				System.out.print(M);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}

import java.io.*;
import java.util.*;

public class Smile {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		String w1 = in.nextLine();
		String w2 = in.nextLine();
		int h1 = 10 * (w1.charAt(0) - '0') + (w1.charAt(1) - '0');
		int h2 = 10 * (w2.charAt(0) - '0') + (w2.charAt(1) - '0');
		int t1 = 10 * (w1.charAt(3) - '0') + (w1.charAt(4) - '0');
		int t2 = 10 * (w2.charAt(3) - '0') + (w2.charAt(4) - '0');
		int h3 = 0;
		int t3 = 0;
		if (h1 > h2 || (h1 == h2 && t1 >= t2)) {
			if (t1 >= t2) {
				h3 = h1 - h2;
				t3 = t1 - t2;
			} else {
				h3 = h1 - h2 - 1;
				t3 = t1 + 60 - t2;
			}
		} else {
			h3 = (24 - h2) % 24 + h1;
			t3 = (60 - t2) % 60 + t1;
			if (t3 >= 60) {
				t3 = t3 % 60;
				h3 += 1;
			}
		}
		if (h3 > 9) {
			out.print(h3 + ":");
		} else {
			out.print("0" + h3 + ":");
		}
		if (t3 > 9) {
			out.print(t3 );
		} else {
			out.print("0" + t3);
		}
		out.close();
	}
}

import java.util.Scanner;

/**
 * Created by peter.bykov on 19.05.2014.
 */
public class Archive387A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String[] now = s.nextLine().split(":");
        String[] sleepTime = s.nextLine().split(":");
        int hours = Integer.parseInt(now[0]) - Integer.parseInt(sleepTime[0]);
        if(hours < 0) {
            hours = 24 + hours;
        }
        int minutes = Integer.parseInt(now[1]) - Integer.parseInt(sleepTime[1]);
        if(minutes < 0) {
            if(hours > 0) {
                --hours;
            } else {
                hours = 23;
            }
            minutes = 60 + minutes;
        }
        System.out.println(((hours>10)?hours:"0"+hours) + ":" + ((minutes>10)?minutes:"0"+minutes));

    }
}

import java.util.*;
import java.text.DecimalFormat;
public class Obe {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String s=in.next();String s2=in.next();
            DecimalFormat d=new DecimalFormat("00.00");
            double time=(Double.parseDouble(s.replace(":", "."))-Double.parseDouble(s2.replace(":", ".")));
    String s3=d.format(time);
    int h = Integer.parseInt((s3.charAt(s3.length()-2)+""+s3.charAt(s3.length()-1)));
    int a = Integer.parseInt((s.charAt(s.length()-2)+""+s.charAt(s.length()-1)));
    int b = Integer.parseInt((s2.charAt(s2.length()-2)+""+s2.charAt(s2.length()-1)));
               System.out.println(time>=0?s3.replace(".", ":"):(h)!=0&&(a<b)?d.format((time+24.00)-0.40).replace(".", ":"):d.format((time+24.00)).replace(".", ":"));
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh, int mm, int hh2, int mm2) {
        int hhr, mmr = 0;

        if (hh == 0)
            hh = 24;

        mmr = mm - mm2;

        hhr = hh - hh2;

        if (mmr < 0) {
            mmr = 60 - mmr;
            hhr--;
        }

        if (hhr == 24)
            hhr = 0;

        String res = (hhr == 24) ? "00:" : (hhr <= 9) ? "0" + hhr + ":" : hhr
                + ":";

        res += (mmr == 0) ? "00" : (mmr <= 9) ? "0" + mmr : mmr;

        return res;

    }

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] test = bf.readLine().split(":");

        int hh = Integer.parseInt(test[0]);
        int mm = Integer.parseInt(test[1]);

        String[] test2 = bf.readLine().split(":");

        int hh2 = Integer.parseInt(test2[0]);
        int mm2 = Integer.parseInt(test2[1]);

        System.out.println(Sleep(hh, mm, hh2, mm2));

    }
}

import java.util.*;
import java.io.*;

public class A387 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        final int mod = 24*60;
        int ot = 0,nt = 0,tmp = 0;
        String[] buf;

        buf = in.next().split(":");
        ot  = Integer.parseInt(buf[0])*24;
        ot += Integer.parseInt(buf[1]);

        buf = in.next().split(":");
        nt  = Integer.parseInt(buf[0])*24;
        nt += Integer.parseInt(buf[1]);

        tmp = ((ot-nt)+mod)%mod;
        System.out.printf("%02d:%02d\n",tmp/60,tmp%60);
    }

}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class GeorgeAndSleep {
    public static void main(String asd[])throws Exception
    {
        BufferedReader dd=new BufferedReader(new InputStreamReader(System.in));
        String s[]=dd.readLine().split(":");
        int sh=Integer.parseInt(s[0]);
        int sm=Integer.parseInt(s[1]);
        String t[]=dd.readLine().split(":");
        int th=Integer.parseInt(t[0]);
        int tm=Integer.parseInt(t[1]);
       int h=0,m=0;
        if(sh==th && sm<tm)
        {
            h=23;
            m=60-tm+sm;
        }
        else if(sh==th && sm>=tm)
        {
            h=0;
            m=sm-tm;
        }
        else if(sh>th)
        {
            int g=sh-th;
            g-=1;
            int y=60-tm+sm;
            if(y>=60)
            {
                g+=1;
                y=60-y;
            }
            h=g;
          m=y;
        }
        else
        {
              int g=sh+24-th;
            g-=1;
            int y=60-tm+sm;
            if(y>=60)
            {
                g+=1;
                y=60-y;
            }
            h=g;
          m=y;
        }

       String rh="",rm="";
       if(h>=10)
       {
           rh=Integer.toString(h);
       }
       else
           rh="0"+Integer.toString(h);
       if(m>=10)
           rm=Integer.toString(m);
       else
          rm="0"+Integer.toString(m);
       System.out.println(rh+":"+rm);
    }
}

 import java.util.Scanner;

 public class time{
   public static void main(String[] args){
     Scanner in = new Scanner(System.in);

     int time1hrs =0; //in.nextInt();
     int time1mins =0; //in.nextInt();
     int time2hrs = 0;//in.nextInt();
     int time2mins = 0;//in.nextInt();
     String time1 = in.nextLine();
     String time2 = in.nextLine();
     String[] time1s = time1.split(":");
     String[] time2s = time2.split(":");
     time1hrs = Integer.valueOf(time1s[0]);
     time1mins = Integer.valueOf(time1s[1]);

     time2hrs = Integer.valueOf(time2s[0]);
     time2mins = Integer.valueOf(time2s[1]);

     int reshrs = 0;
     int resmins = 0;
     int temp = 0; //временная переменная
     int temp2 = 0;

    if (time1mins - time2mins > 0 && time1hrs == time2hrs){
       System.out.print("00:");
       if (time1mins - time2mins < 10) System.out.print("0");

       System.out.print(time1mins-time2mins);
       System.exit(0);
     }

     if (time1hrs-time2hrs == 0 && time1mins - time2mins == 0){
       System.out.println("00:00");
       System.exit(0);
     }

    /* if (time1mins < time2mins){
       temp = time1mins;
       temp2 = 60 - time2mins;
       resmins = temp + temp2;
     }*/

     if (time1hrs == 0) time1hrs = 24;
     if (time2hrs == 0) time2hrs= 24;
     temp = time1hrs * 60 + time1mins;
     temp2 = time2hrs * 60 + time2mins;

     double res = (Math.max(temp,temp2) - Math.min(temp,temp2));
     reshrs = (int)(res/60);
     resmins = (int)(res % 60);
     System.out.printf("%d:",reshrs);
     if (resmins < 10) System.out.print("0");
     System.out.print(resmins);
   }
 }

import java.util.Scanner;

public class Codeforce{

	public static void main(String[] arg){
		Scanner sc = new Scanner(System.in);
		String wakeUpTime = sc.nextLine();
		String gotoBedTime = sc.nextLine();
		String result = "";
		boolean takeone = false;
		int wakeUpHour = (wakeUpTime.charAt(0) - '0')*10 + (wakeUpTime.charAt(1) - '0');
		int gotoBedHour =(gotoBedTime.charAt(0) - '0')*10 + (gotoBedTime.charAt(1) - '0');
		int wakeUpMin = (wakeUpTime.charAt(3) - '0')*10 + (wakeUpTime.charAt(4) - '0');
		int gotoBedMin = (gotoBedTime.charAt(3) - '0')*10 + (gotoBedTime.charAt(4) - '0');

		if (wakeUpHour == 0)
			wakeUpHour = 24;

		if (gotoBedHour == 0)
			gotoBedHour = 24;

		if (wakeUpMin >= gotoBedMin)
			result = (wakeUpMin - gotoBedMin) + result;
		else{
			if (wakeUpMin == 0){
				wakeUpMin = 60;
				result = (wakeUpMin - gotoBedMin) + result;
				takeone = true;
			}
			else{
				result = (60 - gotoBedMin + wakeUpMin) + result;
				takeone = true;
			}
		}
		if (result.length() == 1)
			result = ":0" + result;
		else
			result = ':' + result;

		if (takeone){
			if (wakeUpHour > gotoBedHour)
				result = (wakeUpHour - 1 - gotoBedHour) + result;
			else
				result = (gotoBedHour -1 - wakeUpHour) + result;
		}
		else{
			if (wakeUpHour >= gotoBedHour)
				result = (wakeUpHour - gotoBedHour) + result;
			else
				result = (24 - gotoBedHour + wakeUpHour) + result;
		}
		if (result.length() == 4)
			result = '0' + result;

		sc.close();
		System.out.println(result);

	}

}

import java.util.Scanner;

public class GeorgeAndSleep {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);
		String currentTime = input.next();
		String sleepDuration = input.next();
		int currentHour = Integer.parseInt(currentTime.charAt(0) + "" + currentTime.charAt(1));
		int currentMin = Integer.parseInt(currentTime.charAt(3) + "" + currentTime.charAt(4));
		int sleepHour = Integer.parseInt(sleepDuration.charAt(0) + "" + sleepDuration.charAt(1));
		int sleepMin = Integer.parseInt(sleepDuration.charAt(4) + "" + sleepDuration.charAt(4));
		int rem = 0;
		int startHour = 0;
		int startMin = 0;

		if (currentMin >= sleepMin)
			startMin = currentMin - sleepMin;
		else {
			startMin = 60 + currentMin - sleepMin;
			rem = 1;
		}

		startHour = currentHour - sleepHour - rem;
		if (startHour < 0)
			startHour += 24;

		System.out.printf(addZero(startHour) + ":" + addZero(startMin));
		System.out.println();
	}

	public static String addZero(int n) {
		if(n < 10)
			return "0" + n;
		else
			return "" + n;
	}
}

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;
public class A227 {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		String x = s.next();
		String y = s.next();
		DateFormat f = new SimpleDateFormat("hh:mm");
		Date d1 = null;
		Date d2 = null;
		try {
			d1 = f.parse(x);
			d2 = f.parse(y);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		s.close();

		long diff = d1.getTime() - d2.getTime();
		long hh = diff / (1000 * 60 * 60) % 24;
		long mm = diff / (1000 * 60) % 60;

		if(hh<0) hh = 24 + hh;

		if(hh == 0) System.out.print("00");
		else if(hh < 10) System.out.print("0"+hh);
		else System.out.print(hh);
		System.out.print(":");
		if(mm == 0) System.out.print("00");
		else if(mm < 10) System.out.print("0"+mm);
		else System.out.print(mm);
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class CF387A {
    public static void main(String[] args) {
        FastReader input = new FastReader();
        PrintWriter pw = new PrintWriter(System.out);

        String wake = input.nextLine();
        String duration = input.nextLine();

        String s1 = wake.substring(0,2);
        String s2 = wake.substring(3,5);

        String s3 = duration.substring(0,2);
        String s4 = duration.substring(3,5);

        int h1 = Integer.parseInt(s1);
        int h2 = Integer.parseInt(s3);

        int m1 = Integer.parseInt(s2);
        int m2 = Integer.parseInt(s4);

        while (h2 > 0){
            h2--;
            h1--;
            if(h1 < 0){
                h1 = 23;
            }
        }

        while (m2 > 0){
            m2--;
            m1--;
            if(m1 < 0)
                m1 = 59;
        }

        if(h1 / 10 == 0){
            pw.print(0);
        }
        pw.print(h1);
        pw.print(":");
        if(m1 / 10 == 0)
            pw.print(0);
        pw.println(m1);

        pw.flush();
        pw.close();
    }
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        String s = scan.nextLine();  // current time

        String t = scan.nextLine();  // sleep period

        int Sh = Integer.parseInt(s.substring(0,2));
        int Th = Integer.parseInt(t.substring(0,2));
        int Sm = Integer.parseInt(s.substring(3,5));
        int Tm = Integer.parseInt(t.substring(3,5));

        if (Sm<Tm)
        {
            Sm+=60;
            if (!(Sh==0))
                Sh--;
            else
                Sh=23;
        }
        if (Sh<Th)
        {
            Sh+=24;
            Sh+=24*Th%Sh;
        }
        Sm-=Tm;
        Sh-=Th;
        String outh="",outm="";
        if (Sh<10)
            outh=outh.concat("0"+Sh);
        else
            outh=outh.concat(""+Sh);
        if (Sm<10)
            outm=outm.concat("0"+Sm);
        else
            outm=outm.concat(""+Sm);

        System.out.println(outh+":"+outm);

    }

}

import sun.util.calendar.Gregorian;

import java.util.*;
import java.io.*;

public class TaskA {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        String s = in.next();
        String p = in.next();
        int h1 = Integer.parseInt(s.substring(0, 2));
        int m1 = Integer.parseInt(s.substring(3, 5));
        int h2 = Integer.parseInt(p.substring(0, 2));
        int m2 = Integer.parseInt(p.substring(3, 5));
        String ans = "";
        if (h2 > h1) {
            if ((24 + h1 - h2) < 10) {
                ans += 0;
            }
            ans += 24 + h1 - h2;

        } else {
            if (h2 == h1) {
                if (m2 <= m1) {
                    ans += "00";
                } else {
                    ans += "23";
                }
            } else {
                ans += (h1 - h2);
            }
        }
        ans += ":";
        int m = Math.abs(m1 + 60 - m2);
        if (m >= 60) {
            m -= 60;
        }
        if (m < 10) {
            ans += "0";
        }
        ans += m;
        out.print(ans);
        out.close();
    }
}

import java.util.Scanner;

public class GeorgeandSleep {

    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        String[] a = scan.next().split(":", -1);
        String[] b = scan.next().split(":", -1);
        int p = Integer.valueOf(a[0]);
        int q = Integer.valueOf(b[0]);
        int k = Integer.valueOf(a[1]);
        int e = Integer.valueOf(b[1]);
        int t = p * 60 + k;
        int r = q * 60 + e;
        int w = t - r;
        int r1 = w / 60;
        int r2 = w % 60;
        if (r1 < 0) {
            r1 = 24 + r1;
        }
        if (r2 < 0) {
            r2 += 60;
        }
        if(e>k){
            r1 +=23;
        }
        System.out.printf("%02d:%02d", r1%24, r2%60);
        System.out.println();
    }

}

import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    String currTime = s.nextLine().trim();
    String sleep = s.nextLine().trim();
    int ch =  Integer.parseInt(currTime.substring(0, currTime.indexOf(':')));
    int cm =  Integer.parseInt(currTime.substring(currTime.indexOf(':') + 1));
    int sh =  Integer.parseInt(sleep.substring(0, sleep.indexOf(':')));
    int sm =  Integer.parseInt(sleep.substring(sleep.indexOf(':') + 1));
    int ssh = 0; int ssm = 0;
    if (cm >= sm) ssm = cm - sm;
    else { ch--; if (ch < 0) ch += 23; ssm = cm + 60 - sm; }
    ssh = ch - sh; if (ssh < 0) ssh += 23;
    System.out.println(String.format("%02d", ssh) + ":" + String.format("%02d", ssm));
  }
}

import java.lang.Math;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class CF227A {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);

		String time = in.next();

		String[] t1 = time.split(":");
		int hour = Integer.valueOf(t1[0]);
		int min = Integer.valueOf(t1[1]);

		String sleep = in.next();

		String[] s1 = sleep.split(":");
		int shour = Integer.valueOf(s1[0]);
		int smin = Integer.valueOf(s1[1]);
/*
		System.out.println(time);

		System.out.println(hour);
		System.out.println(min);
		System.out.println(shour);
		System.out.println(smin);
*/

		int ansmin =0;
		int anshour =0;
		int flag = 0;
		if ( min - smin > 0 ) {
			ansmin = min - smin;

		}else {
			ansmin = min - smin +60;
			flag =1;
		}
		anshour = hour - shour - flag;
		if ( anshour < 0) {
			anshour +=24;
		}

		if(anshour < 10) {
			out.print("0"+anshour);
		} else out.print(anshour);
		out.print(":");
		if (ansmin < 10) {
			out.println("0"+ansmin);
		}else out.print(ansmin);

		//out.println(anshour + ":"+ ansmin );

		out.close();
    	}

//	public static
//	public static
//	public static

}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    }

import java.util.*;
import java.io.*;
public class id1 {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		String[] first = sc.next().split(":");
		String[] second = sc.next().split(":");
		int h1 = Integer.parseInt(first[0]);
		int m1 = Integer.parseInt(first[1]);
		int h2 = Integer.parseInt(second[0]);
		int m2 = Integer.parseInt(second[1]);
		boolean minuteLess = false;
		boolean hourLess = false;
		int diffm = m1 - m2;
		if (diffm < 0){
			minuteLess = true;
			diffm = +60;
		}
		int diffh = h1 - h2;
		if (diffh < 0){
			diffh += 24;
			if (minuteLess){
				diffh--;
			}
		}else{
			if (minuteLess){
				diffh--;
			}
		}
		if (diffh < 10 && diffm < 10){
			System.out.println("0" + diffh + ":0"+diffm);
		}
		else if (diffh < 10 && diffm >= 10){
			System.out.println("0" + diffh + ":"+diffm);
		}
		else if (diffh >= 10 && diffm < 10 ){
			System.out.println(diffh + ":0"+ diffm);
		}
		else {
			System.out.println(diffh + ":"+ diffm);
		}
	}
}

import java.util.Scanner;

public class aa {

    public static void main(String[] args) {
  Scanner x=new Scanner(System.in);

   String s=x.next();
   String h=s.substring(0,2);
   String m=s.substring(3,5);

   String g=x.next();
   String h2=g.substring(0,2);
   String m2=g.substring(3,5);

   int shey=  Integer.parseInt(h)*60+Integer.parseInt(m);

   int nam=  Integer.parseInt(h2)*60+Integer.parseInt(m2);

   int dif= shey-nam;

   int hh=dif/60;

   int mm=dif%60;

   if(hh<0){hh+=24;}

   if(mm<0){mm+=60;}

   System.out.printf("%02d:%02d",hh,mm);

    }

}

import java.util.Scanner;
public class Main {
    public static void main(String[] args)
    {
    String s,t;
    int ph,pm,sh,sm,th,tm;
    Scanner in=new Scanner(System.in);
    while(in.hasNextLine())
    {
    s=in.nextLine();
    t=in.nextLine();
    sh=(s.charAt(0)-48)*10+(s.charAt(1)-48);
sm=(s.charAt(3)-48)*10+(s.charAt(4)-48);
th=(t.charAt(0)-48)*10+(t.charAt(1)-48);
tm=(t.charAt(3)-48)*10+(t.charAt(4)-48);
ph=sh-th;
pm=sm-tm;
if(ph<=0)
ph=(24+ph);
if(ph==24)
ph=0;
if(pm<0)
{pm=60+pm;
ph=ph-1;
}
if(ph<10)
System.out.print("0"+ph+":");
else
System.out.print(ph+":");
if(pm<10)
System.out.print("0"+pm);
else
System.out.println(pm);
    }

    }

}

import java.util.*;

public class CodeForces {
	Scanner scan = new Scanner(System.in);
	CodeForces()
	{
	String s,t;

	s = scan.nextLine();
	t = scan.nextLine();

	String [] shm = s.split(":");
	String [] thm = t.split(":");

	int sh = Integer.parseInt(shm[0]);
	int sm = Integer.parseInt(shm[1]);
	int th = Integer.parseInt(thm[0]);
	int tm = Integer.parseInt(thm[1]);

	int mnew = sm - tm < 0? sm + 60 - tm :sm-tm;
	int hnew = sm - tm < 0? sh - th -1 < 0? sh + 23 - th : sh - th : sh-th < 0? sh + 24 -th : sh-th;

	System.out.println(String.format("%02d", hnew)+":"+String.format("%02d", mnew));
	}
	public static void main(String[] args)
	{
	new CodeForces();
	}
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.text.*;

public class cf387a {

    static BufferedReader br;
    static Scanner sc;
    static PrintWriter out;

    public static void initA() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            sc = new Scanner(System.in);
            out = new PrintWriter(System.out);
        } catch (Exception e) {
        }
    }

    static boolean next_permutation(Integer[] p) {
        for (int a = p.length - 2; a >= 0; --a) {
            if (p[a] < p[a + 1]) {
                for (int b = p.length - 1;; --b) {
                    if (p[b] > p[a]) {
                        int t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                        for (++a, b = p.length - 1; a < b; ++a, --b) {
                            t = p[a];
                            p[a] = p[b];
                            p[b] = t;
                        }
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public static String getString() {
        try {
            return br.readLine();
        } catch (Exception e) {
        }
        return "";
    }

    public static Integer getInt() {
        try {
            return Integer.parseInt(br.readLine());
        } catch (Exception e) {
        }
        return 0;
    }

    public static Integer[] getIntArr() {
        try {
            StringTokenizer temp = new StringTokenizer(br.readLine());
            int n = temp.countTokens();
            Integer temp2[] = new Integer[n];
            for (int i = 0; i < n; i++) {
                temp2[i] = Integer.parseInt(temp.nextToken());
            }
            return temp2;
        } catch (Exception e) {
        }
        return null;
    }

    public static Long[] getLongArr() {
        try {
            StringTokenizer temp = new StringTokenizer(br.readLine());
            int n = temp.countTokens();
            Long temp2[] = new Long[n];
            for (int i = 0; i < n; i++) {
                temp2[i] = Long.parseLong(temp.nextToken());
            }
            return temp2;
        } catch (Exception e) {
        }
        return null;
    }

    public static String[] getStringArr() {
        try {
            StringTokenizer temp = new StringTokenizer(br.readLine());
            int n = temp.countTokens();
            String temp2[] = new String[n];
            for (int i = 0; i < n; i++) {
                temp2[i] = (temp.nextToken());
            }
            return temp2;
        } catch (Exception e) {
        }
        return null;
    }

    public static void print(Object a) {
        out.println(a);
    }

    public static void print(String s, Object... a) {
        out.printf(s, a);
    }

    public static int nextInt() {
        return sc.nextInt();
    }

    public static double nextDouble() {
        return sc.nextDouble();
    }

    public static void main(String[] ar) {
        initA();
        solve();
        out.flush();
    }

    public static void solve() {
        String cur[] = getString().split(":");
        String lama[] = getString().split(":");

        int jam_sekarang = new Integer(cur[0]), menit_sekarang = new Integer(cur[1]);
        int jam_lama = new Integer(lama[0]), menit_lama = new Integer(lama[1]);

        int jam = (jam_sekarang -  jam_lama + 24) % 24;
        int menit = menit_sekarang - menit_lama;
        if(menit < 0){
            jam--;
            menit +=24;
        }
        String j = jam+"";
        String m = menit+"";

        if(j.length()<2){
            j = "0"+j;
        }

        if(m.length()<2){
            m = "0"+m;
        }
        print(j+":"+m);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class A227 {
    public static void main(String args[]) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine();
        String t = br.readLine();
        String h = ""+s.charAt(0) + s.charAt(1);
        int h1 = Integer.parseInt(h);
        h = ""+s.charAt(3) + s.charAt(4);
        int m1 = Integer.parseInt(h);
        h = ""+t.charAt(0) + t.charAt(1);
        int h2 = Integer.parseInt(h);
        h = ""+t.charAt(3) + t.charAt(4);
        int m2 = Integer.parseInt(h);
        int h3,m3;
        String hh3="",mm3="";
        if (m1<m2)
        {
            h1--;
            if (h1<0)
                h1 = 24-h1;
            m3 = 60 + m1 -m2;
        }
        else
        {
            m3 = m1-m2;
        }

        if (h1<h2)
        {
            h3 = 24+h1 -h2;
        }
        else
            h3 = h1-h2;
        //System.out.println(h3 +":"+m3);
        if (h3<10)
            hh3 = "0"+h3;
        else
            hh3 =""+ h3;
        if (m3<10)
            mm3 = "0"+m3;
        else
            mm3 = "" + m3;
        System.out.println(hh3 +":"+mm3);
}
}

import java.util.Scanner;

public class George_And_Sleep{
    static int time (String s){
        String arr[] = s.split(":");
        return Integer.parseInt(arr[0])*60 + Integer.parseInt(arr[1]);
    }
    public static void main(String args[]){
        Scanner in = new Scanner(System.in);
        int start = time(in.next());
        int temp = time(in.next());
        int dur = 24*60 - temp;
        int t = (start + dur) % (24*60);
        if(t%60<10)
        	System.out.println(t/60+":0"+t%60);
        else
        	System.out.println(t/60+":"+t%60);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh, int mm, int hh2, int mm2) {
        int hhr, mmr = 0;

        if (hh == 0)
            hh = 24;

        mmr = mm - mm2;

        hhr = hh - hh2;

        if (mmr < 0) {
            mmr = 60 - mmr;
            hhr--;
        }

        if (hhr == 24)
            hhr = 0;

        String res = (hhr == 24) ? "00:" : (hhr <= 9) ? "0" + hhr + ":" : hhr
                + ":";

        res += (mmr == 0) ? "00" : (mmr <= 9) ? "0" + mmr : mmr;

        return res;

    }

    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String[] test = bf.readLine().split(":");

        int hh = Integer.parseInt(test[0]);
        int mm = Integer.parseInt(test[1]);

        String[] test2 = bf.readLine().split(":");

        int hh2 = Integer.parseInt(test2[0]);
        int mm2 = Integer.parseInt(test2[1]);

        System.out.println(Sleep(hh, mm, hh2, mm2));

    }
}

/* package whatever; // don't place pack4age name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import javax.sound.midi.SysexMessage;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
    public static void main (String[] args) throws java.lang.Exception
    {
        // your code goes here
Scanner sc = new Scanner(System.in);
String s,t,nh = "",nm = "";int l,a,b,c,d,k1,k2;
s = sc.next();t=sc.next();
 a =  Integer.parseInt(s.substring(0,2));
 b =  Integer.parseInt(s.substring(3));
 c =  Integer.parseInt(t.substring(0,2));
 d =  Integer.parseInt(t.substring(3));
int ph = a-c;int pm = b-d;
 // System.out.println(b);
   // System.out.println(d);
if(ph<0){ph = ph + 24;}
if(pm<0){pm = pm + 60;
        ph = ph-1;
                }

if(ph >10 && pm >10){
    System.out.println(ph+":"+pm);
}
else{
if(ph<10){
          nh = Integer.toString(ph);
          nh = "0"+ph;
          }
else{nh = Integer.toString(ph);}
if(pm<10){
          nm = Integer.toString(pm);
          nm = "0"+pm;
          }
else{nm = Integer.toString(pm);}
  System.out.println(nh+":"+nm);
}   }
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class splitcheck
{

    public static void main(String []args)
    {Scanner sc=new Scanner(System.in);
      String str1=sc.next();
      String str2=sc.next();
      String ar1[]=str1.split(":");
      String ar2[]=str2.split(":");
      int arl1[]=new int[2];
      int arl2[]=new int[2];
       for (int i=0;i<2;i++)
        {arl1[i]=Integer.parseInt(ar1[i]);
         arl2[i]=Integer.parseInt(ar2[i]);

        }

            int min=arl1[0]-arl2 [0];
            int hours=arl1[1]-arl2 [1];

            if(min<0)
            min+=24;
            if(hours<0)
            hours+=60;

            if(min<10&&hours<10)
            System.out.println("0"+min+":0"+hours);
            else if(min>10&&hours<10)
            System.out.println(min+":0"+hours);
            else if(min<10&&hours>10)
            System.out.println("0"+min+":"+hours);
            else
            System.out.println(min+":"+hours);
            }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class A {

    static void run_stream(InputStream ins) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String[] hm=br.readLine().split(":");

        int h1=Integer.parseInt(hm[0]);
        int m1=Integer.parseInt(hm[1])+h1*60;

        hm=br.readLine().split(":");
        int h2=Integer.parseInt(hm[0]);
        int m2=Integer.parseInt(hm[1])+h2*60;

        int m=m1-m2;
        if(m<0) {
            m+=(60*24);
        }

        int h=m/60;
        m=m%60;

        System.out.println(h+":"+m);
    }

    public static void main(String[] args) throws IOException {
        run_stream(System.in);
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;

/**
 * Created with IntelliJ IDEA.
 * User: AUtemuratov
 * Date: 07.04.14
 * Time: 15:43
 * To change this template use File | Settings | File Templates.
 */
public class ValeraX {

    static int n,x,sum;
    static int a[] = new int[111];
    static int b[] = new int[111];
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tk = new StringTokenizer(bf.readLine(), ":");
        for (int i=1; i<=2; i++){
            a[i] = Integer.parseInt(tk.nextToken());
        }

        tk = new StringTokenizer(bf.readLine(), ":");
        for (int i=1; i<=2; i++){
            b[i] = Integer.parseInt(tk.nextToken());
        }

        //a = FastRead.getNumbers(2,":");
        //b = FastRead.getNumbers(2,":");

       // System.out.println(a[1] + " " + a[2]);

        int one = (a[1]+24-b[1])%24;
        int two = (a[2]+60-b[2])%60;
        System.out.printf(String.format("%02d", one) + ":" + String.format("%02d", two));

    }
}

class FastRead {

        public static int [] getNumbers(int q, String delim) throws IOException {
            int a[] = new int[q+1];
            BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
            StringTokenizer tk = new StringTokenizer(bf.readLine(),delim);
            for (int i=1; i<=q; i++){
                a[i] = Integer.parseInt(tk.nextToken());
            }

            return a;
        }

        }

import java.util.Scanner;

/**
 * Created by kaaveh on 10/7/14.
 */
public class _387A_ {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        String tempW = input.nextLine();
        String tempS = input.nextLine();

        String[] tempWs = tempW.split(":");
        String[] tempSs = tempS.split(":");
        int wH = Integer.parseInt(tempWs[0]);
        int wM = Integer.parseInt(tempWs[1]);
        int sH = Integer.parseInt(tempSs[0]);
        int sM = Integer.parseInt(tempSs[1]);

        int rH = wH - sH;
        int rM = wM - sM;

        if (rH < 0){
            if (wM == sM)
                rH+= 24;
            else
                rH += 23;
        }
        if (rM <0) {
            rM += 60;
            if (wH == sH)
                rH= 23;
        }

        if (rH>9 && rM>9) {
            System.out.println(rH + ":" + rM);
            System.exit(0);
        }
        if (rH < 10)
            System.out.print("0" + rH + ":");
        else if (rH > 9)
            System.out.print(rH + ":");
        if (rM > 9)
            System.out.print(rM);
        else
            System.out.print("0" + rM);
    }
}

import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author KHALED
 */
public class GeorgeandSleep {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        String s=scan.next();
        String t=scan.next();
        int k1=Integer.parseInt(s.charAt(0)+""+s.charAt(1));
        int h1=Integer.parseInt(s.charAt(3)+""+s.charAt(4));
        int k2=Integer.parseInt(t.charAt(0)+""+t.charAt(1));
        int h2=Integer.parseInt(t.charAt(3)+""+t.charAt(4));
        int a=k1-k2;
        if(a<0)
            a+=24;
        int b=h1-h2;
        if(b<0)
            b+=24;
        String q=a+"";
        if(q.length()==1)
            q="0"+q;
        String w=b+"";
        if(w.length()==1)
            w="0"+w;
        System.out.println(q+":"+w);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh,int mm,int hh2 ,int mm2){
        int hhout,mmout;

        if(hh<hh2)
            hhout=24-(hh2-hh);
        else
            hhout=hh-hh2;

        if(mm<mm2)
            mmout=(60-mm2)+mm;
        else
            mmout=mm-mm2;

        if(mm<mm2&&hh==hh2&&hh==23)hhout=23;

        String outmin=mmout+"";
        if(outmin.length()==1)outmin="0"+outmin;
        String outhours=hhout+"";
        if(outhours.length()==1)outhours="0"+outhours;

        return outhours+":"+outmin;

    }

  public static void main(String[] args) throws IOException {
  BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
  String[] test= bf.readLine().split(":");

  int hh = Integer.parseInt(test[0]);
  int mm = Integer.parseInt(test[1]);

  String[] test2= bf.readLine().split(":");

  int hh2 = Integer.parseInt(test2[0]);
  int mm2 = Integer.parseInt(test2[1]);

  //Test Using the values from the buffer zeft:
  System.out.println(Sleep(hh,mm,hh2,mm2));

 }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 *
 * @author Ahmed
 */
public class AGeorgeAndSleep {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
String one[] = b.readLine().split(":");
String two[] = b.readLine().split(":");

int h1=Integer.parseInt(one[0]);
int m1=Integer.parseInt(one[1]);
int h2=Integer.parseInt(two[0]);
int m2=Integer.parseInt(two[1]);

if(m1 >= 0 && m1 <=59 && m2 >= 0 && m2 <=59  && h1 >= 0 && h1 <=23 && h2 >= 0 && h2 <=23){
if (h1 == 00 )

    h1=24;

if (h2 == 00 )

    h2=24;
String hour=(h1-h2)+"";
String min=(m1-m2)+"";
String hourNew=hour;
String minNew=min;
if (hour.length()==1)
    hourNew="0"+hour;
if (min.length()==1)
    minNew="0"+min;

    System.out.println(hourNew+":"+minNew);

}
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class JavaApplication2 {

    public static void main(String[] args) throws IOException {
        BufferedReader I = new BufferedReader(new InputStreamReader(System.in));
        String s[] = I.readLine().split(":");
        int h = Integer.parseInt(s[0]);
        int m = Integer.parseInt(s[1]);
        String t[] = I.readLine().split(":");
        int h1 = Integer.parseInt(t[0]);
        int m1 = Integer.parseInt(t[1]);
        int h2;
        int m2;
        if (h == 0) {
            h = 24;
        }

        h2 = h - h1;
        m2 = m - m1;

        if (h2 < 0) {
            h2 = 24 + h2;
        }
        if (m2 < 0) {
            h2--;
            m2 = 0 - m2;

        }
        String a = "";
        if(h2==24){
            h2=0;
        }
        if(m2==60){
            m2=0;
        }
        if (h2 < 10) {
            System.out.print("0" + h2 + ":");
        } else {
            System.out.print(h2 + ":");

        }if(m2<10){
            System.out.print("0"+m2);
        }else
            System.out.println(m2);

    }

}

import java.util.*;

public class bel7ob {
    public static void main(String[] args)  {
        Scanner sc = new Scanner(System.in);
        String wake = sc.nextLine();
        String sleep = sc.nextLine();

        int hWake =Integer.parseInt(wake.substring(0,2)) ;
        int minWake = Integer.parseInt(wake.substring(3)) ;
        int hSleep = Integer.parseInt(sleep.substring(0,2)) ;
        int minSleep = Integer.parseInt(sleep.substring(3)) ;

        if(hWake == 0)
            hWake = 24 ;
        if (hSleep == 0)
            hSleep = 24 ;
        if(hWake < hSleep)
            hWake += 24 ;
        if(minWake < minSleep)
            minWake += 60 ;

        if((hWake - hSleep) < 10 && (minWake - minSleep) < 10 )
            System.out.println("0"+(hWake-hSleep)+":"+"0"+(minWake-minSleep));
        else if ((hWake - hSleep) > 10 && (minWake - minSleep) < 10)
            System.out.println((hWake-hSleep)+":"+"0"+(minWake-minSleep));
            else if ((minWake - minSleep) > 10 && (hWake - hSleep) < 10)
                System.out.println("0"+(hWake-hSleep)+":"+(minWake-minSleep));
            else
            System.out.println((hWake-hSleep)+":"+(minWake-minSleep));
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh,int mm,int hh2 ,int mm2){
        int hhout,mmout;
        if(hh==0)hh=hh+1;
        if(hh2==0)hh2=hh2+1;

        if(hh<hh2)
            hhout=24-(hh2-hh);
        else
            hhout=hh-hh2;

        if(mm<mm2)
            mmout=(60-mm2)+mm;
        else
            mmout=mm-mm2;

        if(mm<mm2&&hh==hh2&&hh==23)hhout=23;

        String outmin=mmout+"";
        if(outmin.length()==1)outmin="0"+outmin;
        String outhours=hhout+"";
        if(outhours.length()==1)outhours="0"+outhours;

        return outhours+":"+outmin;

    }

  public static void main(String[] args) throws IOException {
  BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
  String[] test= bf.readLine().split(":");

  int hh = Integer.parseInt(test[0]);
  int mm = Integer.parseInt(test[1]);

  String[] test2= bf.readLine().split(":");

  int hh2 = Integer.parseInt(test2[0]);
  int mm2 = Integer.parseInt(test2[1]);

  //Test Using the values from the buffer zeft:
  System.out.println(Sleep(hh,mm,hh2,mm2));

 }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

    public static String Sleep(int hh,int mm,int hh2 ,int mm2){
        int hhout,mmout;
        if(hh==0){
            hh=23;
        }

        if(hh<hh2)
            hhout=24-(hh2-hh);
        else
            hhout=hh-hh2;

        if(mm<mm2)
            mmout=(60-mm2)+mm;
        else
            mmout=mm-mm2;

        if(mm<mm2&&hh==hh2&&hh==23)hhout=23;

        String outmin=mmout+"";
        if(outmin.length()==1)outmin="0"+outmin;
        String outhours=hhout+"";
        if(outhours.length()==1)outhours="0"+outhours;

        return outhours+":"+outmin;

    }

  public static void main(String[] args) throws IOException {
  BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
  String[] test= bf.readLine().split(":");

  int hh = Integer.parseInt(test[0]);
  int mm = Integer.parseInt(test[1]);

  String[] test2= bf.readLine().split(":");

  int hh2 = Integer.parseInt(test2[0]);
  int mm2 = Integer.parseInt(test2[1]);

  //Test Using the values from the buffer zeft:
  System.out.println(Sleep(hh,mm,hh2,mm2));

 }

}

import java.io.*;
import java.math.*;
import java.util.*;

public class FirstApp {
 private static MyScanner in;
 private static PrintStream out;
 private static void solve() throws IOException
 {
	 String s= in.nextString();
	 String t= in.nextString();
	 String str1 = new StringBuilder().append(s.charAt(0)).append(s.charAt(1)).toString();
	 String str2 = new StringBuilder().append(s.charAt(3)).append(s.charAt(4)).toString();
	 String str3 = new StringBuilder().append(t.charAt(0)).append(t.charAt(1)).toString();
	 String str4 = new StringBuilder().append(t.charAt(3)).append(t.charAt(4)).toString();
	 int s1= Integer.parseInt(str1);
	 int s2= Integer.parseInt(str2);
	 int s3= Integer.parseInt(str3);
	 int s4= Integer.parseInt(str4);
	 int res1=0;
	 int res2=0;
	 if(s1-s3<0)
	 {
		 s1=24;
	 }

	 if(s2 -s4 < 0)
	 {
		 res2=60;
		 res1 =23;
	 }

	 res1+=s1-s3;
	 res2+=s2-s4;
	 if(res1 >=24)
		 res1=res1-24;
	 if(res1/10==0)
	 {
		 System.out.print(0);
		 System.out.print(res1);
	 }
	 else
	 {
		 System.out.print(res1);
	 }
	 System.out.print(":");
	 if(res2/10==0)
	 {
		 System.out.print(0);
		 System.out.print(res2);
	 }
	 else
	 {
		 System.out.print(res2);
	 }
}

 public static void main(String[] args) throws IOException {
	 in = new MyScanner();
	out = System.out;
  solve();
 }

 // =====================================
 static class MyScanner {
  BufferedReader bufReader;
  StringTokenizer strTok;

  public MyScanner() throws IOException
  {
   bufReader = new BufferedReader(new InputStreamReader(System.in));
   strTok = new StringTokenizer("");
  }

  String GetNextToken() throws IOException {
   if (!strTok.hasMoreTokens())
    strTok = new StringTokenizer(bufReader.readLine());
   return strTok.nextToken();
  }

  public int nextInt() throws IOException {
   return Integer.valueOf(GetNextToken());
  }
  public String nextString() throws IOException {
   return GetNextToken();
  }

 }

}

import java.io.*;
import java.util.*;

public class Main
{
	public static void main(String[] args) throws IOException
	{
		Scanner sc = new Scanner(System.in);
		String wake[] = sc.nextLine().split(":");
		String duration[] = sc.nextLine().split(":");
		String sleep = process(wake, duration);
		System.out.println(sleep);
	}

	public static String process(String[] wk, String[] dr)
	{
		int awal = Integer.parseInt(wk[0]);
		int lama = Integer.parseInt(dr[0]);
		int selisih = awal - lama;
		if(selisih<0) {
			awal = 24 + (selisih);
		}
		else{
			awal = selisih;
		}
		int awal2 = Integer.parseInt(wk[1]);
		int lama2 = Integer.parseInt(dr[1]);
		int selisih2 = awal2 - lama2;
		if(selisih2<0) {
			awal = 60 + (selisih2);
		}
		else{
			awal2 = selisih2;
		}
		String awal3 = awal+"";
		String awal4 = awal2+"";
		if(awal3.length()<2)
			awal3 = "0"+awal;
		if(awal4.length()<2)
			awal4 = "0"+awal2;
		String hasil = awal3+":"+awal4;
		return hasil;
	}
}

import java.util.*;
import java.io.*;

public class A387 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        final int mod = 24*60;
        int ot = 0,nt = 0,tmp = 0;
        String[] buf;

        buf = in.next().split(":");
        ot  = Integer.parseInt(buf[0])*24;
        ot += Integer.parseInt(buf[1]);

        buf = in.next().split(":");
        nt  = Integer.parseInt(buf[0])*24;
        nt += Integer.parseInt(buf[1]);

        tmp = ((ot-nt)+mod)%mod;
        System.out.printf("%02d:%02d\n",tmp/60,tmp%60);
    }

}

import java.util.Scanner;

public class GeorgeAndSleep {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
            String s = scanner.next();
            String t = scanner.next();
            int sHour = Integer.parseInt(s.substring(0 , 2));
            int sMinute = Integer.parseInt(s.substring(3));
            int tHour = Integer.parseInt(t.substring(0 , 2));
            int tMinute = Integer.parseInt(t.substring(3));
            if(sHour - tHour >= 0) {
                    if(sMinute - tMinute < 0) {
                        if(sHour - tHour == 0)
                            System.out.print(23 + ":");
                        else {
                            if(sHour - tHour - 1 < 10)
                                System.out.print(0);
                            System.out.print(sHour - tHour - 1 + ":");
                        }
                    }
                    else {
                        if(sHour - tHour < 10)
                            System.out.print(0);
                        System.out.print(sHour - tHour + ":");
                    }
            }
            else {
                if(sHour - tHour + 24 < 10) {
                    System.out.print(0);
                    if(sMinute - tMinute < 0)
                        System.out.print(sHour - tHour + 23 + ":");
                    else
                        System.out.print(sHour - tHour  + 24 + ":");
                }
                else {
                    if(sMinute - tMinute < 0)
                        System.out.print(sHour - tHour + 23 + ":");
                    else
                        System.out.print(sHour - tHour + 24 + ":");
                }
            }
            if(sMinute - tMinute >= 0) {
                if (sMinute - tMinute < 10) {
                    System.out.print(0);
                    System.out.print(sMinute - tMinute);
                }
                else
                    System.out.print(sMinute - tMinute);
            }
            else {
                if(sMinute - tMinute + 60 < 10)
                    System.out.print(0 + sMinute - tMinute + 60);
                else
                    System.out.print(sMinute - tMinute + 60);
            }
    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		String s=in.next();
		String t=in.next();
		String v[]=s.split(":");
		String v2[]=t.split(":");
		int a=Integer.parseInt(v[0]);
		int a1=Integer.parseInt(v[1]);
		int b=Integer.parseInt(v2[0]);
		int b1=Integer.parseInt(v2[1]);
		int c=0;
		int c1=0;

		if ((a1-b1)<0) {
			if (a<=b) {
				c=23+(a-b);
			}
			else {
				c=(a-b);
			}
			c1=60+(a1-b1);
		}
		else {
			if (a<b) {
				c=24+(a-b);
			}
			else {
				c=(a-b);
			}
			c1=a1-b1;
		}
		String r=String.valueOf(c);
		String r1=String.valueOf(c1);
		if (r.length()==2) {
			System.out.print(r+":");
		}
		else {
			System.out.print("0"+r+":");
		}
		if (r1.length()==2) {
			System.out.println(r1);
		}
		else {
			System.out.println("0"+r1);
		}

	}

}