Little Petya is learning to play chess. He has already learned how to move a king, a rook and a bishop. Let us remind you the rules of moving chess pieces. A chessboard is 64 square fields organized into an 8 × 8 table. A field is represented by a pair of integers (r, c) — the number of the row and the number of the column (in a classical game the columns are traditionally indexed by letters). Each chess piece takes up exactly one field. To make a move is to move a chess piece, the pieces move by the following rules:  A rook moves any number of fields horizontally or vertically.  A bishop moves any number of fields diagonally.  A king moves one field in any direction — horizontally, vertically or diagonally.     The pieces move like that Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (r1, c1) to field (r2, c2)? At that, we assume that there are no more pieces besides this one on the board. Help him solve this problem.

The input contains four integers r1, c1, r2, c2 (1 ≤ r1, c1, r2, c2 ≤ 8) — the coordinates of the starting and the final field. The starting field doesn't coincide with the final one. You can assume that the chessboard rows are numbered from top to bottom 1 through 8, and the columns are numbered from left to right 1 through 8.

Print three space-separated integers: the minimum number of moves the rook, the bishop and the king (in this order) is needed to move from field (r1, c1) to field (r2, c2). If a piece cannot make such a move, print a 0 instead of the corresponding number.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;

@SuppressWarnings("unused")
public class A {
	public  static  FastScannerA scan = new FastScannerA();
	public static PrintWriter out = new PrintWriter(System.out);
	public static void solve () {
		int r1=scan.nextInt();
		int c1=scan.nextInt();
		int r2=scan.nextInt();
		int c2=scan.nextInt();
		out.print((r1==r2 || c1==c2) ?"1":"2");
		if((r1+c1)%2!=(r2+c2)%2)out.print(" "+"0"+"");
		else {
			out.print((r1 + c1 == r2 + c2 || r1 - c1 == r2 - c2)?" "+"1":" "+"2");
		}
		out.print(" ");
		out.println(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
	}
	public static void main(String[] args) {

		solve();
		out.close();
	}

}
class FastScannerA {
	BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer st= new StringTokenizer("");
	String next() {
		while (!st.hasMoreTokens())
			try {
				st=new StringTokenizer(br.readLine());
			} catch (IOException e) {
				e.printStackTrace();
			}
		return st.nextToken();
	}
	int nextInt() {
		return Integer.parseInt(next());
	}
	int[] readArray(int n) {
		int[] a=new int[n];
		for (int i=0; i<n; i++) a[i]=nextInt();
		return a;
	}
	long nextLong() {
		return Long.parseLong(next());
	}
	void sort(long[] a) {
		ArrayList<Long> l=new ArrayList<>();
		for (long i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

}

import java.util.Scanner;

public class EsA {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int r1,r2,c1,c2;
		r1=scan.nextInt();
		c1=scan.nextInt();
		r2=scan.nextInt();
		c2=scan.nextInt();

		//torre
		if(r1==r2 || c1 == c2){
			System.out.print(1);
		}else{
			System.out.print(2);
		}
		System.out.print(" ");

		//alfiere
		int dif1 = Math.abs(r2-r1);
		int dif2 = Math.abs(c2-c1);
		if((r1+c1)%2 != (r2+c2)%2){
			System.out.print(0);
		}else {
			if(dif1==dif2)
				System.out.print(1);
			else
				System.out.print(2);

		}
		System.out.print(" ");

		//re

		int k2 = Math.abs(c2-c1);
		int k1 = Math.abs(r2-r1);
		System.out.print(Math.max(k2, k1));
		System.out.println();
	}

}

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 RookBishopandKing {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int r1=scan.nextInt();
        int c1=scan.nextInt();
        int r2=scan.nextInt();
        int c2=scan.nextInt();
        int r=0,b=0,k=0;
//        if(r1==r2||c1==c2)
//            r=1;
//        else
//            r=2;
//        if(Math.abs(r1-r2)==Math.abs(c1-c2))
//            b=1;
//        else if((r1==r2&&Math.abs(c1-c2)%2==0)||(c1==c2&&Math.abs(r1-r2)%2==0))
//            b=2;
//        else if((r1!=r2&&Math.abs(c1-c2)%2==1)||(c1!=c2&&Math.abs(r1-r2)%2==1))
//            b=2;
//        else
//            b=0;
//        if(b==1)
//            k=Math.abs(c1-c2);
//        else if(b==2)
//        {
//            k=Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
//        }
//        else
//            k=Math.abs(r1-r2)+Math.abs(c1-c2);
//        System.out.println(r+" "+b+" "+k);
        int rook = ((r2 != r1)? 1: 0) + ((c2 != c1)? 1: 0);
        int king = Math.max(Math.abs(r2 - r1), Math.abs(c2 - c1));
        int bishop = 2;
        if(r1 + c1 == r2 + c2) bishop = 1;
        if(c1 - r1 == c2 - r2) bishop = 1;
        if((r1 + c1) % 2 != (r2 + c2) % 2) bishop = 0;
        System.out.println(rook + " " + bishop + " " + king);
    }
}

import java.util.*;
import java.io.*;
public class Main {
    public static void main(String[] args) {
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        Solver s = new Solver();
        int test = 1;
        for (int i = 1; i <= test; i++) {
            s.solve(i, in, out);
        }
        out.close();
    }

    static class Solver {

        static class Pair {
            int x, y;

            public Pair(int x, int y) {
                this.x = x;
                this.y = y;
            }
        }

        void solve(int test_case, InputReader in, PrintWriter out) {
            int r1 = in.nextInt() - 1;
            int c1 = in.nextInt() - 1;
            int r2 = in.nextInt() - 1;
            int c2 = in.nextInt() - 1;
            int n = 8;
            int[][] level = new int[8][8];
            for (int i = 0; i < level.length; i++) {
                Arrays.fill(level[i], Integer.MAX_VALUE);
            }
            level[r1][c1] = 0;
            Queue<Pair> q = new LinkedList<>();
            q.add(new Pair(r1, c1));
            while (!q.isEmpty()) {
                Pair tt = q.remove();
                for (int i = tt.x; i < n; i++) {
                    if (level[i][tt.y] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(i, tt.y));
                        level[i][tt.y] = level[tt.x][tt.y] + 1;
                    }
                }
                for (int i = tt.x; i >= 0; i--) {
                    if (level[i][tt.y] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(i, tt.y));
                        level[i][tt.y] = level[tt.x][tt.y] + 1;
                    }
                }
                for (int i = tt.y; i < n; i++) {
                    if (level[tt.x][i] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(tt.x, i));
                        level[tt.x][i] = level[tt.x][tt.y] + 1;
                    }
                }
                for (int i = tt.y; i >= 0; i--) {
                    if (level[tt.x][i] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(tt.x, i));
                        level[tt.x][i] = level[tt.x][tt.y] + 1;
                    }
                }
            }
            if (level[r2][c2] == Integer.MAX_VALUE) level[r2][c2] = 0;
            out.print(level[r2][c2] + " ");
            for (int i = 0; i < level.length; i++) {
                Arrays.fill(level[i], Integer.MAX_VALUE);
            }
            level[r1][c1] = 0;
            q.clear();
            q.add(new Pair(r1, c1));
            while (!q.isEmpty()) {
                Pair tt = q.remove();
                for (int i = tt.x, j = tt.y; i < n && j < n; i++, j++) {
                    if (level[i][j] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(i, j));
                        level[i][j] = level[tt.x][tt.y] + 1;
                    }
                }
                for (int i = tt.x, j = tt.y; i >= 0 && j >= 0; i--, j--) {
                    if (level[i][j] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(i, j));
                        level[i][j] = level[tt.x][tt.y] + 1;
                    }
                }
                for (int i = tt.x, j = tt.y; i < n && j >= 0; i++, j--) {
                    if (level[i][j] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(i, j));
                        level[i][j] = level[tt.x][tt.y] + 1;
                    }
                }
                for (int i = tt.x, j = tt.y; i >= 0 && j < n; i--, j++) {
                    if (level[i][j] > level[tt.x][tt.y] + 1) {
                        q.add(new Pair(i, j));
                        level[i][j] = level[tt.x][tt.y] + 1;
                    }
                }
            }
            if (level[r2][c2] == Integer.MAX_VALUE) level[r2][c2] = 0;
            out.print(level[r2][c2] + " ");
            for (int i = 0; i < level.length; i++) {
                Arrays.fill(level[i], Integer.MAX_VALUE);
            }
            level[r1][c1] = 0;
            q.clear();
            q.add(new Pair(r1, c1));
            while (!q.isEmpty()) {
                Pair tt = q.remove();
                for (int dx = -1; dx <= 1; dx++) {
                    for (int dy = -1; dy <= 1; dy++) {
                        int x = tt.x + dx;
                        int y = tt.y + dy;
                        if (x < n && x >= 0 && y < n && y >=0 ) {
                            if (level[x][y] > level[tt.x][tt.y] + 1) {
                                q.add(new Pair(x, y));
                                level[x][y] = level[tt.x][tt.y] + 1;
                            }
                        }
                    }
                }
            }
            if (level[r2][c2] == Integer.MAX_VALUE) level[r2][c2] = 0;
            out.print(level[r2][c2] + " ");
        }
    }

    static class InputReader {

        BufferedReader br;
        StringTokenizer st;

        public InputReader() {
            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 in = new Scanner(System.in);
        int x1,y1,x2,y2, movT, movA, movR;
        x1 = in.nextInt();
        y1 = in.nextInt();
        x2 = in.nextInt();
        y2 = in.nextInt();
        movT = cantMovTorre(x1, y1, x2, y2);
        movA = cantMovArfil(x1, y1, x2, y2);
        movR = cantMovRey(x1, y1, x2, y2);
        System.out.println(movT+" "+movA+" "+movR);
    }

    private static int cantMovTorre(int x1, int y1, int x2, int y2){
        int resp=1;
        if((x1 != x2) && (y1 != y2))
            resp = 2;
        return resp;
    }

    private static int cantMovArfil(int x1, int y1, int x2, int y2){
        int resp=0;
        if(((x1+y1)%2 == (x2+y2)%2) || ((x1-y1)%2 == (x2-y2)%2)){
            if((x1+y1 == x2+y2) || (x1-y1 == x2-y2))
                resp =1;
            else
                resp=2;
        }
        return resp;
    }

    private static int cantMovRey(int x1, int y1, int x2, int y2){
        return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2));
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class Main {

	public static void main(String[] args) {

		PrintWriter writer = new PrintWriter(System.out);
		try {
			BufferedReader reader = new BufferedReader(new InputStreamReader(
					System.in));

			String[] strings = reader.readLine().split(" ");

			int r1 = Integer.parseInt(strings[0]);
			int c1 = Integer.parseInt(strings[1]);
			int r2 = Integer.parseInt(strings[2]);
			int c2 = Integer.parseInt(strings[3]);

			if (r1 == r2 || c1 == c2) {
				writer.print(1 + " ");
			} else {
				writer.print(2 + " ");
			}

			if (Math.abs((r1 + c1) - (r2 + c2)) % 2 == 1)
				writer.print(0 + " ");
			else {
				if (r1 + c1 == r2 + c2 || r1 - c1 == r2 - c2)
					writer.print(1 + " ");
				else
					writer.print(2 + " ");
			}

			writer.print(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));

		} catch (Exception ex) {
		} finally {
			writer.flush();
			writer.close();
		}

	}
}

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author geek_guY
 */
public class que1 {

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

        inputz1 in = new inputz1(System.in);
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();

        int a1 = 0, a2 = 0, a3 = 0;

        if (x1 == x2 || y1 == y2) {
            a1 = 1;
        } else {
            a1 = 2;
        }

        if (Math.abs(x1 - x2) == Math.abs(y1 - y2)) {
            a2 = 1;
        } else if ((Math.abs(x1 - x2) + Math.abs(y1 - y2)) % 2 == 0) {
            a2 = 2;
        } else {
            a2 = 0;
        }

        int q1 = Math.abs(x2-x1);
        int q2 = Math.abs(y2-y1);

        a3 = Math.max(q1, q2);
        System.out.println(a1+" "+a2+" "+a3);

    }
}

class inputz1 {

    final private int BUFFER_SIZE = 1 << 17;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public inputz1(InputStream in) {
        din = new DataInputStream(in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String nextString() throws Exception {
        StringBuffer sb = new StringBuffer("");
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        do {
            sb.append((char) c);
            c = read();
        } while (c > ' ');
        return sb.toString();
    }

    public char nextChar() throws Exception {
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        return (char) c;
    }

    public int nextInt() throws Exception {
        int ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    public long nextLong() throws Exception {
        long ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    private void fillBuffer() throws Exception {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1) {
            buffer[0] = -1;
        }
    }

    private byte read() throws Exception {
        if (bufferPointer == bytesRead) {
            fillBuffer();
        }
        return buffer[bufferPointer++];
    }
}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
	    Scanner sc = new Scanner(System.in);
	int r1 = sc.nextInt();
	int c1 = sc.nextInt();
	int r2 = sc.nextInt();
	int c2 = sc.nextInt();
	int rm = 0;
	int km = 0;
	int bm = 0;
	if(r1==r2 || c1==c2){
	    rm=1;
	    if(r1==r2){
	        km = Math.abs(c1-c2);
	        if(km%2==1){
	            bm = 0;
	        }
	        else{
	            bm = 2;
	        }
	    }
	    else{
	        km = Math.abs(r1-r2);
	        if(km%2==1){
	            bm = 0;
	        }
	        else{
	            bm = 2;
	        }
	    }
	}
	else{
	    int rd = r1-r2;
	    int cd = c1-c2;
	    int ra = Math.abs(rd);
	    int ca = Math.abs(cd);
	    if(r1+c1==r2+c2){
	        bm=1;
	    }
	    else if(ra==ca){
	        bm=1;
	    }
	    else if((r1+c1)%2==(r2+c2)%2){
	        bm=2;
	    }
	    else{
	        bm=0;
	    }
	    rm=2;
	    km = Math.max(ra,ca);
	}
	System.out.println(""+rm+" "+bm+" "+km);
	        }
	    }

import java.util.*;
import java.io.*;
public class Cf217a {
    public static void main(String[] args) throws IOException {
        InputStreamReader fin = new InputStreamReader(System.in);
        Scanner scr = new Scanner(fin);
        int r1 = scr.nextInt();
        int c1 = scr.nextInt();
        int r2 = scr.nextInt();
        int c2 = scr.nextInt();
        int l = 0;
        int s = 0;
        int k = 0;
        if ((r1 == r2)|(c1 == c2)) {
            l = 1;
        } else {
            l = 2;
        }
        if ((r1 + c1)%2 != (r2 + c2)%2) {
            s = 0;
        } else if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) {
            s = 1;
        } else {
            s = 2;
        }
        k = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
        PrintWriter fout = new PrintWriter(System.out);
        fout.print(l +" "+ s +" "+ k);
        fout.flush();
        fout.close();
    }
}

import java.util.*;
import java.io.*;
public class RookBishop{
	public static void main(String[] args)throws IOException{
		FastReader sc = new FastReader();
		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(java.io.FileDescriptor.out),"ASCII"),512);
		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();
		int rm = 0;
		int bm = 0;
		int km = 0;
		int a = Math.abs(r1-r2);
		int b = Math.abs(c1-c2);
		int c = Math.min(a, b);
		if(r1 == r2 || c1 == c2) rm = 1;
		else rm = 2;
		if((r1+c1)%2 != (r2+c2)%2) bm = 0;
		else{
			if(a == b) bm = 1;
			else bm = 2;
		}
		km = c;
		a -= c;
		b -= c;
		km += Math.max(a, b);
		out.write(rm + " " + bm + " " + km);
		out.write('\n');
		out.flush();
	}
}
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 RookiBishopKing {

    public static int rooki(int x1, int y1, int x2, int y2) {
        return ((x1 == x2) || (y1 == y2)) ? 1 : 2;
    }

    public static int bishop(int x1, int y1, int x2, int y2) {
        if ((x1 + y1) % 2 != (x2 + y2) % 2) {
            return 0;
        }
        return (Math.abs(x1 - x2) == Math.abs(y1 - y2)) ? 1 : 2;
    }

    public static int king(int x1, int y1, int x2, int y2) {
        int c = 0;
        for (; (x1 != x2) || (y1 != y2);) {
            if (y1 > y2) {
                y1--;
            }
            if (y1 < y2) {
                y2--;
            }
            if (x1 > x2) {
                x1--;
            }
            if (x1 < x2) {
                x2--;
            }
            c++;
        }
        return c += (y1==y2)?Math.abs(x1-x2):Math.abs(y1-y2);

    }

    public static void main(String[] args) {
        Scanner scr = new Scanner(System.in);
        int x1, y1, x2, y2;
        x1 = scr.nextInt();
        y1 = scr.nextInt();
        x2 = scr.nextInt();
        y2 = scr.nextInt();

        System.out.print(rooki(x1, y1, x2, y2));
        System.out.print(" ");
        System.out.print(bishop(x1, y1, x2, y2));
        System.out.print(" ");
        System.out.println(king(x1, y1, x2, y2));

    }

}

import java.util.*;

public class Main
{

	public static void main(String[] args)
	{
		// (546 456 160)C (252298 116 218 124)B (297 251)A

		Scanner in = new Scanner(System.in);

		int r1, c1, r2, c2;

		r1 = in.nextInt();
		c1 = in.nextInt();
		r2 = in.nextInt();
		c2 = in.nextInt();

		if (r1 == r2 || c1 == c2)
			System.out.println(1);
		else
			System.out.println(2);

		System.out.println(" ");

		if ((r1 + c1) % 2 != (r2 + c2) % 2)
			System.out.println(0);
		else
		{
			if (r1 + c1 == r2 + c2 || r1 - c1 == r2 - c2)
				System.out.println(1);
			else
				System.out.println(2);
		}

		System.out.println(" ");
		System.out.println(Math. max(Math.abs(r1 - r2), Math.abs(c1 - c2)));

	}
}

import java.util.Scanner;

public class RookBishopKing {

    public static void main (String [] args) {
    	Scanner sc=new Scanner(System.in);
    	int r1=sc.nextInt();
    	int c1=sc.nextInt();
    	int r2=sc.nextInt();
    	int c2=sc.nextInt();
    	//rook:
    	int rook=0;
    	int bish=0;
    	int king=0;
    	if (r1==r2){
    		if (c1!=c2)
    			rook=1;
    	}
    	else{
    		if (c1==c2)
    			rook=1;
    		else
    			rook=2;
    	}
    	//bishop:
    	if ((r1+c1)%2==(r2+c2)%2){
    		if (r1+c1==r2+c2 || r1-c1==r2-c2)
    			bish=1;
    		else
    			bish=2;

    	}
    	while (r1!=r2 || c1!=c2){
    		if (r1>r2){
    			r1--;
    		}
    		else{
    			if (r2>r1)
    				r2--;
    		}
    		if (c1>c2){
    			c1--;
    		}
    		else{
    			if (c2>c1)
    				c2--;
    		}
    		king++;
    	}
    	System.out.println(rook + " "+ bish + " " + king);
    }

}

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

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

        int R1 = sc.nextInt();
        int C1 = sc.nextInt();
        int R2 = sc.nextInt();
        int C2 = sc.nextInt();

        int dr = Math.abs(R2 - R1);
        int dc = Math.abs(C2 - C1);

        int r = (R1 == R2 || C1 == C2) ? 1 : 2;

        int b;
        if (dr % 2 != dc % 2) {
        	b = 0;
        } else {
        	b = (dr == dc) ? 1 : 2;
        }

        int k = Math.max(dr, dc);

        System.out.println(r + " " + b + " " + k);
    }

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

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

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

        int[] nextIntArray(int n) {
        	int[] arr = new int[n];
        	for (int i = 0; i < n; i++) {
        		arr[i] = nextInt();
        	}
        	return arr;
        }

        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.util.*;
import java.io.*;
import java.awt.Point;
import java.math.BigDecimal;
import java.math.BigInteger;

import static java.lang.Math.*;

// Solution is at the bottom of code

public class A implements Runnable{

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	OutputWriter out;
	StringTokenizer tok = new StringTokenizer("");

	public static void main(String[] args){
		new Thread(null, new A(), "", 128 * (1L << 20)).start();
	}

	/////////////////////////////////////////////////////////////////////

	void init() throws FileNotFoundException{
		Locale.setDefault(Locale.US);

		if (ONLINE_JUDGE){
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new OutputWriter(System.out);
		}else{
			in = new BufferedReader(new FileReader("input.txt"));
			out = new OutputWriter("output.txt");
		}
	}

	////////////////////////////////////////////////////////////////

	long timeBegin, timeEnd;

	void time(){
		timeEnd = System.currentTimeMillis();
		System.err.println("Time = " + (timeEnd - timeBegin));
	}

	void debug(Object... objects){
		if (ONLINE_JUDGE){
			for (Object o: objects){
				System.err.println(o.toString());
			}
		}
	}

	/////////////////////////////////////////////////////////////////////

	public void run(){
		try{
			timeBegin = System.currentTimeMillis();
			Locale.setDefault(Locale.US);

			init();
			solve();

			out.close();
			time();
		}catch (Exception e){
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	/////////////////////////////////////////////////////////////////////

	String delim = " ";

	String readString() throws IOException{
		while(!tok.hasMoreTokens()){
			try{
				tok = new StringTokenizer(in.readLine());
			}catch (Exception e){
				return null;
			}
		}

		return tok.nextToken(delim);
	}

	String readLine() throws IOException{
		return in.readLine();
	}

	/////////////////////////////////////////////////////////////////

	final char NOT_A_SYMBOL = '\0';

	char readChar() throws IOException{
		int intValue = in.read();

		if (intValue == -1){
			return NOT_A_SYMBOL;
		}

		return (char) intValue;
	}

	char[] readCharArray() throws IOException{
		return readLine().toCharArray();
	}

	/////////////////////////////////////////////////////////////////

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	int[] readIntArray(int size) throws IOException {
		int[] array = new int[size];

		for (int index = 0; index < size; ++index){
			array[index] = readInt();
		}

		return array;
	}

	int[] readIntArrayWithDecrease(int size) throws IOException {
		int[] array = readIntArray(size);

		for (int i = 0; i < size; ++i) {
			array[i]--;
		}

		return array;
	}

	///////////////////////////////////////////////////////////////////

	long readLong() throws IOException{
		return Long.parseLong(readString());
	}

	long[] readLongArray(int size) throws IOException{
		long[] array = new long[size];

		for (int index = 0; index < size; ++index){
			array[index] = readLong();
		}

		return array;
	}

	////////////////////////////////////////////////////////////////////

	double readDouble() throws IOException{
		return Double.parseDouble(readString());
	}

	double[] readDoubleArray(int size) throws IOException{
		double[] array = new double[size];

		for (int index = 0; index < size; ++index){
			array[index] = readDouble();
		}

		return array;
	}

	////////////////////////////////////////////////////////////////////

	BigInteger readBigInteger() throws IOException {
		return new BigInteger(readString());
	}

	BigDecimal readBigDecimal() throws IOException {
		return new BigDecimal(readString());
	}

	/////////////////////////////////////////////////////////////////////

	Point readPoint() throws IOException{
		int x = readInt();
		int y = readInt();
		return new Point(x, y);
	}

	Point[] readPointArray(int size) throws IOException{
		Point[] array = new Point[size];

		for (int index = 0; index < size; ++index){
			array[index] = readPoint();
		}

		return array;
	}

	/////////////////////////////////////////////////////////////////////

	List<Integer>[] readGraph(int vertexNumber, int edgeNumber)
	throws IOException{
		@SuppressWarnings("unchecked")
		List<Integer>[] graph = new List[vertexNumber];

		for (int index = 0; index < vertexNumber; ++index){
			graph[index] = new ArrayList<Integer>();
		}

		while (edgeNumber-- > 0){
			int from = readInt() - 1;
			int to = readInt() - 1;

			graph[from].add(to);
			graph[to].add(from);
		}

		return graph;
	}

	/////////////////////////////////////////////////////////////////////

	static class IntIndexPair {

		static Comparator<IntIndexPair> increaseComparator = new Comparator<A.IntIndexPair>() {

			@Override
			public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
				int value1 = indexPair1.value;
				int value2 = indexPair2.value;

				if (value1 != value2) return value1 - value2;

				int index1 = indexPair1.index;
				int index2 = indexPair2.index;

				return index1 - index2;
			}
		};

		static Comparator<IntIndexPair> decreaseComparator = new Comparator<A.IntIndexPair>() {

			@Override
			public int compare(IntIndexPair indexPair1, IntIndexPair indexPair2) {
				int value1 = indexPair1.value;
				int value2 = indexPair2.value;

				if (value1 != value2) return -(value1 - value2);

				int index1 = indexPair1.index;
				int index2 = indexPair2.index;

				return index1 - index2;
			}
		};

		int value, index;

		public IntIndexPair(int value, int index) {
			super();
			this.value = value;
			this.index = index;
		}

		public int getRealIndex() {
			return index + 1;
		}
	}

	IntIndexPair[] readIntIndexArray(int size) throws IOException {
		IntIndexPair[] array = new IntIndexPair[size];

		for (int index = 0; index < size; ++index) {
			array[index] = new IntIndexPair(readInt(), index);
		}

		return array;
	}

	/////////////////////////////////////////////////////////////////////

	static class OutputWriter extends PrintWriter{

		final int DEFAULT_PRECISION = 12;

		int precision;
		String format, formatWithSpace;

		{
			precision = DEFAULT_PRECISION;

			format = createFormat(precision);
			formatWithSpace = format + " ";
		}

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

		public OutputWriter(String fileName) throws FileNotFoundException {
			super(fileName);
		}

		public int getPrecision() {
			return precision;
		}

		public void setPrecision(int precision) {
			precision = max(0, precision);
			this.precision = precision;

			format = createFormat(precision);
			formatWithSpace = format + " ";
		}

		private String createFormat(int precision){
			return "%." + precision + "f";
		}

		@Override
		public void print(double d){
			printf(format, d);
		}

		public void printWithSpace(double d){
			printf(formatWithSpace, d);
		}

		public void printAll(double...d){
			for (int i = 0; i < d.length - 1; ++i){
				printWithSpace(d[i]);
			}

			print(d[d.length - 1]);
		}

		@Override
		public void println(double d){
			printlnAll(d);
		}

		public void printlnAll(double... d){
			printAll(d);
			println();
		}
	}

	/////////////////////////////////////////////////////////////////////

	int[][] steps = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
	int[][] steps8 = {
			{-1, 0}, {1, 0}, {0, -1}, {0, 1},
			{-1, -1}, {1, 1}, {1, -1}, {-1, 1}
	};

	boolean check(int index, int lim){
		return (0 <= index && index < lim);
	}

	/////////////////////////////////////////////////////////////////////

	boolean checkBit(int mask, int bitNumber){
		return (mask & (1 << bitNumber)) != 0;
	}

	/////////////////////////////////////////////////////////////////////

	void solve() throws IOException {
		Point start = readPoint();
		Point finish = readPoint();

		int rookAnswer = getRook(start, finish);
		int bishopAnswer = getBishop(start, finish);
		int kingAnswer = getKing(start, finish);

		out.println(rookAnswer + " " + bishopAnswer + " " + kingAnswer);
	}

	private int getKing(Point start, Point finish) {
		int deltaRow = abs(start.x - finish.x);
		int deltaColumn = abs(start.y - finish.y);

		return max(deltaRow, deltaColumn);
	}

	private int getBishop(Point start, Point finish) {
		int can = (isEqualColor(start, finish)? 1: 0);

		int startDiagLU = start.x - start.y;
		int finishDiagLU = finish.x - finish.y;

		int startDiagRU = start.x + start.y;
		int finishDiagRU = finish.x + finish.y;

		int deltaLU = (startDiagLU != finishDiagLU? 1: 0);
		int deltaRU = (startDiagRU != finishDiagRU? 1: 0);

		return (deltaLU + deltaRU) * can;
	}

	private boolean isEqualColor(Point start, Point finish) {
		boolean isStartBlack = isBlackCell(start);
		boolean isFinishBlack = isBlackCell(finish);

		return (isStartBlack == isFinishBlack);
	}

	private boolean isBlackCell(Point cell) {
		boolean isRowEven = (cell.x & 1) == 0;
		boolean isColumnEven = (cell.y & 1) == 0;

		boolean isBlack = (isColumnEven == isRowEven);

		return isBlack;
	}

	int getRook(Point start, Point finish) {
		int deltaRow = (start.x != finish.x? 1: 0);
		int deltaColumn = (start.y != finish.y? 1: 0);

		return deltaRow + deltaColumn;
	}
}

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

public class Problem370A
{
    public static void main(String[] args) throws IOException
    {
        fastinput.init(System.in);
        int r1 = fastinput.nextInt();
        int c1 = fastinput.nextInt();
        int r2 = fastinput.nextInt();
        int c2 = fastinput.nextInt();

        int rookmoves = 0;
        int bishopmoves = 0;
        int kingmoves = 0;

        if (r1 == r2)
        {
            rookmoves = 1;
            if ((c1+c2) % 2 == 0)
            {
                bishopmoves = 2;
            }
            kingmoves = Math.abs(c1-c2);
        }
        else if (c1 == c2)
        {
            rookmoves = 1;
            if ((r1+r2) % 2 == 0)
            {
                bishopmoves = 2;
            }
            kingmoves = Math.abs(r1-r2);
        }
        else
        {
            rookmoves = 2;

            if (Math.abs(r1 - r2) == Math.abs(c1 - c2))
            {
                bishopmoves = 1;
            }
            else if ((r1+r2) % 2 == 0 && (c1+c2) % 2 == 0)
            {
                bishopmoves = 2;
            }
            else
            {
                int r1a = r1+1;
                int c1a = c1+1;
                if ((r1a+r2) % 2 == 0 && (c1a+c2) % 2 == 0)
                {
                    bishopmoves = 2;
                }
            }

            kingmoves = Math.max(Math.abs(r1-r2), Math.abs(c1-c2));
        }
        System.out.println(rookmoves+" "+bishopmoves+" "+kingmoves);
    }

    public static class fastinput
    {
        static BufferedReader bf;
        static StringTokenizer st;

        static void init(InputStream input)
        {
            bf = new BufferedReader(new InputStreamReader(input));
            st = new StringTokenizer("");
        }

        static String nextline() throws IOException
        {
            return bf.readLine();
        }

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

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

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

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStreamReader;
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();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int r1 = in.nextInt();
            int c1 = in.nextInt();
            int r2 = in.nextInt();
            int c2 = in.nextInt();
            if (r1 == r2 || c1 == c2) out.print("1 ");
            else out.print("2 ");
            if ((r1 + c1) % 2 != (r2 + c2) % 2) out.print("0 ");
            else if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) out.print("1 ");
            else out.print("2 ");
            out.print(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));
        }

    }

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

        public InputReader(InputStream inputStream) {
            reader = new BufferedReader(new InputStreamReader(inputStream));
        }

        private void fillTokenizer() {
            if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }

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

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

    }
}

import java.util.*;
public class CodeForces217A {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        int r1 = input.nextInt();
        int c1 = input.nextInt();
        int r2 = input.nextInt();
        int c2 = input.nextInt();

        int sol1;
        if (r1 == r2 || c1 == c2) sol1 = 1;
        else sol1 = 2;

        int sol2;
        if ((Math.abs(r1 - r2) + Math.abs(c1 - c2)) % 2 == 1) sol2 = 0;
        else if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) sol2 = 1;
        else sol2 = 2;

        int length = Math.abs(r1 - r2);
        int width = Math.abs(c1 - c2);
        int sol3 = Math.max(length, width);

        System.out.println(sol1 + " " + sol2 + " " + sol3);
        input.close();
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int r1 = scn.nextInt();
        int c1 = scn.nextInt();
        int r2 = scn.nextInt();
        int c2 = scn.nextInt();
        int rook = 0, bishop = 0, king = 0;
        if (r1 == r2 || c1 == c2) {
            rook = 1;
        } else {
            rook = 2;
        }

        if (Math.abs(r1 - r2) == Math.abs(c1 - c2)){
          bishop = 1;
        }
        else if ((r1 + c1) % 2 != (r2 + c2) % 2){
            bishop =0;
        }else{
            bishop=2;
        }
        king = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
        System.out.println(rook+" "+bishop+" "+king);
    }
}

import java.util.Scanner;
public class RookBishopKing{
  public static void main(String[] args){
    Scanner scan=new Scanner(System.in);
    int rook=0;
    int bishop=0;
    int king=0;
    int r1=scan.nextInt();
    int c1=scan.nextInt();
    int r2=scan.nextInt();
    int c2=scan.nextInt();
    if(r1==r2 || c1==c2){rook=1;}
    else{rook=2;}
    if(Math.abs(r1-r2)==Math.abs(c1-c2)){bishop=1;}
    else if((Math.abs(r1-r2)+Math.abs(c1-c2)) % 2==1){bishop=0;}
    else{bishop=2;}
    int count=0;
    while(!(r1==r2 && c1==c2)){
      if(r2>r1){r1++;}
      if(r1>r2){r2++;}
      if(c1>c2){c2++;}
      if(c2>c1){c1++;}
    count++;}
    king=count;
    System.out.print(rook + " " + bishop + " " + king);

  }

}

import java.util.*;

public class  Main {

	public static void main(String args[]){

	Scanner sc = new Scanner (System.in);

   int [] x;
   x = new int[4];
   for(int i=0; i<4; i++){
	   x[i] = sc.nextInt();
   }

	int k = x[0] - x[2];
	int m = x[1] - x[3];
	int n = k - m;
	n = n>=0 ? n : n*-1;
	k = k>=0 ? k : k*-1;
	m = m>=0 ? m : m*-1;

	int Rook = (k==0 || m==0) ? 1 : 2;
	int Bishop = (k == 0 || m == 0) ? (k==0) ? (m%2 == 0) ? 2 : 0 : (k%2 == 0) ? 2 : 0 : (k==m) ? 1 : (n%2 == 0) ? 2 : 0 ;
	int King = (k==m) ? k : k>m ? k : m;

	System.out.println(Rook+" "+Bishop+" "+King);

}
}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Vishal Burman
 */
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);
        ARookBishopAndKing solver = new ARookBishopAndKing();
        solver.solve(1, in, out);
        out.close();
    }

    static class ARookBishopAndKing {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int r1 = in.nextInt();
            int c1 = in.nextInt();
            int r2 = in.nextInt();
            int c2 = in.nextInt();

            int ans1 = 0;
            int ans2 = 0;
            int ans3 = 0;
            //for rook
            if (r1 == r2 || c1 == c2)
                ans1 = 1;
            else
                ans1 = 2;

            //for bishop
            if ((r1 + c1) % 2 == (r2 + c2) % 2) {
                if (Math.abs(r1 - r2) == Math.abs(c1 - c2))
                    ans2 = 1;
                else
                    ans2 = 2;
            }

            //for king
            ans3 = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
            out.println(ans1 + " " + ans2 + " " + ans3);
        }

    }

    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 interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

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

public class Main{
    public static void main(String args[]) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        boolean [][]board = new boolean[9][9];

        for(int i = 1 ; i <=8 ;i++){
            boolean now = false;
            if(i % 2 == 1) now = true;
            board[i][1] = now;
            for(int j = 2; j <=8 ; j++){
                board[i][j] = !board[i][j-1];
            }
        }

        String s[] = br.readLine().split(" ");
        int r1 = Integer.parseInt(s[0]);
        int c1 = Integer.parseInt(s[1]);
        int r2 = Integer.parseInt(s[2]);
        int c2 = Integer.parseInt(s[3]);

        int rook = (r1 == r2 || c1 == c2) ? 1 : 2;

        int deltac = Math.abs(c2-c1);
        int deltar = Math.abs(r2-r1);
        int king = (deltar >= deltac) ? deltar : deltac ;

        int bishop = 0;
        if(board[r1][c1] == board[r2][c2]){
            if(Math.abs(r1-r2) == Math.abs(c1-c2))
                bishop = 1;
            else
                bishop = 2;
        }

        System.out.println(rook+" "+bishop+" "+king);
    }
}

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

public class RookBishopAndKing {
    public static void main(String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(f.readLine());
        int r1 = Integer.parseInt(st.nextToken());
        int c1 = Integer.parseInt(st.nextToken());
        int r2 = Integer.parseInt(st.nextToken());
        int c2 = Integer.parseInt(st.nextToken());
        System.out.print((r1==r2?0:1)+(c1==c2?0:1)+" ");
        if ((r1+c1+r2+c2) % 2 == 1)
            System.out.print("0 ");
        else if (Math.abs(r1-r2) == Math.abs(c1-c2))
            System.out.print("1 ");
        else
            System.out.print("2 ");
        System.out.println(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
    }
}

import java.util.Scanner;

public class Div2Round217A {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int r1 = in.nextInt();
		int c1 = in.nextInt();
		int r2 = in.nextInt();
		int c2 = in.nextInt();
		// rook
		System.out.print((r1 == r2 || c1 == c2) ? 1 : 2);
		// bishop
		if ((r1 + c1)%2 != (r2 + c2)%2)
			System.out.print(" 0 ");
		else if (Math.abs(r2 - r1) == Math.abs(c2 - c1))
			System.out.print(" 1 ");
		else
			System.out.print(" 2 ");
		// king
		System.out.println(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));

	}

}

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

public class Main {
	public static void main(String[] args) {
		Scanner fi = new Scanner (System.in);
		PrintWriter fo = new PrintWriter (System.out);
		int x = fi.nextInt(),
			y = fi.nextInt(),
			u = fi.nextInt(),
			v = fi.nextInt();

		fo.print((x == u || y == v ? 1 : 2) + " ");

		if (((x & 1) == (y & 1)) ^ ((u & 1) == (v & 1))) fo.print(0);
		else
			fo.print(x + y == u + v || x - y == u - v ? 1 : 2);

		fo.print(" " + Math.max(Math.abs(x - u), Math.abs(v - y)));

		fi.close();
		fo.close();
	}
}

import java.util.*;

/**
 * @Author : Eroui Abdelaziz
 * @Verdic : AC
 */

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

		int x1 = in.nextInt();
		int y1 = in.nextInt();
		int x2 = in.nextInt();
		int y2 = in.nextInt();

		System.out.print(((x1==x2 || y1 == y2)? "1": "2")+" ");
		if ((x1 + y1) % 2 != (x2 + y2) % 2)
			System.out.print("0 ");
		else {
	        if (x1 + y1 == x2 + y2 || x1 - y1 == x2 - y2)
	        	System.out.print("1 ");
	        else
	        	System.out.print("2 ");
	    }
		System.out.println(Math.max(Math.abs(x1-x2), Math.abs(y1-y2))+" ");

	}

}

import java.util.*;
import java.io.*;
public class a {
public static void main(String[] args) throws IOException
{
    //input.init(System.in);
    Scanner input = new Scanner(System.in);
    PrintWriter out = new PrintWriter(System.out);
    int r1 = input.nextInt(), c1 = input.nextInt(), r2 = input.nextInt(), c2 = input.nextInt();
    int rook = 2;
    if(r1 == r2 || c1 == c2) rook = 1;
    int bishop = 2;
    if((r1+c1) %2 != (r2+c2)%2) bishop = 0;
    else if(r1+c1 == r2+c2 || r1 - c1 == r2 - c2) bishop = 1;
    int king = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
    out.println(rook+" "+bishop+" "+king);
    out.close();
}
public static class input {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /** get next word */
    static String next() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

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

    static double nextDouble() throws IOException {
        return Double.parseDouble( next() );
    }
    static long nextLong() throws IOException {
        return Long.parseLong( next() );
    }
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class CF370A {

    static class Info{
        int x;
        int y;
        Info(int x,int y){
            this.x = x;
            this.y = y;
        }
    }
    public static void main(String[] args) {
        FastReader input = new FastReader();
        PrintWriter pw = new PrintWriter(System.out);

        int x1 = input.nextInt();
        int y1 = input.nextInt();
        int x2 = input.nextInt();
        int y2 = input.nextInt();

        int rook = 0;

        if(x1 == x2 && y1  == y2)
            rook = 0;
        else{
            if(x1 == x2 || y1 == y2)
                rook = 1;
            else
                rook = 2;
        }

        int bisop = 0;

        if(x1 == x2 && y1 == y2){
            bisop = 0;
        }
        else{
            int tempX = x1;
            int tempY = y1;

            // left diag
            boolean left = false;

            while (tempX >= 1 && tempY >= 1){
                tempX--;
                tempY--;
                if(tempX == x2 && tempY == y2){
                    left = true;
                    break;
                }
            }
            boolean right = false;
            tempX = x1;
            tempY = y1;

            while (tempX >= 1 && tempY <= 8){
                tempY++;
                tempX--;
                if(tempX == x2 && tempY == y2){
                    right = true;
                    break;
                }
            }
            boolean downLeft = false;
            tempX = x1;
            tempY = y1;

            while (tempX <= 8 && tempY >= 1){
                tempX++;
                tempY--;
                if(tempX == x2 && tempY == y2){
                    downLeft = true;
                  //  System.out.println("Here");
                    break;
                }
            }
            boolean downRight = false;
            tempX = x1;
            tempY = y1;

            while (tempX <= 8 && tempY <= 8){
                tempX++;
                tempY++;
                if(tempX == x2 && tempY == y2){
                    downRight = true;
                    break;
                }
            }
            if(left || right || downLeft || downRight){
                bisop = 1;
            }
            else{
                boolean[][] visited = new boolean[9][9];
                int[][] level = new int[9][9];

                for(int i = 1;i <= 8;i++){
                    for(int j = 1;j <= 8;j++){
                        level[i][j] = Integer.MAX_VALUE;
                    }
                }

                LinkedList<Info> queue = new LinkedList<Info>();
                queue.add(new Info(x1,y1));
                visited[x1][y1] = true;
                level[x1][y1] = 0;

                while (!queue.isEmpty()){
                    Info curr = queue.poll();

                    int x = curr.x;
                    int y = curr.y;

                    if(x+1 <= 8 && y+1 <= 8){
                        if(!visited[x+1][y+1]){
                            visited[x+1][y+1] = true;
                            level[x+1][y+1] = Math.min(level[x+1][y+1],level[x][y]+1);
                            queue.add(new Info(x+1,y+1));
                        }
                    }

                    if(x-1 >= 1 && y-1 >= 1){
                        if(!visited[x-1][y-1]){
                            visited[x-1][y-1] = true;
                            level[x-1][y-1] = Math.min(level[x-1][y-1],level[x][y]+1);
                            queue.add(new Info(x-1,y-1));
                        }
                    }

                    if(x+1 <= 8 && y-1 >= 1){
                        if(!visited[x+1][y-1]){
                            visited[x+1][y-1] = true;
                            level[x+1][y-1] = Math.min(level[x+1][y-1],level[x][y]+1);
                            queue.add(new Info(x+1,y-1));
                        }
                    }

                    if(x-1 >= 1 && y+1 <= 8){
                        if(!visited[x-1][y+1]){
                            visited[x-1][y+1] = true;
                            level[x-1][y+1] = Math.min(level[x-1][y+1],level[x][y]+1);
                            queue.add(new Info(x-1,y+1));
                        }
                    }

                }

                if(visited[x2][y2]){
                    bisop = 2;
                }
                else{
                    bisop = 0;
                }
            }
        }

        int king = 0;

        if(x1 == x2 && y1 == y2){
            king = 0;
        }
        else{
            boolean[][] visited = new boolean[9][9];
            int[][] level = new int[9][9];

            for(int i = 1;i <= 8;i++){
                for(int j = 1;j <= 8;j++){
                    level[i][j] = Integer.MAX_VALUE;
                }
            }

            LinkedList<Info> queue = new LinkedList<Info>();
            queue.add(new Info(x1,y1));
            visited[x1][y1] = true;
            level[x1][y1] = 0;

            while (!queue.isEmpty()){
                Info curr = queue.poll();

                int x = curr.x;
                int y = curr.y;

                if(x+1 <= 8 && y+1 <= 8){
                    if(!visited[x+1][y+1]){
                        visited[x+1][y+1] = true;
                        level[x+1][y+1] = Math.min(level[x+1][y+1],level[x][y]+1);
                        queue.add(new Info(x+1,y+1));
                    }
                }

                if(x-1 >= 1 && y-1 >= 1){
                    if(!visited[x-1][y-1]){
                        visited[x-1][y-1] = true;
                        level[x-1][y-1] = Math.min(level[x-1][y-1],level[x][y]+1);
                        queue.add(new Info(x-1,y-1));
                    }
                }

                if(x+1 <= 8 && y-1 >= 1){
                    if(!visited[x+1][y-1]){
                        visited[x+1][y-1] = true;
                        level[x+1][y-1] = Math.min(level[x+1][y-1],level[x][y]+1);
                        queue.add(new Info(x+1,y-1));
                    }
                }

                if(x-1 >= 1 && y+1 <= 8){
                    if(!visited[x-1][y+1]){
                        visited[x-1][y+1] = true;
                        level[x-1][y+1] = Math.min(level[x-1][y+1],level[x][y]+1);
                        queue.add(new Info(x-1,y+1));
                    }
                }

                if(x-1 >= 1 && y >= 1 && y <= 8){
                    if(!visited[x-1][y]){
                        visited[x-1][y] = true;
                        level[x-1][y] = Math.min(level[x-1][y],level[x][y] + 1);
                        queue.add(new Info(x-1,y));
                    }
                }
                // down
                if(x+1 <= 8 && y >= 1 && y <= 8){
                    if(!visited[x+1][y]){
                        visited[x+1][y] = true;
                        level[x+1][y] = Math.min(level[x+1][y],level[x][y] + 1);
                        queue.add(new Info(x+1,y));
                    }
                }
                // left
                if(y-1 >= 1 && x >= 1 && x <= 8){
                    if(!visited[x][y-1]){
                        visited[x][y-1] = true;
                        level[x][y-1] = Math.min(level[x][y-1],level[x][y] + 1);
                        queue.add(new Info(x,y-1));
                    }
                }

                // right
                if(y+1 <= 8 && x >= 1 && x <= 8){
                    if(!visited[x][y+1]){
                        visited[x][y+1] = true;
                        level[x][y+1] = Math.min(level[x][y+1],level[x][y] + 1);
                        queue.add(new Info(x,y+1));
                    }
                }

            }

            king = level[x2][y2];
        }

        pw.println(rook + " " + bisop + " " + king);

        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.*;
    import java.io.*;
    public class Main {
        public static long mod= (long) (1e9 +7);
        public static void main(String args[]){
            InputReader s= new InputReader(System.in);
            OutputStream outputStream= System.out;
            PrintWriter out= new PrintWriter(outputStream);
            int r1= s.nextInt();
            int c1= s.nextInt();
            int r2= s.nextInt();
            int c2= s.nextInt();
            if(r1==r2 || c1==c2){
                out.print("1 ");
            }
            else{
                out.print("2 ");
            }
            if(r1%2!=0 && c1%2!=0 || r1%2==0 && c1%2==0){
                if(r2%2!=0 && c2%2!= 0 || r2%2==0 && c2%2==0){
                    if(Math.abs(r1-r2)==Math.abs(c1-c2)){
                        out.print("1 ");
                    }
                    else{
                        out.print("2 ");
                    }
                }
                else{
                    out.print("0 ");
                }
            }
            else{
                if(r2%2!=0 && c2%2!=0|| r2%2==0 && c2%2==0){
                    out.print("0 ");
                }
                else{
                    if(Math.abs(r1-r2)==Math.abs(c1-c2)){
                        out.print("1 ");
                    }
                    else{
                        out.print("2 ");
                    }
                }
            }
            out.println(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
            out.close();
        }
        static class InputReader {

            public BufferedReader reader;
            public StringTokenizer tokenizer;

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

            public 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;
            }
            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 long nextLong() {
                  return Long.parseLong(next());
                }
            public int nextInt() {
              return Integer.parseInt(next());
            }
          }
        public static int gcd(int number1, int number2) {
            if(number2 == 0){
                return number1;
            }
            return gcd(number2, number1%number2);
        }
        public static int combinations(int n,int r){
            if(n==r) return 1;
            if(r==1) return n;
            if(r==0) return 1;
            return combinations(n-1,r)+ combinations(n-1,r-1);
        }

        public static int expo(int a, int b){
            if (b==1)
                return a;
            if (b==2)
                return a*a;

            if (b%2==0){
                    return expo(expo(a,b/2),2);
            }
            else{
                return a*expo(expo(a,(b-1)/2),2);
            }
        }

        public static void sieve(int N){
            int arr[]= new int[N+1];
            for(int i=2;i<Math.sqrt(N);i++){
                if(arr[i]==0){
                    for(int j= i*i;j<= N;j= j+i){
                        arr[j]=1;
                    }
                }
            }
            // All the i for which arr[i]==0 are prime numbers.
        }
    }

import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.InputMismatchException;
import java.util.Scanner;
import java.util.TreeSet;

public class Solution
{
    public static void main(String[] args) {
        new Solution().solve();
    }
    PrintWriter out;

    //long mod=1000000007L ;
    public void solve()
    {
        out=new PrintWriter(System.out);
        int r1=in.nextInt();
        int c1=in.nextInt();

        int r2=in.nextInt();
        int c2=in.nextInt();

        int ans1,ans2;
        if(r1==r2 || c1==c2)
        {
            ans1=1;
        }
        else
        {
            ans1=2;
        }

        if((r1+c1)%2!=(r2+c2)%2)
        {
            ans2=0;
        }
        else if(Math.abs(r1-r2)==Math.abs(c1-c2))
        {
            ans2=1;
        }
        else
        {
            ans2=2;;

        }

        System.out.println(ans1+" "+ans2+" "+Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));

        out.close();
    }

    public void solve1()
    {

        out=new PrintWriter(System.out);
        int n=in.nextInt();
        int m=in.nextInt();
        boolean[][] arr=new boolean[n+2][m+2];
        int[][] d=new int[n+2][m+2];
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                arr[i][j]=true;
            }
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(arr[i][j])
                {
                    if(arr[i-1][j])
                    {
                        d[i][j]++;
                    }
                    if(arr[i+1][j])
                    {
                        d[i][j]++;
                    }
                    if(arr[i][j-1])
                    {
                        d[i][j]++;
                    }
                    if(arr[i][j+1])
                    {
                        d[i][j]++;
                    }
                }
            }
        }

        ArrayList<point> list=new ArrayList<point>();
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(d[i][j]==1)
                {
                    list.add(new point(i,j));
                }
            }
        }

        char[][] ans=new char[n+2][m+2];
        while(!list.isEmpty())
        {
            point temp=list.remove(0);
            int i=temp.x;
            int j=temp.y;
            if((int)ans[i][j]==0)
            {
                if(arr[i-1][j])
                {
                    //d[i][j]++;
                    ans[i-1][j]='<';
                    ans[i][j]='>';
                }
                if(arr[i+1][j])
                {
                    d[i][j]++;
                }
                if(arr[i][j-1])
                {
                    d[i][j]++;
                }
                if(arr[i][j+1])
                {
                    d[i][j]++;
                }
            }
        }
        out.close();
    }

    public class point
    {
        int x;
        int y;
        public point(int x,int y)
        {
            this.x=x;
            this.y=y;
        }
    }

    public class UF {

        private int[] parent;  // parent[i] = parent of i
        private byte[] rank;   // rank[i] = rank of subtree rooted at i (never more than 31)
        private int count;
        int[] seg;
        int max;
        // number of components
        public UF(int N) {
            if (N < 0) throw new IllegalArgumentException();
            count = N;
            parent = new int[N];
            rank = new byte[N];
            seg=new int[N];
            for (int i = 0; i < N; i++) {
                parent[i] = i;
                rank[i] = 0;
                seg[i]=1;
            }
            max=1;
        }

        public int find(int p) {
            if (p < 0 || p >= parent.length) throw new IndexOutOfBoundsException();
            while (p != parent[p]) {
                parent[p] = parent[parent[p]];    // path compression by halving
                p = parent[p];
            }
            return p;
        }

        public int count() {
            return count;
        }

        public boolean connected(int p, int q) {
            return find(p) == find(q);
        }

        public boolean union(int p, int q) {
            //  System.out.println("uf "+p+" "+q);
            int rootP = find(p);
            int rootQ = find(q);
            if (rootP == rootQ) return false;

            // make root of smaller rank point to root of larger rank
            if      (rank[rootP] < rank[rootQ])
            {
                parent[rootP] = rootQ;
                seg[rootQ]+=seg[rootP];
                max=Math.max(seg[rootQ],max);
            }
            else if (rank[rootP] > rank[rootQ])
            {
                parent[rootQ] = rootP;
                seg[rootP]+=seg[rootQ];
                max=Math.max(seg[rootP],max);
            }
            else {
                parent[rootQ] = rootP;
                rank[rootP]++;
                seg[rootP]+=seg[rootQ];
                max=Math.max(seg[rootP],max);
            }
            count--;
            return true;
        }

    }

    class segTree
    {
        //  int N =(int) 1e5; // limit for array size
        int n;  // array size
        long[] sum;

        public segTree(long[] arr)
        {
            n=arr.length;
            sum=new long[3*n];
            for(int i=0;i<arr.length;i++)
            {
                sum[i+n]=arr[i];
            }
            build();
            //          for(int i=0;i<2*arr.length;i++)
            //          {
            //              System.out.print(max[i]+" ");
            //          }
            //          System.out.println();
            //          for(int i=0;i<2*arr.length;i++)
            //          {
            //              System.out.print(count[i]+" ");
            //          }
            //  System.out.println(Arrays.toString(max)+" "+Arrays.toString(count));
        }
        void build() {  // build the tree
            for (int i = n - 1; i > 0; --i)
            {
                if(sum[i<<1]!=sum[i<<1|1])
                {
                    sum[i] =sum[i<<1] | sum[i<<1|1];
                }
                else
                {
                    sum[i]=sum[i<<1];
                }
            }
        }

        void modify(int p, int value) {  // set value at position p
            for (sum[p += n] = value; p > 1; p >>= 1) sum[p>>1] = sum[p] | sum[p^1];
        }

        long query(int l, int r) {  // sum on interval [l, r)
            //  System.out.println(Arrays.toString(sum)+" "+l+" "+ r);
            long ans=0L;
            for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
                if ((l&1)!=0)
                {
                    ans|=sum[l];
                    l++;
                }
                if ((r&1)!=0)
                {
                    --r;
                    ans|=sum[r];
                }
            }
            return ans;
        }
    }

    class qq implements Comparable<qq>
    {
        long sqrn;
        int l,r;
        int idx;
        public qq(int idx,int l,int r)
        {
            this.l=l;
            this.idx=idx;
            this.r=r;
        }

        @Override
        public int compareTo(qq o) {
            // TODO Auto-generated method stub
            if(this.l/sqrn==o.l/sqrn)
            {
                return Integer.compare(this.r, o.r);
            }
            else
            {
                return Integer.compare(this.l,o.l);
            }
        }

        public String toString()
        {
            return "{ "+this.idx+" "+this.l+" "+this.r+" }";
        }

    }

    //  public void add(int x)
    //  {
    //      System.out.println("Add "+x);
    //      count[arr[x]]++;
    //      if(count[arr[x]]==c)
    //      {
    //          for(int i=0;i<3;i++)
    //          {
    //              if(s[i]==-1)
    //              {
    //                  answer++;
    //                  s[i]=arr[x];
    //                  break;
    //              }
    //          }
    //      }
    //      else if(count[arr[x]]>c)
    //      {
    //          if(s[0]!=arr[x] && s[1]!=arr[x] && s[2]!=arr[x])
    //          {
    //              for(int i=0;i<3;i++)
    //              {
    //                  if(s[i]==-1)
    //                  {
    //                      answer++;
    //                      s[i]=arr[x];
    //                      break;
    //                  }
    //              }
    //          }
    //      }
    //  for(int i=0;i<10;i++)
    //  {
    //      System.out.print(count[i]+" ");
    //  }
    //  System.out.println();
    //      System.out.println(answer);
    //  }
    //
    //  public void remove(int x)
    //  {
    //      count[arr[x]]--;
    //      System.out.println("remove " +x);
    //      if(count[arr[x]]==c-1)
    //      {
    //          for(int i=0;i<3;i++)
    //          {
    //              if(s[i]==arr[x])
    //              {
    //                  answer--;
    //                  s[i]=-1;
    //                  break;
    //              }
    //          }
    //      }
    //      else if(count[arr[x]]>c)
    //      {
    //          if(s[0]!=arr[x] && s[1]!=arr[x] && s[2]!=arr[x])
    //          {
    //              for(int i=0;i<3;i++)
    //              {
    //                  if(s[i]==-1)
    //                  {
    //                      answer++;
    //                      s[i]=arr[x];
    //                      break;
    //                  }
    //              }
    //          }
    //      }
    //      for(int i=0;i<10;i++)
    //      {
    //          System.out.print(count[i]+" ");
    //      }
    //      System.out.println();
    //      System.out.println(answer);
    //  }

    //
    //      long pow(long a,int n,long m)
    //      {
    //          if(n==1)
    //              return a;
    //          if(n==0)
    //              return 1;
    //          long ans=pow(a,n/2,m);
    //          ans*=ans;
    //          ans%=m;
    //          if(n%2!=0)
    //              ans*=a;
    //          ans%=m;
    //          return ans;
    //      }

    public static int gcd(long a, long b) {
        BigInteger b1 = BigInteger.valueOf(a);
        BigInteger b2 = BigInteger.valueOf(b);
        BigInteger gcd = b1.gcd(b2);
        return gcd.intValue();
    }

    FasterScanner in=new FasterScanner();

    public static class FasterScanner {
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

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

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

        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 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 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 int[] nextIntArray(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextInt();
            }
            return arr;
        }

        public long[] nextLongArray(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = nextLong();
            }
            return arr;
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
    }
}

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.ArrayList;
import java.util.Collections;
import java.lang.Math;

public class Lo {
    public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
      int x1 = sc.nextInt();
      int y1 = sc.nextInt();
      int x2 = sc.nextInt();
      int y2 = sc.nextInt();
      if(x1==x2 || y1==y2){
          System.out.print(1+" ");
      }
      else{
          System.out.print(2+" ");
      }
      if((x1+x2)%2 != (y1+y2)%2){
          System.out.print(0+" ");
      }
      else if(Math.abs(x1-x2)==Math.abs(y1-y2)){
          System.out.print(1+" ");
      }
      else{
          System.out.print(2+" ");
      }
      System.out.print(Math.max(Math.abs(x1-x2),Math.abs(y1-y2)));
    }
}

//package com.prituladima.codeforce.a2oj.div2A;

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

import static java.lang.Math.abs;
import static java.util.stream.IntStream.range;

public class Pro84 {

    private void solve() {

        int x1 = nextInt(), y1 = nextInt(), x2 = nextInt(), y2 = nextInt();

        sout(x1 != x2 && y1 != y2 ? 2 : 1);

        sout(" ");
        sout(((x1 & 1) == (y1 & 1)) == ((x2 & 1) == (y2 & 1)) ? (abs(x1 - x2) == abs(y1 - y2) ? 1 : 2) : 0);
        sout(" ");
        int ans = 0;
        while (x1 != x2 || y1 != y2){
            x1 += x2 > x1 ? 1 : x2 < x1 ? -1 : 0;
            y1 += y2 > y1 ? 1 : y2 < y1 ? -1 : 0;
            ans++;
        }
        sout(ans);

    }

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

    private BufferedReader reader;
    private StringTokenizer tokenizer;
    private PrintWriter writer;

    private void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    private int nextInt() {
        return Integer.parseInt(nextToken());
    }

    private long nextLong() {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    private int[] nextArr(int size) {
        return Arrays.stream(new int[size]).map(c -> nextInt()).toArray();
    }

    private long[] nextArrL(int size) {
        return Arrays.stream(new long[size]).map(c -> nextLong()).toArray();
    }

    private double[] nextArrD(int size) {
        return Arrays.stream(new double[size]).map(c -> nextDouble()).toArray();
    }

    private char[][] nextCharMatrix(int n) {
        return range(0, n).mapToObj(i -> nextToken().toCharArray()).toArray(char[][]::new);
    }

    private int[][] nextIntMatrix(int n, int m) {
        return range(0, n).mapToObj(i -> nextArr(m)).toArray(int[][]::new);
    }

    private double[][] nextDoubleMatrix(int n, int m) {
        return range(0, n).mapToObj(i -> nextArr(m)).toArray(double[][]::new);
    }

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

    private void soutn() {
        writer.println();
    }

    private void soutn(Object o) {
        writer.println(o);
    }

    private void sout(Object o) {
        writer.print(o);
    }

    private void souf(String format, Object... args) {
        writer.printf(format, args);
    }

    private <Param> void sout(Param[] arr) {
        writer.println(Arrays.toString(arr));
    }

}

import java.util.*;
public class chessBoard {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int xs=scn.nextInt();
		int ys=scn.nextInt();
		int xd=scn.nextInt();
		int yd=scn.nextInt();

		if(xd==xs || yd==ys)
			System.out.println("1");
		else
			System.out.println("2");

		if(((xs+ys)%2==0 && (xd+yd)%2==0)||((xs+ys)%2!=0 && (xd+yd)%2!=0))
		{
			if(xs+ys==xd+yd)
				System.out.println("1");
			else {
				if((xs-ys)==(xd-yd))
					System.out.println("1");
				else
					System.out.println("2");
			}
		}
		else {
			System.out.println("0");
		}

		int count=Math.min(Math.abs(xs-xd),Math.abs(ys-yd));
		if(Math.abs(xs-xd)<Math.abs(ys-yd)) {
			if(xs<=xd && ys<yd)
				ys=ys+count;
			else if(xs>=xd && ys>yd)
				ys=ys-count;
			else if(xs<=xd && ys>yd)
				ys=ys-count;
			else if(xs>=xd && ys<yd)
				ys=ys+count;
			System.out.println(count+Math.abs(ys-yd));
		}
		else if(Math.abs(xs-xd)>Math.abs(ys-yd))
		{
			if(xs<xd && ys<=yd)
				xs=xs+count;
			else if(xs>xd && ys>=yd)
				xs=xs-count;
			else if(xs<xd && ys>=yd)
				xs=xs+count;
			else if(xs>xd && ys<=yd)
				xs=xs-count;
			System.out.println(count+Math.abs(xs-xd));
		}
		else
		System.out.println(count);

	}

}

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

	public static void main(String[] args) throws IOException,NumberFormatException {
		try {
			FastScanner sc=new FastScanner();
			int r1=sc.nextInt(),c1=sc.nextInt(),r2=sc.nextInt(),c2=sc.nextInt();
			int rook=0,bishop=0,king=0;
			if(Math.abs(r2-r1)!=0) {
				rook+=1;
			}
			if(Math.abs(c2-c1)!=0) {
				rook+=1;
			}
			if((r1+c1)%2!=(r2+c2)%2) {
				bishop=0;
			}
			else {
				if(r1-c1==r2-c2||r1+c1==r2+c2) {
					bishop=1;
				}
				else {
					bishop=2;
				}
			}
			System.out.println(rook+" "+bishop+" "+(Math.max(Math.abs(r1-r2),Math.abs(c1-c2))));
		}
		catch(Exception e){
			return;
		}

	}
	public static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
                                      st=new StringTokenizer(br.readLine());
                              } catch (IOException e) {}
			return st.nextToken();
		}

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

	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.math.BigInteger;
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) {
        int r1=in.readInt();
        int c1=in.readInt();
        int r2=in.readInt();
        int c2=in.readInt();
        int b,r,k;
        if (r1==r2||c1==c2) r=1;
        else r=2;
        if((r1+c1)%2!=(r2+c2)%2) b=0;
        else if (Math.abs(r1-r2)==Math.abs(c1-c2)) b=1;
        else b=2;
        k=Math.max(Math.abs(r1-r2),Math.abs(c1-c2));
        out.println(r+" "+b+" "+k);
    }
}

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);
        }
}

import java.util.*;
public class Ques1{
public static void main(String args[]){
Scanner in=new Scanner(System.in);
int x1=in.nextInt();
int y1=in.nextInt();
int x2=in.nextInt();
int y2=in.nextInt();
int rook=find_rook(x1,y1,x2,y2);
int bishop=find_bishop(x1,y1,x2,y2);
int king=find_king(x1,y1,x2,y2);
System.out.println(rook+" "+bishop+" "+king);

}
private static int find_rook(int x1,int y1,int x2,int y2){
if(x1==x2 || y1==y2)
  return 1;
  else
   return 2;

}

private static int find_bishop(int x1,int y1,int x2,int y2){
if((x1+y1)%2==(x2+y2)%2){
if(((x1-y1) ==(x2-y2)) || ((x1+y1) ==(x2+y2)))
     return 1;
     else
      return 2;

}
else
 return 0;
}

private static int find_king(int x1,int y1,int x2,int y2){
int k=Math.max(Math.abs(x1-x2),Math.abs(y1-y2));
return k;
}
}

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author bone
 */
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) {
        int r1 = in.readInt();
        int c1 = in.readInt();
        int r2 = in.readInt();
        int c2 = in.readInt();

        int a;
        int b;
        int c;

        if (r1 != r2 && c1 != c2) {
            a = 2;
        } else {
            a = 1;
        }

        if ((r1 + c1) % 2 == (r2 + c2) % 2) {
            if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) {
                b = 1;
            } else {
                b = 2;
            }
        } else {
            b = 0;
        }

        c = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));

        out.println(a + " " + b + " " + c);
    }
}

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 static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    }

// author: Ahmed A.M
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //S1 p1 = new S1();   p1.solve();
        //S2 p2 = new S2();   p2.solve();
        //S3 p3 = new S3();   p3.solve();
        //S4 p4 = new S4();   p4.solve();
        //S5 p5 = new S5();   p5.solve();
        //S6 p6 = new S6();   p6.solve();
        //S7 p7 = new S7();   p7.solve();
        //S8 p8 = new S8();   p8.solve();
        //S9 p9 = new S9();   p9.solve();
        //S10 p10 = new S10();    p10.solve();
        //S11 p11 = new S11();    p11.solve();
        //S12 p12 = new S12();    p12.solve();
        //S13 p13 = new S13();    p13.solve(); *  confusing
        //S14 p14 = new S14();    p14.solve();
        //S15 p15 = new S15();    p15.solve();
        //S16 p16 = new S16();    p16.solve();
        //S17 p17 = new S17();    p17.solve();
        //S18 p18 = new S18();    p18.solve(); * without help?
        //S19 p19 = new S19();    p19.solve(); * without set ?
        //S20 p20 = new S20();    p20.solve(); * confusing * Data Types
        //S21 p21 = new S21();    p21.solve(); * confusing and fuzzy thinking
        //S22 p22 = new S22();    p22.solve();
        //S23 p23 = new S23();    p23.solve(); * very annoying problem in very annoying moments
        //S24 p24 = new S24();    p24.solve();
        //S25 p25 = new S25();    p25.solve();
        //S26 p26 = new S26();    p26.solve();
        //S27 p27 = new S27();    p27.solve();
        //S28 p28 = new S28();    p28.solve();
        //S29 p29 = new S29();    p29.solve();
        //S30 p30 = new S30();    p30.solve();
        //S31 p31 = new S31();    p31.solve();
        //S32 p32 = new S32();    p32.solve();
        //S33 p33 = new S33();    p33.solve();
        //S34 p34 = new S34();    p34.solve();
        //S35 p35 = new S35();    p35.solve();
        //S36 p36 = new S36();    p36.solve(); * Repeated mistakes
        //S37 p37 = new S37();    p37.solve();
        //S38 p38 = new S38();    p38.solve();
        //S39 p39 = new S39();    p39.solve(); * Not good
        //S40 p40 = new S40();    p40.solve();
        //S41 p41 = new S41();    p41.solve(); * Observations
        //S42 p42 = new S42();    p42.solve();
        //S43 p43 = new S43();    p43.solve(); * don't understand it
        //S45 p45 = new S45();    p45.solve(); * 2
        //S46 p46 = new S46();    p46.solve(); * 1
        //S47 p47 = new S47();    p47.solve(); * 1
        //S48 p48 = new S48();    p48.solve(); * 1
        //S49 p49 = new S49();    p49.solve(); * 4 * Cascading of mistakes
        //S50 p50 = new S50();    p50.solve(); * 2 I've to eat now
        //S51 p51 = new S51();    p51.solve(); * 1
        //S52  p52 = new S52();  p52.solve();  * 2
        //S53 p53 = new S53();    p53.solve(); * 3
        //S54 p54 = new S54();    p54.solve(); * 1
        //S55 p55 = new S55();    p55.solve(); * 1
        //S56 p56 = new S56();    p56.solve(); * 1
        //S57 p57 = new S57();    p57.solve(); * 1
        //S58 p58 = new S58();    p58.solve(); * 3
        //S59 p59 = new S59();    p59.solve(); * 1
        //S60 p60 = new S60();    p60.solve(); * 1
        //S61 p61 = new S61();    p61.solve(); * 1
        //S62 p62 = new S62();    p62.solve(); * 1
        //S63 p63 = new S63();    p63.solve(); * 1
        //S64 p64 = new S64();    p64.solve(); *
        // -----
        //S67 p67 = new S67();    p67.solve(); * 2
        //S68 p68 = new S68();    p68.solve(); * 1
        //S69 p69 = new S69();    p69.solve();
        //S70 p70 = new S70();    p70.solve(); * 1
        //S71 p71 = new S71();    p71.solve();
        //S72 p72 = new S72();    p72.solve();
        //S73 p73 = new S73();    p73.solve();
        //S74 p74 = new S74();    p74.solve(); * 2
        //S78 p78 = new S78();    p78.solve(); * 1
        //S79 p79 = new S79();    p79.solve(); * 1
        //S80 p80 = new S80();    p80.solve(); * 1
        //S81 p81 = new S81();    p81.solve(); * inf
        //S82 p82 = new S82();    p82.solve(); * 2
        //S83 p83 = new S83();    p83.solve(); * 1
        //S84 p84 = new S84();    p84.solve(); * 1
        //S85 p85 = new S85();    p85.solve(); * 2
        //S86 p86 = new S86();    p86.solve(); * 1
        //S87 p87 = new S87();    p87.solve(); * ??
        //S88 p88 = new S88();    p88.solve(); * 1
        S89 p89 = new S89();    p89.solve();
    }
}
class S89 {

    public static void solve(){
        Scanner input = new Scanner(System.in);
        int r1 = input.nextInt();
        int c1 = input.nextInt();
        int r2 = input.nextInt();
        int c2 = input.nextInt();

        int dr = Math.abs(r1-r2);
        int dc = Math.abs(c1-c2);

        int r, b, k;
        r = dr == 0 || dc == 0 ? 1 : 2;
        b = (((dr ^ dc) & 1) == 0) ? (dr == dc ? 1 : 2) : 0;
        k = dr + dc - Math.min(dr, dc);

        System.out.println(r+" "+b+" "+k);
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt(); //odd
        int c1 = sc.nextInt(); //odd
        int r2 = sc.nextInt(); //odd
        int c2 = sc.nextInt(); //odd

        int rook = 0;
        int bishop = 0;
        int king = 0;
        //white odd odd
        //black ewen, odd  then     odd, ewen

        if (r1 == r2 && c1 == c2) {
            rook = 0;
            bishop = 0;
            king = 0;
        } else {
            rook = (r1 == r2 || c1 == c2) ? 1 : 2;
            bishop = ((r1 % 2 ==  c1 % 2   && r2 % 2 ==c2 % 2 ) || (r1 % 2 != c1 % 2 && r2 % 2 != c2 % 2)) ? ((Math.abs(r2 - r1) == Math.abs(c2 - c1)) ? 1 :2 ): 0;
          king = (Math.abs(r2 - r1) > Math.abs(c2 - c1)) ? Math.abs(r2 - r1) : Math.abs(c2 - c1);

        }
        System.out.printf("%d %d %d", rook, bishop, king);
    }
}

import java.util.Collections;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.Scanner;

public class card_game {
	public static void main(String args[]) {
		Scanner scn = new Scanner(System.in);
		int  r1=scn.nextInt();
		int c1=scn.nextInt();
		int r2=scn.nextInt();
		int c2=scn.nextInt();
		System.out.println(rook(r1,c1,r2,c2)+" "+bishop(r1,c1,r2,c2)+" "+king(r1,c1,r2,c2));

	 }

	private static int rook(int r1, int c1, int r2, int c2) {
		if(r1==r2 || c1==c2){
			return 1;
		}
		return 2;
	}

	private static int king(int r1, int c1, int r2, int c2) {
		// TODO Auto-generated method stub
		return Math.max(Math.abs(r1-r2), Math.abs(c1-c2));
	}

	private static int bishop(int r1, int c1, int r2, int c2) {
		if((r1+c1)%2!=(r2+c2)%2){
		return 0;
		}
		if(Math.abs(r1-r2)==Math.abs(c1-c2)){
			return 1;
		}
		return 2;
	}
}

import java.util.Scanner;

/**
 * @author manurampandit
 *
 */
public class RookBishopKing {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int r1, c1, r2, c2;
        r1 = in.nextInt();
        c1 = in.nextInt();
        r2 = in.nextInt();
        c2 = in.nextInt();
        int rookMoves, bishopMove, KingMove;
        if (r1 == r2 || c1 == c2)
            rookMoves = 1;
        else
            rookMoves = 2;
        if ((r1 + c1) % 2 != (r2 + c2) % 2)
            bishopMove = 0;
        else if ((r1 + c1) == (r2 + c2) || (r1 - r2) == (c1 - c2))
            bishopMove = 1;
        else
            bishopMove = 2;
        if(Math.abs(r1-r2)>Math.abs(c1-c2))
            KingMove= Math.abs(r1-r2);
        else
            KingMove= Math.abs(c1-c2);
        System.out.println(rookMoves + " " + bishopMove + " " + KingMove);
    }
}

import java.util.*;

public class file{
    public static int rook = 0, bishop = 0, king = 0;
    public static void main(String[] args){
        Scanner scn = new Scanner(System.in);
        int sr = scn.nextInt()-1;
        int sc = scn.nextInt()-1;
        int dr = scn.nextInt()-1;
        int dc = scn.nextInt()-1;
        if(sr == dr || sc == dc){
            rook = 1;
        }else{
            rook = 2;
        }
        int[][] mat = new int[8][8];
        mat[sr][sc] = 1;
        calcbishop(sr, sc, dr, dc, mat);
        for(int i=0; i<8; i++){
            for(int j=0; j<8; j++){
                mat[i][j] = 0;
            }
        }
        calcking(sr, sc, dr, dc, mat);
        System.out.println(rook + " " + bishop + " " + king);
    }

    public static class Pair{
        int r;
        int c;
        int w;
        Pair(int r, int c, int w){
            this.r = r;
            this.c = c;
            this.w = w;
        }
    }

    public static void calcbishop(int sr, int sc, int dr, int dc, int[][] mat){
        LinkedList<Pair> queue = new LinkedList<>();
        queue.add(new Pair(sr, sc, 0));
        while(queue.size() > 0){
            Pair rem = queue.removeFirst();
            if(rem.r == dr && rem.c == dc){
                bishop = rem.w;
                break;
            }
            if(mat[rem.r][rem.c] == 2){
                continue;
            }
            mat[rem.r][rem.c] = 2;
            for(int i=1; i<=7; i++){
                if(rem.r + i < 8 && rem.c + i < 8)
                    queue.addLast(new Pair(rem.r + i, rem.c + i, rem.w + 1));
                if(rem.r + i < 8 && rem.c - i >= 0)
                    queue.addLast(new Pair(rem.r + i, rem.c - i, rem.w + 1));
                if(rem.r - i >= 0 && rem.c + i < 8)
                    queue.addLast(new Pair(rem.r - i, rem.c + i, rem.w + 1));
                if(rem.r - i >= 0 && rem.c - i >= 0)
                    queue.addLast(new Pair(rem.r - i, rem.c - i, rem.w + 1));
            }
        }
    }
    public static void calcking(int sr, int sc, int dr, int dc, int[][] mat){
        LinkedList<Pair> queue = new LinkedList<>();
        queue.add(new Pair(sr, sc, 0));
        int[][] dirs = {{1,1},{1,-1},{-1,1},{-1,-1},{1,0},{-1,0},{0,1},{0,-1}};
        while(queue.size() > 0){
            Pair rem = queue.removeFirst();
            if(rem.r == dr && rem.c == dc){
                king = rem.w;
                break;
            }
            if(mat[rem.r][rem.c] == 2){
                continue;
            }
            mat[rem.r][rem.c] = 2;
            for(int i=0; i<=7; i++){
                if(rem.r + dirs[i][0] < 8 && rem.r + dirs[i][0] >= 0 && rem.c + dirs[i][1] < 8 && rem.c + dirs[i][1] >= 0)
                    queue.addLast(new Pair(rem.r + dirs[i][0], rem.c + dirs[i][1], rem.w + 1));
            }
        }
    }
}

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

public class A
{
	String line;
	StringTokenizer inputParser;
	BufferedReader is;
	FileInputStream fstream;
	DataInputStream in;
	String FInput="";

	void openInput(String file)
	{

		if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
		else
		{
			try{
			fstream = new FileInputStream(file);
			in = new DataInputStream(fstream);
			is = new BufferedReader(new InputStreamReader(in));
			}catch(Exception e)
			{
				System.err.println(e);
			}
		}

	}

	void readNextLine()
	{
		try {
			line = is.readLine();
			inputParser = new StringTokenizer(line, " ");
			//System.err.println("Input: " + line);
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}
		catch (NullPointerException e)
		{
			line=null;

		}

	}

	int NextInt()
	{
		String n = inputParser.nextToken();
		int val = Integer.parseInt(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	long NextLong()
	{
		String n = inputParser.nextToken();
		long val = Long.parseLong(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	double NextDouble()
	{
		String n = inputParser.nextToken();
		double val = Double.parseDouble(n);

		//System.out.println("I read this number: " + val);
		return val;
	}

	String NextString()
	{
		String n = inputParser.nextToken();
		return n;
	}

	void closeInput()
	{
		try {
			is.close();
		} catch (IOException e) {
			System.err.println("Unexpected IO ERROR: " + e);
		}

	}

	public static void main(String [] argv)
	{
		//String filePath="input.txt";
        String filePath=null;
		if(argv.length>0)filePath=argv[0];
		new A(filePath);
	}

	public A(String inputFile)
	{
		openInput(inputFile);
		StringBuilder sb = new StringBuilder();
		readNextLine();
		int x1=NextInt(), y1=NextInt();
		int x2=NextInt(), y2=NextInt();

		if(x1==x2||y1==y2)sb.append("1 ");
		else sb.append("2 ");

		int d11=x1+y1;
		int d12=x1-y1;
		int d21=x2+y2;
		int d22=x2-y2;

		int ret=2;

		if(d11%2!=d21%2)ret=0;
		else
		{
			if(d11==d21)ret=1;
			else if(d12==d22)ret=1;
		}
		sb.append(ret+" ");

		sb.append(Math.max(Math.abs(x1-x2),Math.abs(y1-y2))+" ");

    	System.out.println(sb);
		closeInput();
	}

}

import java.util.Scanner;
import java.lang.Math;

public class _370A{

	public static void main(String[] args){

		Scanner s = new Scanner(System.in);
		int x1 = s.nextInt();
		int y1 = s.nextInt();
		int x2 = s.nextInt();
		int y2 = s.nextInt();

		int rook = 0;
		if(x1 != x2){
			rook++;
		}
		if(y1 != y2){
			rook++;
		}

		int bishop = 0;
		if(Math.abs(x1-x2) == Math.abs(y1-y2)){
			bishop = 1;
		}
		else{
			if((Math.abs(x1-x2) + Math.abs(y1-y2))%2==0 && (Math.abs(x1-x2) + Math.abs(y1-y2))!=0){
				bishop = 2;
			}
		}

		int king = 0;

		if(Math.abs(x1-x2) == Math.abs(y1-y2)){
			king = Math.abs(x1-x2);
		}
		else{
			if(x1 == x2){
				king = Math.abs(y1-y2);
			}
			else if(y1 == y2){
				king = Math.abs(x1-x2);
			}
			else{
				if(Math.abs(y2-y1)>Math.abs(x2-x1)){
					king = Math.abs(y1-y2);
				}
				else{
					king = Math.abs(x1-x2);
				}
			}
		}
		System.out.println(rook + " " + bishop + " " + king);

	}
}

import java.util.Scanner;

public class CF370A {
public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	int r1 = sc.nextInt();
	int c1 = sc.nextInt();
	int r2 = sc.nextInt();
	int c2 = sc.nextInt();
	int rook;
	if(r1 == r2 || c1 == c2)
		rook = 1;
	else
		rook = 2;

	int bi;
	if(Math.abs(r1-r2) == Math.abs(c1-c2))
		bi = 1;
	else{
		if(white(r1,c1) && black(r2,c2) || (white(r2,c2) && black(r1,c1))){
			bi = 0;
		}
		else{
			bi = 2;
		}

	}
	int king;
	if(diagonalOrRow(r1,c1,r2,c2))
		king = Math.abs(c1-c2);
	else if(c1 == c2)
		king = Math.abs(r1-r2);
	else{
		if(Math.abs(r1-r2) < Math.abs(c1-c2)){
		int newColumn;
		if(c1>c2)
			newColumn = c1-Math.abs(r1-r2);
		else
			newColumn = c1+Math.abs(r1-r2);
		king = Math.abs(r1-r2) + Math.abs(newColumn - c2);
		}
		else{
			int newColumn;
			if(r1>r2)
				newColumn = r1-Math.abs(c1-c2);
			else
				newColumn = r1+Math.abs(c1-c2);
			king = Math.abs(c1-c2) + Math.abs(newColumn - r2);

		}
	}

	System.out.println(rook + " " + bi + " " + king);
}

private static boolean diagonalOrRow(int r1, int c1, int r2, int c2) {
	return r1 == r2 || Math.abs(r1-r2) == Math.abs(c1-c2);
}

private static boolean black(int r2, int c2) {
	return r2%2 == 0 && c2%2 == 1 ||(r2%2 == 1 && c2%2 == 0);
}

private static boolean white(int r1, int c1) {
	return r1%2 == 0 && c1%2 == 0 ||(r1%2 == 1 && c1%2 == 1);

}
}

import java.util.*;

public class R217Div2QA {
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		int r1 = s.nextInt(), c1 = s.nextInt();
		int r2 = s.nextInt(), c2 = s.nextInt();
		int R = 2;
		if(r1 == r2)	R--;
		if(c1 == c2)	R--;
		int B = 2;
		int dr = Math.abs(r1-r2);
		int dc = Math.abs(c1-c2);
		if(dr == dc)
			B = 1;
		else if((dr + dc) % 2 != 0){
				B = 0;
		}
		int K = 0;
		while(dr > 0 || dc > 0){
			K++;
			dr--;
			dc--;
		}

		System.out.println(R + " " + B + " " + K);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Scanner;

public class A217 {

    public void solve() throws IOException {

        Scanner sc = new Scanner(System.in);
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);

        int i = 0, j = 0, k = 0;
        long ans = 0, sum = 0, count = 0;
        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();
        int rcount = 0, bcount = 0, kcount = 0;

        if (r1 == r2 || c1 == c2) {
            rcount = 1;
        } else {
            rcount = 2;
        }

        if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) {
            bcount = 1;
        } else {
            int a[][] = new int[8][8];
            count = 1;
            for (int l = 0; l < 8; l++) {
                for (int m = 0; m < 8; m++) {
                    if (count % 2 == 0) {
                        a[l][m] = 1;
                    } else {
                        a[l][m] = 2;
                    }
                    count++;
                }
                count++;
            }
//            for (int l = 0; l < 8; l++) {
//                for (int m = 0; m < 8; m++) {
//                    System.out.print(a[l][m] + " ");
//                }
//                System.out.println("");
//            }

            if (a[r1 - 1][c1 - 1] == a[r2 - 1][c2 - 1]) {
                //System.out.println(a[r1 - 1][c1 - 1] + "  " + a[r2 - 1][c2 - 1]);
                bcount = 2;
            } else {

                bcount = 0;
            }
        }

        int kx = r1;
        int ky = c1;
        int qx = r2;
        int qy = c2;
        ArrayList<String> list = new ArrayList<String>();
        while (qx != kx || qy != ky) {
            String m = "";
            if (qx - kx > 0) {
                m += "L";
                kx++;
            } else if (qx - kx < 0) {
                m += "R";
                kx--;
            }
            if (qy - ky > 0) {
                m += "D";
                ky++;
            } else if (qy - ky < 0) {
                m += "U";
                ky--;
            }

            list.add(m);
        }
        // System.out.println(list.size());
        kcount = list.size();

        System.out.println(rcount + " " + bcount + " " + kcount);
    }

    public static void main(String[] args) throws IOException {
        new A217().solve();

    }
}

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

/**
 *
 * @author Altynbek.Nurgaziyev
 */
public class R217_D2_A {

        public void solution() throws Exception {
                int r1 = in.nextInt();
                int c1 = in.nextInt();
                int r2 = in.nextInt();
                int c2 = in.nextInt();
                int dr = Math.abs(r1 - r2);
                int dc = Math.abs(c1 - c2);
                if (dr == 0 || dc == 0) {
                        out.print(1 + " ");
                } else {
                        out.print(2 + " ");
                }
                if ((r1 + c1) % 2 == (r2 + c2) % 2) {
                        if (dr == dc) {
                                out.print(1 + " ");
                        } else {
                                out.print(2 + " ");
                        }
                } else {
                        out.print(0 + " ");
                }
                out.println(Math.max(dr, dc));
        }

        Scanner in;
        PrintWriter out;
        String input, output;

        public void run() throws Exception {
                if (input != null) {
                        in = new Scanner(new FileReader(input));
                } else {
                        in = new Scanner(System.in);
                }

                if (output != null) {
                        out = new PrintWriter(new File(output));
                } else {
                        out = new PrintWriter(System.out);
                }

                solution();

                out.close();
        }

        public static void main(String[] args) throws Exception {
                new R217_D2_A().run();
        }

        public class Scanner {

                private BufferedReader br;
                private StringTokenizer st;

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

                public Scanner(FileReader fr) {
                        br = new BufferedReader(fr);
                }

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

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

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

                public Double nextDouble() throws Exception {
                        return Double.parseDouble(next());
                }
        }
}

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

/*
 * @author Mahmoud Aladdin <aladdin3>
 *
 */

public class Main {
    public static void main (String[] args) throws java.lang.Exception {
		InputReader scan = new InputReader(System.in);
		PrintWriter writer = new PrintWriter(System.out, true);
		(new Main(scan, writer)).run();
		writer.close();
    }

    private InputReader jin;
    private PrintWriter jout;

    public Main(InputReader in, PrintWriter out) {
    	this.jin  = in;
    	this.jout = out;
    }

    public void run() throws Exception {
		int r1 = jin.integer();
		int c1 = jin.integer();
		int r2 = jin.integer();
		int c2 = jin.integer();

		int rook = ((r2 != r1)? 1: 0) + ((c2 != c1)? 1: 0);
		int king = Math.max(Math.abs(r2 - r1), Math.abs(c2 - c1));
		int bishop = 2;
		if(r1 + c1 == r2 + c2) bishop = 1;
		if(c1 - r1 == c2 - r2) bishop = 1;
		if((r1 + c1) % 2 != (r2 + c2) % 2) bishop = 0;
		jout.println(rook + " " + bishop + " " + king);
    }
}

class InputReader {
    private static final int bufferMaxLength = 1024;
    private InputStream in;
    private byte[] buffer;
    private int currentBufferSize;
    private int currentBufferTop;
    private static final String tokenizers = " \t\r\f\n";

    public InputReader(InputStream stream) {
        this.in = stream;
        buffer = new byte[bufferMaxLength];
        currentBufferSize = 0;
        currentBufferTop = 0;
    }

    private boolean refill() throws IOException {
        this.currentBufferSize = this.in.read(this.buffer);
        this.currentBufferTop = 0;
        return this.currentBufferSize > 0;
    }

    private Byte readChar() throws IOException {
        if(currentBufferTop < currentBufferSize) {
            return this.buffer[this.currentBufferTop++];
        } else {
            if(!this.refill()) {
                return null;
            } else {
                return readChar();
            }
        }
    }

    public String token() throws IOException {
        StringBuffer tok = new StringBuffer();
        Byte first;
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) != -1));
        if(first == null) return null;
        tok.append((char)first.byteValue());
        while((first = readChar()) != null && (tokenizers.indexOf((char) first.byteValue()) == -1)) {
            tok.append((char)first.byteValue());
        }
        return tok.toString();
    }

    public String line() throws IOException {
		Byte first;
		StringBuffer line = new StringBuffer();
		while ((first = readChar()) != null && (char)first.byteValue() != '\n') {
			line.append((char)first.byteValue());
		}
		return (first == null && line.length() == 0)? null : line.toString();
    }

    public Integer integer() throws NumberFormatException, IOException {
        String tok = token();
        return tok == null? null : Integer.parseInt(tok);
    }

}

//package codeforces;

import java.io.PrintWriter;
import java.util.Scanner;

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

        int r1 = in.nextInt();
        int c1 = in.nextInt();
        int r2 = in.nextInt();
        int c2 = in.nextInt();

        out.println(rook(r1, c1, r2, c2) + " "
                + bishop(r1, c1, r2, c2) + " "
                + king(r1, c1, r2, c2));
        out.flush();
    }

    private static int rook(int r1, int c1, int r2, int c2) {
        if (r1 == r2 || c2 == c1)
            return 1;
        else
            return 2;
    }

    private static int bishop(int r1, int c1, int r2, int c2) {
        int rb = Math.abs(r1 - r2) % 2 == 0 ? 1:0;
        int cb = Math.abs(c1 - c2) % 2 == 0 ? 1:0;
        if ((rb + cb) % 2 == 0) {
            if (Math.abs(r1 - r2) == Math.abs(c1 - c2))
                return 1;
            else
                return 2;
        }
        else
            return 0;
    }

    private static int king(int r1, int c1, int r2, int c2) {
        return Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
    }
}

import java.io.*;
import java.util.*;
public class Main8 {
    public static void main(String[] args)throws IOException{
        BufferedReader  buffer = new BufferedReader (new InputStreamReader(System.in)) ;
        StringTokenizer st= new StringTokenizer (buffer.readLine());
        int x1=Integer.parseInt(st.nextToken());
        int y1=Integer.parseInt(st.nextToken());
        int x2=Integer.parseInt(st.nextToken());
        int y2=Integer.parseInt(st.nextToken());
        int rook=0;
        int bishop=0;
        int king=0;
            rook=(y1==y2 || x1==x2)? 1:2;
            System.out.print(rook+" ");
            int ChangeInY=Math.abs(y2-y1);
            int ChangeInX=Math.abs(x2-x1);
            int t=Math.abs(ChangeInY-ChangeInX);

            if (ChangeInY==ChangeInX) bishop=1;
            else if (t%2==0) bishop=2;
            else bishop=0;
            System.out.print(bishop+" ");
            if (y1==y2) king=Math.abs(x2-x1);
            else if (x1==x2) king=Math.abs(y2-y1);
            else {
                while (y1!=y2 || x1!=x2){
                    if (y2>y1 && x2>x1){
                        y1++;
                        x1++;
                        king++;
                    }
                    else if (y2>y1 && x1>x2){
                        y1++;
                        x1--;
                        king++;
                    }

                else    if (y1>y2 && x2>x1){
                        y1--;
                        x1++;
                        king++;
                    }
                    else    if (y1>y2 && x1>x2){
                        y1--;
                        x1--;
                        king++;
                    }
                    else if (x1==x2){
                    king=king+(Math.abs(y2-y1));
                    y1=y2;
                    x1=x2;

                }
                else if (y1==y2){
                    king=king+(Math.abs(x2-x1));
                    y1=y2;
                    x1=x2;

                }

            }

        }
            System.out.print(king);

    }
}

//package div217;
import java.io.*;
import java.util.*;
public class A
{
	BufferedReader in=null;
	PrintWriter ob=null;
	public static void main(String args[])throws IOException
	{
		new A().Solve();
	}
	void Solve()throws IOException
	{
		in=new BufferedReader(new InputStreamReader(System.in));
		ob=new PrintWriter(System.out);
		StringTokenizer st=new StringTokenizer(in.readLine());
		int x1=Integer.parseInt(st.nextToken());
		int y1=Integer.parseInt(st.nextToken());
		int x2=Integer.parseInt(st.nextToken());
		int y2=Integer.parseInt(st.nextToken());
		int d=Integer.MAX_VALUE;
		int crook=0,bishop=0,king=0;
		if(Math.abs(x2-x1)>0 && Math.abs(y2-y1)>0)
		{
			crook=2;
		}
		else
			crook=1;
		if((Math.abs(y2-y1)==Math.abs(x2-x1)))
		{
			bishop=1;
		}
		else{
			bishop=0;
		}
		if ((x1 + y1) % 2 != (x2 + y2) % 2)
			bishop= 0;
		else {
	        if (x1 + y1 == x2 + y2 || x1 - y1 == x2 - y2)
	        	bishop= 1;
	        else
	        	bishop= 2;
	    }

		king = Math.max(Math.abs(y2-y1),Math.abs(x2-x1));
		ob.println(crook+" "+bishop+" "+king);
		ob.flush();
	}
}

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

public class Main implements Runnable {

	public void solve() throws IOException {
		int r1 = nextInt();
                int c1 = nextInt();
                int r2 = nextInt();
                int c2 = nextInt();

                int a = (r1 == r2 || c1 == c2) ? 1 : 2;
                int b = 0;
                if(Math.abs(r1 - r2) == Math.abs(c1 - c2)){
                        b = 1;
                }
                else if(Math.abs(r1 - r2) % 2 == Math.abs(c1 - c2) % 2){
                        b = 2;
                }
                else b = 0;

                int c = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));

                System.out.println(a + " " + b + " " + c);
	}

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

	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 RookiBishopKing {

    public static int rooki(int x1, int y1, int x2, int y2) {
        return ((x1 == x2) || (y1 == y2)) ? 1 : 2;
    }

    public static int bishop(int x1, int y1, int x2, int y2) {
        if ((x1 + y1) % 2 != (x2 + y2) % 2) {
            return 0;
        }
        return (Math.abs(x1 - x2) == Math.abs(y1 - y2)) ? 1 : 2;
    }

    public static int king(int x1, int y1, int x2, int y2) {
        int c = 0;
        for (; (x1 != x2) || (y1 != y2);) {
            if (y1 > y2) {
                y1--;
            }
            if (y1 < y2) {
                y2--;
            }
            if (x1 > x2) {
                x1--;
            }
            if (x1 < x2) {
                x2--;
            }
            c++;
        }
        return c += (y1==y2)?Math.abs(x1-x2):Math.abs(y1-y2);

    }

    public static void main(String[] args) {
        Scanner scr = new Scanner(System.in);
        int x1, y1, x2, y2;
        x1 = scr.nextInt();
        y1 = scr.nextInt();
        x2 = scr.nextInt();
        y2 = scr.nextInt();

        System.out.print(rooki(x1, y1, x2, y2));
        System.out.print(" ");
        System.out.print(bishop(x1, y1, x2, y2));
        System.out.print(" ");
        System.out.println(king(x1, y1, x2, y2));

    }

}

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) {
   int x1=in.nextInt(),y1=in.nextInt(),x2=in.nextInt(),y2=in.nextInt();
       int r,k,b;
        if(x1==x2||y1==y2)r=1;
        else r=2;
        if((x1+y1)%2!=(x2+y2)%2)b=0;
        else{
            if(Math.abs(x2-x1)==Math.abs(y2 - y1))b=1;
            else b=2;

        }
        int h=Math.abs(x2-x1),v=Math.abs(y2-y1);
        k=Math.min(h,v)+Math.abs(h-v);
       out.println(r+" "+b+" "+k);
    }
}

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();
        }
    }

    static boolean isWhiteSpace(int c) {
        return c >= 0 && c <= 32;
    }

    public int nextInt() {
        int c = read();
        while (isWhiteSpace(c)) {
            c = read();
        }
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int ret = 0;
        while (c >= 0 && !isWhiteSpace(c)) {
            if (c < '0' || c > '9') {
                throw new NumberFormatException("digit expected " + (char) c
                        + " found");
            }
            ret = ret * 10 + c - '0';
            c = read();
        }
        return ret * sgn;
    }

    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);
    }

}

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

/**
 * 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) {
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        StringBuilder result = new StringBuilder();
        if (x1 == x2 || y1 == y2) {
            result.append(1 + " ");
        } else {
            result.append(2 + " ");
        }
        if (Math.abs(x2 - x1) == Math.abs(y2 - y1)) {
            result.append(1 + " ");
        } else if ((Math.abs(x2 - x1) + Math.abs(y2 - y1)) % 2 == 0) {
            result.append(2 + " ");
        } else {
            result.append(0 + " ");
        }
        result.append(Math.max(Math.abs(x2 - x1), Math.abs(y2 - y1)));
        out.println(result);
    }
}

class InputReader {
    StringTokenizer tokenizer;
    BufferedReader reader;

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

    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());
    }

}

/**
 *
 */
//package codeforces;
import java.util.*;
/**
 * @author Shivansh Singh
 *
 */
public class Cf370A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int i,r1,r2,c1,c2,p,q;
		r1=sc.nextInt();
		c1=sc.nextInt();
		r2=sc.nextInt();
		c2=sc.nextInt();
		if(r1==2 && c1==c2)
			System.out.println(0+" "+0+" "+0);
		else {
		if(r1==r2 || c1==c2)
			System.out.print(1+" ");
		else
			System.out.print(2+" ");
		if((r1+c1)%2==(r2+c2)%2) {
			if(Math.abs(r1-r2)==Math.abs(c1-c2))
				System.out.print(1+" ");
			else
				System.out.print(2+" ");
		}
		else
			System.out.print(0+" ");
		p=Math.abs(r1-r2);
		q=Math.abs(c1-c2);
		if(p>=q)
			System.out.print(p);
		else
			System.out.println(q);
		}
		sc.close();
	}

}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author mark
 */
public class RookBishopKing {

    private static int[] minMaxX;
    private static int[] minMaxY;
    private static int counter = 0;

    public static void main(String[] args) throws FileNotFoundException {
        //FileInputStream str = new FileInputStream(new File("/home/mark/tmp/input.txt"));
        //Scanner scan = new Scanner(str);
        Scanner scan = new Scanner(System.in);
        int startY = scan.nextInt() - 1;
        int startX = scan.nextInt() - 1;
        int endY = scan.nextInt() - 1;
        int endX = scan.nextInt() - 1;

        int[] end = {endX, endY};
        int[] start = {startX, startY};

        int rook = 0;
        int bishop = 0;
        int king = 0;

        //Rook
        rook = Math.abs(startX - endX) > 0 ? 1 : 0;
        rook += Math.abs(startY - endY) > 0 ? 1 : 0;

        //Bishop
            List<int[]> availableMovesStart = new ArrayList<>();
            getBishopMoves(startX, startY, availableMovesStart);
            List<int[]> availableMovesEnd = new ArrayList<>();
            getBishopMoves(endX, endY, availableMovesEnd);
            if (contains(availableMovesStart, end)) {
                //bishop = countBishopMoves(start, end);
                bishop++;
            } else {
                int[] target = null;
                for (int[] move : availableMovesStart) {
                    if (contains(availableMovesEnd,move)) {
                        target=move;
                    }
                }
                if (target != null) {
//                    bishop = countBishopMoves(start, target)
//                            + countBishopMoves(target, end);
                    bishop += 2;
                }
        }
        //King
        minMaxX = new int[2];
        minMaxY = new int[2];
        if (startX > endX) {
            minMaxX[0] = endX;
            minMaxX[1] = startX;
        } else {
            minMaxX[1] = endX;
            minMaxX[0] = startX;
        }

        if (startY > endY) {
            minMaxY[0] = endY;
            minMaxY[1] = startY;
        } else {
            minMaxY[1] = endY;
            minMaxY[0] = startY;
        }

        king = getShortestPath(start, end);
        System.out.println(rook + " " + bishop + " " + king);
    }

    private static boolean contains(List<int[]> availableMoves, int[] dst) {
        for (int[] curr : availableMoves) {
            if (Arrays.equals(curr, dst)) {
                return true;
            }
        }
        return false;
    }

//    private static int countBishopMoves(int[] start, int end[]) {
//        return (int) Math.sqrt(Math.pow(start[0] - end[0], 2)
//                + Math.pow(start[1] - end[1], 2));
//    }
    private static void getBishopMoves(int startX, int startY, List<int[]> availableMoves) {
        int x = startX;
        int y = startY;

        while (x < 8 && y < 8) {
            int move[] = {x, y};
            availableMoves.add(move);
            x++;
            y++;
        }

        x = startX - 1;
        y = startY - 1;
        while (x >= 0 && y >= 0) {
            int move[] = {x, y};
            availableMoves.add(move);
            x--;
            y--;
        }

        x = startX + 1;
        y = startY - 1;
        while (x < 8 && y >= 0) {
            int move[] = {x, y};
            availableMoves.add(move);
            x++;
            y--;
        }

        x = startX - 1;
        y = startY + 1;
        while (x >= 0 && y < 8) {
            int move[] = {x, y};
            availableMoves.add(move);
            x--;
            y++;
        }

    }

    private static int getShortestPath(int[] src, int[] dst) {
            Queue<Node> unvisited = new PriorityQueue<>();
            Queue<Node> visited = new LinkedList<>();
            Node node = new Node(src[0],src[1]);
            Node dstNode = new Node(dst[0],dst[1]);
            node.distance=0;
            unvisited.add(node);
            while(!unvisited.isEmpty()){
                Node curr = unvisited.remove();
                visited.add(curr);
                List<Node> neigh = curr.getNeighbours();
                for(Node tmpNode: neigh){
                    if (tmpNode.equals(dstNode)){
                        return curr.distance+1;
                    }
                    if (!visited.contains(tmpNode) && !unvisited.contains(tmpNode)){
                        if (tmpNode.distance>curr.distance+1){
                            tmpNode.distance=curr.distance+1;
                        }
                        unvisited.add(tmpNode);
                    }
                }
            }
            return Integer.MAX_VALUE;
    }

    static class Node implements Comparable<Node> {
        int x,y;
        int distance= Integer.MAX_VALUE;

        public Node(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(Node t) {
            return this.distance-t.distance;
        }

        @Override
        public int hashCode() {
            int hash = 5;
            hash = 53 * hash + this.x;
            hash = 53 * hash + this.y;
            return hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false;
            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            final Node other = (Node) obj;
            if (this.x != other.x) {
                return false;
            }
            if (this.y != other.y) {
                return false;
            }
            return true;
        }

        private List<Node> getNeighbours() {
        List<Node> list = new ArrayList<>();
        int[] m01 = {x + 1,y};
        int[] m02 = {x,y+1};
        int[] m03 = {x - 1,y};
        int[] m04 = {x,y-1};
        int[] m05 = {x + 1,y+1};
        int[] m06 = {x-1,y-1};
        int[] m07 = {x - 1, y+1};
        int[] m08 = {x+1, y- 1};

        if (isValid(m02)) {
            list.add(new Node(m02[0],m02[1]));
        }

        if (isValid(m01)) {
            list.add(new Node(m01[0],m01[1]));
        }
        if (isValid(m03)) {
            list.add(new Node(m03[0],m03[1]));
        }
        if (isValid(m04)) {
            list.add(new Node(m04[0],m04[1]));
        }
        if (isValid(m05)) {
            list.add(new Node(m05[0],m05[1]));
        }
        if (isValid(m06)) {
            list.add(new Node(m06[0],m06[1]));
        }
        if (isValid(m07)) {
            list.add(new Node(m07[0],m07[1]));
        }
        if (isValid(m08)) {
            list.add(new Node(m08[0],m08[1]));
        }
        return list;
        }
    }

    private static boolean isValid(int[] m08) {
        if (m08[0] >= 0 && m08[0] < 8
                && m08[1] >= 0 && m08[1] < 8) {
            return true;
        } else {
            return false;
        }
    }
}

import java.util.*;
public class Main {
	public static void main (String []args){
      Scanner in = new Scanner (System.in);
      int a=in.nextInt();
       int b=in.nextInt();
        int c=in.nextInt();
     int d=in.nextInt();

      if(a==c||b==d)
   	System.out.print("1 ");
      	else System.out.print("2 ");

    if(a+b==c+d||c-a==d-b)
      		System.out.print("1 ");
      		else if((a+b+c+d)%2==0)
      System.out.print("2 ");
          else System.out.print("0 ");

          	if(d-b==c-a && d-b>0)
          		System.out.print(d-b + " ");
            else if(d-b==c-a && d-b<0)
            	System.out.print(b-d);
            else System.out.print(Math.max(Math.abs(d-b),Math.abs(c-a)));

      }
    }

/**
 * Created by Omar on 12/20/2015.
 */
import java.util.*;
import java.io.*;
public class RookBishopandKing {
public static void main(String[] args)throws Exception{

    BufferedReader br= new BufferedReader (new InputStreamReader(System.in));
    String[] parts=br.readLine().split(" ");
    int r1=Integer.parseInt(parts[0]);
    int c1=Integer.parseInt(parts[1]);
    int r2=Integer.parseInt(parts[2]);
    int c2=Integer.parseInt(parts[3]);

    int king=0;
    int x=r1,y=c1;
    while(x!=r2 || y!=c2){
        if(x>r2 && y>c2){
            x--;
            y--;
            king++;
            continue;
        }
        if(x<r2 && y<c2){
            x++;
            y++;
            king++;
            continue;
        }
        if(x>r2 && y<c2){
            x--;
            y++;
            king++;
            continue;
        }
        if(x<r2 && y>c2){
            x++;
            y--;
            king++;
            continue;
        }
        if(x>r2){
            x--;
            king++;
        }
     else   if(x<r2){
            x++;
            king++;
        }
        if(y>c2){
            y--;
            king++;
        }
        else if(y<c2){
            y++;
            king++;
        }
    }
    x=r1;
    y=c1;
    int rook=0;
    while(x!=r2 || y!=c2){
        if(x!=r2){
            x=r2; rook++;
        }
        if(y!=c2){
            y=c2; rook++;
        }
    }
    x=r1;
    y=c1;
    int bishop = 2;
    int dr = Math.abs(x-r2);
    int dc = Math.abs(y-c2);
    if(dr == dc)  bishop = 1;
    else if((dr + dc) % 2 != 0){
        bishop = 0;
    }
System.out.println(rook+" "+bishop+" "+king);
    br.close();}
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c= sc.nextInt();
        int d= sc.nextInt();
        System.out.print(rook(a,b,c,d)+ " ");
        System.out.print(bishop(a,b,c,d)+ " ");
        System.out.println(king(a,b,c,d));
    }
    public static int bishop (int a, int b, int c, int d){
        if((a+b)%2!=(c+d)%2){
            return 0;
        }
        else{
            if(Math.abs(c-a)==Math.abs(d-b)||Math.abs(c-a)==-Math.abs(d-b)){
                return 1;
            }
            else{
                return 2;
            }
        }
    }
    public static int rook(int a, int b, int c, int d){
        if(a==c||b==d){
            return 1;
        }
        else{
            return 2;
        }
    }
    public static int king(int a, int b, int c, int d){
        return(Math.max(Math.abs(a-c),Math.abs(b-d)));
    }
}

import java.util.Collections;
import java.util.HashMap;
import java.util.PriorityQueue;
import java.util.Scanner;

public class card_game {
	public static void main(String args[]) {
		Scanner scn = new Scanner(System.in);
		int  r1=scn.nextInt();
		int c1=scn.nextInt();
		int r2=scn.nextInt();
		int c2=scn.nextInt();
		System.out.println(rook(r1,c1,r2,c2)+" "+bishop(r1,c1,r2,c2)+" "+king(r1,c1,r2,c2));

	 }

	private static int rook(int r1, int c1, int r2, int c2) {
		if(r1==r2 || c1==c2){
			return 1;
		}
		return 2;
	}

	private static int king(int r1, int c1, int r2, int c2) {
		// TODO Auto-generated method stub
		return Math.max(Math.abs(r1-r2), Math.abs(c1-c2));
	}

	private static int bishop(int r1, int c1, int r2, int c2) {
		if((r1+c1)%2!=(r2+c2)%2){
		return 0;
		}
		if(Math.abs(r1-r2)==Math.abs(c1-c2)){
			return 1;
		}
		return 2;
	}
}

import java.util.Scanner;

public class A
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();

        int l = 2;
        if(r2 == r1) l--;
        if(c1 == c2) l--;

        int k;
        int dx = Math.abs(r1 - r2);
        int dy = Math.abs(c1 - c2);

        k = dx + dy - Math.min(dx, dy);

        int s;
        int mod2 = Math.abs((c1 - r1) % 2);

        if(Math.abs((c2 - r2) % 2) != mod2)
            s = 0;
        else
        {
            if(dx == dy)
            {
                if(dx == 0)
                    s = 0;
                else s = 1;
            }
            else s = 2;
        }

        System.out.print(l + " " + s + " " + k);

    }
}

import java.util.*;

/**
 * _370A
 */
public class _370A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x1 = sc.nextInt();
        int y1 = sc.nextInt();
        int x2 = sc.nextInt();
        int y2 = sc.nextInt();
        rook(x1, y1, x2, y2);
        bishop(x1, y1, x2, y2);
        king(x1, y1, x2, y2);

    }

    public static void rook(int x1,int y1,int x2,int y2) {
        if(x1==x2||y1==y2){
            System.out.print(1+" ");
        }
        else{
            System.out.print(2+" ");
        }
    }
    public static void bishop(int x1,int y1,int x2,int y2) {
        if((x1+y1)%2!=(x2+y2)%2){
            System.out.print(0+" ");
            return;
        }
        else{
        double slope=0;
        try{
         slope=(Math.abs((x1-x2)/(y1-y2)));
        }
        catch(ArithmeticException e){
            slope=0;
        }
        if(slope==1){
            System.out.print(1+" ");
        }
        else{
           System.out.print(2+" ");
        }
    }
    }
    public static void king(int x1,int y1,int x2,int y2) {
        System.out.print(Math.max(Math.abs(x1-x2),Math.abs(y1-y2))+" ");
    }
}

import java.util.Scanner;

public class ProblemA {

    public static int reduced(int r1, int c1, int r2, int c2){
        int min = Integer.MAX_VALUE;
        int cc=c1;
        int rr=r1;
        int move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
        //  System.out.println(move);
            move++;
            r1++;
            c1++;

        }
        c1=cc;
        r1=rr;
        move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1--;
            c1++;
        }
        c1=cc;
        r1=rr;
        move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1++;
            c1--;
        }
        c1=cc;
        r1=rr;
        move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1--;
            c1--;
        }
        return min;

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();
        int r, b, k;
        if(r1==r2 && c1==c2){
            r=0;
        }
        else if(r1==r2 || c1==c2){
            r=1;
        }
        else{
            r=2;
        }
        if(r1==r2 && c1==c2){
            b=0;
        }
        else if(Math.abs(r1-r2)==Math.abs(c1-c2)){
            b=1;
        }
        else if(Math.abs(Math.abs(r1-r2)-Math.abs(c1-c2))%2==1){
            b=0;
        }
        else{
            b=2;
        }
        if(r1==r2 || c1==c2){
            k=Math.abs(r1-r2)+Math.abs(c1-c2);
        }
        else
            k=reduced(r1, c1, r2, c2);
        System.out.printf("%d %d %d", r, b, k);
    }

}

import java.util.*;
public class code{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int x1=sc.nextInt();
		int y1= sc.nextInt();

		int x2= sc.nextInt();
		int y2= sc.nextInt();
		int ans1 = rook(x1,y1,x2,y2);
		int ans2 = bishob(x1,y1,x2,y2);
		int ans3 = king(x1,y1,x2,y2);
		System.out.println(ans1+" "+ans2+" "+ans3);

}

public static int rook(int x1,int y1, int x2,int y2){

	if(x1==x2 && y1==y2) return 0 ;
	if(x1==x2 || y1==y2) return 1;
	return 2 ;

}
public static int bishob(int x1,int y1, int x2,int y2){

	if(Math.abs(y2-y1)==Math.abs(x2-x1)) return 1;

	if(x1==x2 && y1==y2) return 0 ;
	if((x1+y1)%2 != (x2+y2)%2) return 0;
	return 2 ;

}

public static int king(int x1,int y1, int x2,int y2){
	return Math.max(Math.abs(y2-y1), Math.abs(x2-x1));

}

}

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

public class A {
	BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter out;

	public void solve() throws IOException {
		int R1 = nextInt();
		int C1 = nextInt();
		int R2 = nextInt();
		int C2 = nextInt();

		if (R1 == R2 && C1 == C2) {
			out.println("0 0 0"); return;
		}

		int a1 = 0;
		if(R1 != R2) a1++;
		if(C1 != C2) a1++;

		int a2 = 2;
		if (Math.abs(R2-R1) == Math.abs(C2-C1) ){
			a2 = 1;
		}
		if ( (R1 + C1) % 2 != (R2 + C2) % 2) {
			a2 = 0;
		}

		int a3 = Math.max( Math.abs(R2-R1), Math.abs(C2-C1));

		out.println(a1 + " " + a2 + " " + a3);

	}

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

	public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            reader.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

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

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

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

}

import java.util.*;
public class _370A_ {

    /**
     * @param args
     */
    private int r1;
    private int c1;
    private int r2;
    private int c2;
    private static _370A_ a;
    private static Scanner sc;

    public _370A_(int r1, int c1, int r2, int c2){
        this.r1 = r1;
        this.r2 = r2;
        this.c1 = c1;
        this.c2 = c2;
    }
    public int CheckRock(){
        if(r2 == r1 || c2 == c1)    return 1;
        else   return 2;
    }

    public void CheckBishop(){
        if((r1%2==0 && c1%2==1) || (r1%2==1 && c1%2==0)) //black
        {
            if((r2%2==0 && c2%2==1) || (r2%2==1 && c2%2==0)) //black
            {
                if(Math.abs(r2-r1) == Math.abs(c2-c1)) System.out.printf(" 1");
                else System.out.printf(" 2");
            }
            else System.out.printf(" 0");
        }

        if((r1%2==1 && c1%2==1) || (r1%2==0 && c1%2==0)) //white
        {
            if((r2%2==1 && c2%2==1) || (r2%2==0 && c2%2==0)) //white
            {
                if(Math.abs(r2-r1) == Math.abs(c2-c1)) System.out.printf(" 1");
                else System.out.printf(" 2");
            }
            else System.out.printf(" 0");
        }
        }

    public int CheckKing(){
        if(r2 == r1)    return Math.abs(c2 - c1);
        else{
            if(c2 == c1)   return Math.abs(r2 - r1);
            else{
                if(Math.abs(c2 - c1) > Math.abs(r1 - r2))   return Math.abs(c2 - c1);
                else return   Math.abs(r1 - r2);
            }
        }
    }
    public static void main(String[] args) {
        int rr1, rr2, cc1, cc2;
        sc = new Scanner(System.in);
        rr1 = sc.nextInt();
        cc1 = sc.nextInt();
        rr2 = sc.nextInt();
        cc2 = sc.nextInt();
        a = new _370A_(rr1,cc1,rr2,cc2);
        System.out.printf("%d",a.CheckRock());
        a.CheckBishop();
        System.out.printf(" %d", a.CheckKing());
    }

}

import java.util.Scanner;

public class RookBishopKing {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();
		int rooks = 0;
		int bishops = 0;
		int kings = 0;
		if (r1 == r2 || c2 == c1) {
			rooks = 1;
		} else {
			rooks = 2;
		}
		int dif1 = Math.abs(r1 - r2);
		int dif2 = Math.abs(c1 - c2);
		if (dif1 % 2 == dif2 % 2) {
			if (dif1 == dif2) {
				bishops = 1;
			} else {
				bishops = 2;
			}
		}
		kings = Math.max(dif1, dif2);
		System.out.println(rooks + " " + bishops + " " + kings);
	}

}

import java.io.*;
import java.util.*;
public class Main
{
	public static void main(String[] args) throws Exception
	{
	    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

	    String s=br.readLine();
	    String ss[]=s.split(" ");
	    int r1=Integer.parseInt(ss[0]);
	    int c1=Integer.parseInt(ss[1]);
	    int r2=Integer.parseInt(ss[2]);
	    int c2=Integer.parseInt(ss[3]);
	    if(r1==r2||c1==c2)
	    System.out.print("1 ");
	    else
	    System.out.print("2 ");
	    if((r1+c1)%2==(r2+c2)%2)
	    {
	        if(r1-r2==c1-c2)
	        System.out.print("1 ");
	        else if(r1+c1==c2+r2)
	        System.out.print("1 ");
	        else
	        System.out.print("2 ");
	    }
	    else
	    System.out.print("0 ");
	    System.out.print(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
	}
}

/* package codechef; // don't place package name! */

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

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
	    Scanner sc = new Scanner(System.in);
	int r1 = sc.nextInt();
	int c1 = sc.nextInt();
	int r2 = sc.nextInt();
	int c2 = sc.nextInt();
	int rm = 0;
	int km = 0;
	int bm = 0;
	if(r1==r2 || c1==c2){
	    rm=1;
	    if(r1==r2){
	        km = Math.abs(c1-c2);
	        if(km%2==1){
	            bm = 0;
	        }
	        else{
	            bm = 2;
	        }
	    }
	    else{
	        km = Math.abs(r1-r2);
	        if(km%2==1){
	            bm = 0;
	        }
	        else{
	            bm = 2;
	        }
	    }
	}
	else{
	    int rd = r1-r2;
	    int cd = c1-c2;
	    int ra = Math.abs(rd);
	    int ca = Math.abs(cd);
	    if(r1+c1==r2+c2){
	        bm=1;
	    }
	    else if(ra==ca){
	        bm=1;
	    }
	    else if((r1+c1)%2==(r2+c2)%2){
	        bm=2;
	    }
	    else{
	        bm=0;
	    }
	    rm=2;
	    km = Math.max(ra,ca);
	}
	System.out.println(""+rm+" "+bm+" "+km);
	        }
	    }

import java.util.*;
import java.lang.*;

public class Chess{

	static int r1,r2,c1,c2;

	public static void main(String[] args) {

		Scanner in = new Scanner(System.in);
		r1 = in.nextInt();
		c1 = in.nextInt();
		r2 = in.nextInt();
		c2 = in.nextInt();

		if(r1 == r2 && c1== c2)
			System.out.print("0 0 0");

		if(r1 == r2 || c1 == c2)
			System.out.print(1 + " ");
		else
			System.out.print(2 + " ");

		if((r1 + c1) % 2 != (r2 + c2) % 2)
			System.out.print(0 + " ");
		else if(r1 + c1 == r2 + c2 || r1 - c1 == r2 - c2)
			System.out.print(1 + " ");
		else
			System.out.print(2 + " ");

		System.out.print(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));

		}

}

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

public class RookBishopandKing {
    Reader in;
    PrintWriter out;

    void solve() throws IOException
    {
        int curr_row= in.ni(), curr_col= in.ni();
        int row= in.ni(), col= in.ni();

        int rook= 0, bishop= 0, king= 0;

        if(row== curr_row || col== curr_col)
            rook= 1;
        else
            rook= 2;

        if(((curr_row+ curr_col)%2==0 && (col+row)%2==0)||((curr_row+ curr_col)%2!=0 && (col+row)%2!=0))
        {
            if(Math.abs(curr_row- row) == Math.abs(curr_col- col))
                bishop= 1;
            else
                bishop= 2;
        }
        else
            bishop= 0;

        king= Math.max(Math.abs(curr_row- row), Math.abs(curr_col- col));

        out.println(rook+" "+bishop+" "+king);
    }

    void run() throws Exception {
        in = new Reader();
        out = new PrintWriter(System.out);

        solve();
        out.flush();
    }

    public static void main(String[] args) throws Exception {
        new RookBishopandKing().run();
    }

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String ns() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public String ns(boolean bool) {
            Scanner sc = new Scanner(System.in);
            return sc.nextLine();
        }

        public int ni() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nl() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nd() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }
}

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

	public class A {

		public static void main(String[] args) throws Exception{
			Scanner sc = new Scanner(System.in);
			PrintWriter out = new PrintWriter(System.out);
			int r1 = sc.nextInt(), c1 = sc.nextInt(), r2 = sc.nextInt(), c2 = sc.nextInt();
			if(r1 == r2 || c1 == c2) out.print(1 + " ");
			else out.print(2 + " ");
			if((r1 + c1) % 2 != (r2 + c2) % 2) out.print(0 + " ");
			else if(Math.abs(r1 - r2) == Math.abs(c1 - c2)) out.print(1 + " ");
			else out.print(2 + " ");
			int diff1 = Math.abs(r1 - r2), diff2 = Math.abs(c1 - c2);
			out.println(Math.min(diff1, diff2) + Math.abs(diff1 - diff2));
			out.flush();
			out.close();
		}

		static class Scanner
		{
			StringTokenizer st;
			BufferedReader br;

			public Scanner(InputStream System){	br = new BufferedReader(new InputStreamReader(System));}
			public String next() throws IOException
			{
				while (st == null || !st.hasMoreTokens())
					st = new StringTokenizer(br.readLine());
				return st.nextToken();
			}
			public String nextLine()throws IOException{return br.readLine();}
			public int nextInt() throws IOException {return Integer.parseInt(next());}
			public double nextDouble() throws IOException {return Double.parseDouble(next());}
			public char nextChar()throws IOException{return next().charAt(0);}
			public Long nextLong()throws IOException{return Long.parseLong(next());}
			public boolean ready() throws IOException{return br.ready();}
			public void waitForInput(){for(long i = 0; i < 3e9; i++);}
		}
	}

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

public class cf370a {
  static FastIO in = new FastIO(), out = in;

  public static void main(String[] args) {
    int r1 = in.nextInt();
    int c1 = in.nextInt();
    int r2 = in.nextInt();
    int c2 = in.nextInt();
    out.print(getRook(r1,c1,r2,c2) + " " + getBishop(r1,c1,r2,c2) + " " + getKing(r1,c1,r2,c2));
    out.close();
  }
  static int getRook(int r1, int c1, int r2, int c2) {
    int ans = 2;
    if(r1 == r2) ans--;
    if(c1 == c2) ans--;
    return ans;
  }

  static int getBishop(int r1, int c1, int r2, int c2) {
    if((r1+c1)%2 != (r2+c2)%2) return 0;
    if(Math.abs(r2-r1) == Math.abs(c2-c1)) return 1;
    return 2;
  }

  static int getKing(int r1, int c1, int r2, int c2) {
    return Math.max(Math.abs(r2-r1), Math.abs(c2-c1));
  }

  static class FastIO extends PrintWriter {
    BufferedReader br;
    StringTokenizer st;

    public FastIO() {
      this(System.in, System.out);
    }

    public FastIO(InputStream in, OutputStream out) {
      super(new BufferedWriter(new OutputStreamWriter(out)));
      br = new BufferedReader(new InputStreamReader(in));
      scanLine();
    }

    public void scanLine() {
      try {
        st = new StringTokenizer(br.readLine().trim());
      } catch (Exception e) {
        throw new RuntimeException(e.getMessage());
      }
    }

    public int numTokens() {
      if (!st.hasMoreTokens()) {
        scanLine();
        return numTokens();
      }
      return st.countTokens();
    }

    public String next() {
      if (!st.hasMoreTokens()) {
        scanLine();
        return next();
      }
      return st.nextToken();
    }

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

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

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

//package com.congli.codeforces;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Locale;
import java.util.StringTokenizer;

public class C217Div2A_Rook {

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

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

	public void solve() throws IOException {
		int r1 = readInt();
		int c1 = readInt();
		int r2 = readInt();
		int c2 = readInt();

		rook(r1, c1, r2, c2);
		bishop(r1, c1, r2, c2);
		king(r1, c1, r2, c2);
	}

	private void rook(int r1, int c1, int r2, int c2) {
		if (r1 == r2 || c1 == c2) {
			out.print("1 ");
		} else {
			out.print("2 ");
		}
	}

	private void bishop(int r1, int c1, int r2, int c2) {
		if ((r1+c1)%2 != (r2+c2)%2) {
			out.print("0 ");
			return;
		}

		if (r1-c1 == r2-c2 || r1+c1 == r2+c2) {
			out.print("1 ");
		} else {
			out.print("2 ");
		}
	}

	private void king(int r1, int c1, int r2, int c2) {
		int rDiff = Math.abs(r1 - r2);
		int cDiff = Math.abs(c1 - c2);
		out.println(Math.max(rDiff, cDiff));
	}

	public void start()
	{
		try {
			long t1 = System.currentTimeMillis();
			if (System.getProperty("ONLINE_JUDGE") != null) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader("/Users/congli/Documents/javaworkspace/codeforces/src/com/congli/codeforces/input.txt"));
				out = new PrintWriter(System.out);
			}
			Locale.setDefault(Locale.US);
			solve();
			in.close();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Throwable t) {
			t.printStackTrace(System.err);
			System.exit(-1);
		}
	}

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

	public int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	public long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	public double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}
}

import java.util.Scanner;

public class Div2Round217A {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int r1 = in.nextInt();
		int c1 = in.nextInt();
		int r2 = in.nextInt();
		int c2 = in.nextInt();
		// rook
		System.out.print((r1 == r2 || c1 == c2) ? 1 : 2);
		// bishop
		if ((r1 + c1)%2 != (r2 + c2)%2)
			System.out.print(" 0 ");
		else if (Math.abs(r2 - r1) == Math.abs(c2 - c1))
			System.out.print(" 1 ");
		else
			System.out.print(" 2 ");
		// king
		System.out.println(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));

	}

}

import java.util.Scanner;

public class a {
    public static int rookMove(int r1, int c1, int r2, int c2) {
        if(r1 == r2 && c1 == c2){
            return 0;
        }

        if(r1 == r2 || c1 == c2){
            return 1;
        }

        return 2;
    }

    public static int bishopMove(int r1, int c1, int r2, int c2) {
        if((r1 + c1) % 2 != (r2 + c2) % 2){
            return 0;
        }

        int f1 = r1 - c1;
        int f2 = r1 + c1;

        if(r2 - c2 == f1 || r2 + c2 == f2){
            return 1;
        }

        return 2;
    }

    public static int kingMove(int r1, int c1, int r2, int c2) {
        return Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
    }

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

        while (input.hasNext()) {
            int r1 = input.nextInt();
            int c1 = input.nextInt();
            int r2 = input.nextInt();
            int c2 = input.nextInt();

            System.out.println(rookMove(r1, c1, r2, c2) + " " + bishopMove(r1, c1, r2, c2) + " " + kingMove(r1, c1, r2, c2));
        }
    }

}

import java.util.Scanner;

public class RookBishopandKing
{
	public static void main(String[] args)
	{
		Scanner input = new Scanner(System.in);
		int r1 = input.nextInt();
		int c1 = input.nextInt();
		int r2 = input.nextInt();
		int c2 = input.nextInt();
		StringBuilder sb = new StringBuilder();
		if (r1 == r2 || c1 == c2)
		{
			sb.append(1 + " ");
		}
		else
		{
			sb.append(2 + " ");
		}
		if ((r1 + c1) % 2 != (r2 + c2) % 2)
		{
			sb.append(0 + " ");
		}
		else if (Math.abs(r1 - r2) == Math.abs(c1 - c2))
		{
			sb.append(1 + " ");
		}
		else
		{
			sb.append(2 + " ");
		}
		int max = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
		sb.append(max);
		System.out.println(sb);
	}
}

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

public class CodeForces {

    static int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
    static int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};

    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        PrintWriter writer = new PrintWriter(System.out);

        int a = Reader.nextInt();
        int b = Reader.nextInt();
        int c = Reader.nextInt();
        int d = Reader.nextInt();

        int rook = (a == c ? 0 : 1 )+ (b == d ? 0 : 1);
        int king = Math.max(Math.abs(a-c) , Math.abs(d-b));
        int bishop = 0;

        if((a+b) % 2 == (c+d) % 2 && (a!=c || b!=d)){
            if(a - b == c - d || a + b == c + d)
                bishop = 1;
            else
                bishop = 2;
        }

        writer.printf("%d %d %d", rook, bishop, king);
        writer.flush();
    }
}

class Node {

    int freq;
    int startIndex;

    public Node(int freq, int startIndex) {
        this.freq = freq;
        this.startIndex = startIndex;
    }

}

class Edge implements Comparable<Edge> {

    int to;
    int from;
    int cost;

    Edge(int a, int b, int c) {
        from = a;
        to = b;
        cost = c;
    }

    @Override
    public int compareTo(Edge t) {
        return t.cost - cost;
    }
}

class Pair implements Comparable<Pair> {

    long x;
    long y;

    Pair(long a, long b) {
        x = a;
        y = b;
    }

    @Override
    public boolean equals(Object o) {
        return x == ((Pair) o).x && y == ((Pair) o).y;
    }

    @Override
    public int hashCode() {
        return 1;
    }

    @Override
    public int compareTo(Pair t) {
        if (x <= t.x && y <= t.y) {
            return 1;
        }
        return -1;
    }
}

class Reader {

    static BufferedReader reader;
    static StringTokenizer tokenizer;

    public static int pars(String x) {
        int num = 0;
        int i = 0;
        if (x.charAt(0) == '-') {
            i = 1;
        }
        for (; i < x.length(); i++) {
            num = num * 10 + (x.charAt(i) - '0');
        }

        if (x.charAt(0) == '-') {
            return -num;
        }

        return num;
    }

    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input));
        tokenizer = new StringTokenizer("");
    }

    static void init(FileReader input) {
        reader = new BufferedReader(input);
        tokenizer = new StringTokenizer("");
    }

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

    static int nextInt() throws IOException {
        return pars(next());
    }

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

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

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

public class Abood2B {

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();

		int a = (r1 == r2 || c1 == c2) ? 1 : 2;

		int b = 0;

		if((r1 + c1) % 2 == (r2 + c2) % 2)
			b = (r1 - c1 == r2 - c2 || r1 - (9 -c1) == r2 - (9 - c2)) ? 1 : 2;

		int c = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));

		out.println(a + " " + b + " " + c);

		out.flush();

	}

	static 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.Scanner;

public class JavaApplication6 {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int x1 = input.nextInt();
        int y1 = input.nextInt();
        int x2 = input.nextInt();
        int y2 = input.nextInt();
        int rock = 2;
        int bishop = 2;
        int king = 0;
        if(x1 == x2 || y1 == y2){
            rock = 1;

        }
        if(Math.abs(x1 - x2 )== Math.abs(y1 - y2) ){
            bishop = 1;
        }

        else if((x1 + y1)%2 != (x2 + y2)%2){
            bishop = 0;
        }
        if(x1 == x2){
            king = Math.abs(y2-y1);
        }
        else if(y1 == y2 ) {
            king = Math.abs(x2-x1);
        }
        else{
            king = Math.max(Math.abs(y2-y1), Math.abs(x2-x1));
        }
        System.out.print(rock +" " + bishop + " "+ king + " "+"\n");

    }

}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();
		if(r1==r2 || c1==c2) {
			System.out.print("1 ");
		}else{
			System.out.print("2 ");
		}
		if((r1+c1)%2 != (r2+c2)%2) {
			System.out.print("0 ");
		}else if(r2-r1 == c2-c1 || r2-r1 == c1-c2) {
			System.out.print("1 ");
		}else{
			System.out.print("2 ");
		}
		System.out.println(Math.max(Math.abs(r2-r1),Math.abs(c2-c1)));
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
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
 */
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);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
        	int r1 = in.nextInt();
        	int c1 = in.nextInt();
        	int r2 = in.nextInt();
        	int c2 = in.nextInt();
        	int x = 0;
        	int y = 0;
        	int z = 0;
        	if (r1 == r2) {
        		x = 1;
        		if ((c1 - c2) % 2 == 0) {
        			y = 2;
        		} else {
        			y = 0;
        		}
        		z = Math.abs(c1 - c2);
        	} else if (c1 == c2) {
            	x = 1;
            	if ((r1 - r2) % 2 == 0) {
            		y = 2;
            	} else {
            		y = 0;
            	}
            	z = Math.abs(r1 - r2);
            } else {
            	x = 2;
            	if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) {
            		y = 1;
            		z = Math.abs(r1 - r2);
            	} else if (Math.abs(Math.abs(r1 - r2) - Math.abs(c1 - c2)) % 2 == 0) {
            		y = 2;
            		z = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
            	} else {
            		y = 0;
            		z = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));
            	}
            }
        	out.println(x + " " + y + " " + z);
        }
    }

    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.io.*;
import java.util.*;
import java.math.*;

public class Exercise1 implements Runnable {

    static BufferedReader in;
    static PrintWriter out;
    static StringTokenizer st;

    private void solve() throws IOException {
        int xStart = nextInt();
        int yStart = nextInt();
        int xEnd = nextInt();
        int yEnd = nextInt();

        out.printf("%d %d %d", countBishop(xStart, yStart, xEnd, yEnd), countCastle(xStart, yStart, xEnd, yEnd), countKing(xStart, yStart, xEnd, yEnd));
    }

    private int countKing(int xStart, int yStart, int xEnd, int yEnd) {
        int xDiff = Math.abs(xStart - xEnd);
        int yDiff = Math.abs(yStart - yEnd);

        return Math.max(xDiff, yDiff);
    }

    private int countBishop(int xStart, int yStart, int xEnd, int yEnd) {
        return (xEnd == xStart ? 0 : 1) + (yEnd == yStart ? 0 : 1);
    }

    private int countCastle(int xStart, int yStart, int xEnd, int yEnd) {
        if ((xStart + yStart) % 2 != ((xEnd + yEnd) % 2)) {
            return 0;
        } else {
            return Math.abs(xStart - xEnd) == Math.abs(yStart - yEnd) ? 1 : 2;
        }
    }

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

    @Override
    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);

            solve();

            out.close();
        } catch (IOException e) {
            e.printStackTrace(System.err);
            System.exit(1);
        }
    }

    private String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = in.readLine();

            if (line == null) {
                return null;
            }

            st = new StringTokenizer(line);
        }

        return st.nextToken();
    }

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

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

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

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pranay2516
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(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, FastReader in, PrintWriter out) {
            int r1 = in.nextInt(), c1 = in.nextInt(), r2 = in.nextInt(), c2 = in.nextInt();
            out.print((r1 == r2 || c1 == c2 ? 1 : 2) + " ");
            if ((r1 + c1) % 2 != (r2 + c2) % 2) out.print(0 + " ");
            else out.print(((r1 + r2 == c1 + c2 || r1 - r2 == c1 - c2) ? 1 : 2) + " ");
            out.print(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.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 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 c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        }

    }
}

import java.util.Scanner;

public class Div2Round217A {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int r1 = in.nextInt();
		int c1 = in.nextInt();
		int r2 = in.nextInt();
		int c2 = in.nextInt();
		// rook
		System.out.print((r1 == r2 || c1 == c2) ? 1 : 2);
		// bishop
		if (r1 + c1 != r2 + c2)
			System.out.print(" 0 ");
		else if (Math.abs(r2 - r1) == Math.abs(c2 - c1))
			System.out.print(" 1 ");
		else
			System.out.println(" 2 ");
		// king
		System.out.println(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));

	}

}

import java.util.*;
public class RookBishopKing
{
public static Scanner sc;
public static void main(String[] args)
{
sc = new Scanner (System.in);
int r1 = sc.nextInt();
int c1 = sc.nextInt();
int r2 = sc.nextInt();
int c2 = sc.nextInt();
char source = 'B';
char target = 'B';
if ((r1%2==0&&c1%2==0)||(r1%2!=0&&c1%2!=0))
    source = 'W';
if ((r2%2==0&&c2%2==0)||(r2%2!=0&&c2%2!=0))
    target = 'W';
int Rook = 0;
int Bishop = 0;
int King = 0;
if (r1==r2||c1==c2)
    Rook = 1;
else
    Rook = 2;
if (source!=target)
    Bishop = 0;
else
{
    if (Math.abs(r1-r2)==Math.abs(c1-c2))
        Bishop = 1;
    else
        Bishop = 2;
}

if (r1==r2||c1==c2)
    King += Math.abs(r1-r2)+Math.abs(c1-c2);
else
{
int min = 0;
if (Math.abs(r1-r2)<Math.abs(c1-c2))
{
    min = Math.abs(r1-r2);
    if (c1>c2)
    c1 -=min-1;
    else
    c1 += min-1;
}
else
{
    min = Math.abs(c1-c2);
    r1 =Math.abs(min-r1);
}
King += min+Math.abs(r1-r2);

}

System.out.println(Rook+" "+Bishop+" "+King);
}
}

import java.util.Scanner;
public class Solution {
    public static void main(String args[]) {
        Scanner s=new Scanner(System.in);
        int r1=s.nextInt();
        int c1=s.nextInt();
        int r2=s.nextInt();
        int c2=s.nextInt();
        printMinMoves(r1,c1,r2,c2);
    }
    public static void printMinMoves(int r1,int c1,int r2,int c2)
    {
        System.out.println(minMovesForRook(r1,c1,r2,c2)+" "+minMovesForBishop(r1,c1,r2,c2)+" "+minMovesForKing(r1,c1,r2,c2));
    }
    public static int minMovesForRook(int r1,int c1,int r2,int c2)
    {
        if(r1==r2 || c1==c2)
        {
            return 1;
        }
        else return 2;
    }
    public static int minMovesForBishop(int r1,int c1,int r2,int c2)
    {
        if(r1%2==0 && c1%2==0)
        {
            if((r2%2==0 && c2%2==0) || (r2%2!=0 && c2%2!=0))
            {
                if((r2-r1 == c2-c1) || (r1+c1)==(r2+c2))
                {
                    return 1;
                }
                else return 2;
            }
            else{
                return 0;
            }
        }
        else if(r1%2!=0 && c1%2!=0)
        {
            if((r2%2!=0 && c2%2!=0) || (r2%2==0 && c2%2==0))
            {
                if((r2-r1 == c2-c1) || (r1+c1)==(r2+c2))
                {
                    return 1;
                }
                else return 2;
            }
            else{
                return 0;
            }
        }
        else if(r1%2!=0 && c1%2==0)
        {
            if((r2%2!=0 && c2%2==0) || (r2%2==0 && c2%2!=0))
            {
                if((r2-r1 == c2-c1) || (r1+c1)==(r2+c2))
                {
                    return 1;
                }
                else return 2;
            }
            else{
                return 0;
            }
        }
        else if(r1%2==0 && c1%2!=0)
        {
            if((r2%2!=0 && c2%2==0) || (r2%2==0 && c2%2!=0))
            {
                if((r2-r1 == c2-c1) || (r1+c1)==(r2+c2))
                {
                    return 1;
                }
                else return 2;
            }
            else{
                return 0;
            }
        }
        else return 0;
    }
    public static int minMovesForKing(int r1,int c1,int r2,int c2)
    {
        int ans=0;
        int option1=Math.abs(r1-r2);
        int newRow=r2;
        int newCol;
        newCol=c1+(r2-r1);
        option1+=(Math.abs(newCol-c2));

        int option2=Math.abs(c1-c2);
        newCol=c2;
        newRow=r1+(c2-c1);

        option2+=(Math.abs(newRow-r2));
        ans=Math.min(option1,option2);
        return ans;
    }

}

import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.Queue;

import javax.management.Query;
import javax.sound.midi.Soundbank;

import javafx.scene.shape.QuadCurve;

import java.io.BufferedWriter;
import java.io.IOException;

/*
5 3 1 4 13 10

 */

public class Main
{
	static long a,b,c,d,e,f,t,l,r,v,n,m,k,x,y,res=0,len,pow;
	static StringBuilder sb,sb1,sb2;
	static String s;
	static long ar[] = new long[100009];
	static long cumu[] = new long[100009];
	static int dis[][] = new int[9][9];
	//static long cumu[] = new long[150009];
	static ArrayList<Long> vi = new ArrayList<>();
	boolean fl = true;

	static int bfs(long x2, long y2, long d2, long e2)
	{
		Queue<Long> q = new LinkedList<>();

		q.add(x2);
		q.add(y2);

		dis[(int) x2][(int) y2] = 1;

		while(q.size()>0)
		{
			long xx = q.remove();
			long yy = q.remove();

			for(int i=-1; i<1; i++)
			{
				for(int j=-1; j<=1; j++)
				{
					if(xx+i<0 || xx+i==8 || yy+j<0 || yy+j==8)continue;

					if(dis[(int)xx+i][(int)yy+j]==0)
					{
						dis[(int)xx+i][(int)yy+j] = dis[(int)xx][(int)yy]+1;
						q.add(xx+i);
						q.add(yy+j);

						if(xx+i==d2 && yy+j==e2) return dis[(int)xx+i][(int)yy+j]-1;
					}
				}
			}
		}
		return 0;

	}

	public static void main(String[] args)throws IOException
	{
		MainFastScan scanner = new MainFastScan();
		MainFastPrint printer = new MainFastPrint();

		x = scanner.nextLong();
		y = scanner.nextLong();

		d = scanner.nextLong();
		e = scanner.nextLong();

		if(x==d || y==e) printer.print("1 ");
		else printer.print("2 ");

		if((x+y)%2 != (d+e)%2) printer.print("0 ");
		else
		{
			if(Math.abs(x-d)==Math.abs(y-e))  printer.print("1 ");
			else  printer.print("2 ");
		}

		long xx = Math.abs(x-d);
		long yy = Math.abs(y-e);

		printer.print(Long.toString(bfs(x-1, y-1, d-1, e-1)));

		printer.print("\n");
		printer.close();
	}
}

class MainFastPrint
{
	private final BufferedWriter bw;
	public MainFastPrint(){bw=new BufferedWriter(new OutputStreamWriter(System.out));}
	public void print(String str)throws IOException{bw.append(str);}
	public void printLine(String str)throws IOException{print(str); bw.append("\n");}
	public void close()throws IOException{bw.close();}
	public void flush() throws IOException {bw.flush();}
}

class MainFastScan
{
	private byte[] buf=new byte[1024];
	private int index;
	private InputStream in;
	private int total;
	public MainFastScan()
	{
		in=System.in;
	}
	public int scan()throws IOException
	{
		if(total<0)
			throw new InputMismatchException();
		if(index>=total)
		{
			index=0;
			total=in.read(buf);
			if(total<=0)
				return -1;
		}
		return buf[index++];
	}
	public int nextInt()throws IOException
	{
		int integer=0;
		int n=scan();
		while(isWhiteSpace(n)) n=scan();
		int neg=1;
		if(n=='-')
		{
			neg=-1;
			n=scan();
		}
		while(!isWhiteSpace(n))
		{
			if(n>='0'&&n<='9')
			{
				integer*=10;
				integer+=n-'0';
				n=scan();
			}
			else throw new InputMismatchException();
		}
		return neg*integer;
	}

	public long nextLong()throws IOException
	{
		long res=0;
		int n = scan();
		while(isWhiteSpace(n)) n=scan();
		int neg=1;
		if(n=='-')
		{
			neg=-1;
			n=scan();
		}
		while(!isWhiteSpace(n))
		{
			if(n>='0'&&n<='9')
			{
				res *= 10;
				res += n-'0';
				n=scan();
			}
			else throw new InputMismatchException();
		}
		return neg*res;
	}

	public double nextDouble()throws IOException
	{
		double doub=0;
		int n=scan();
		while(isWhiteSpace(n)) n=scan();
		int neg=1;
		if(n=='-')
		{
			neg=-1;
			n=scan();
		}
		while(!isWhiteSpace(n)&&n!='.')
		{
			if(n>='0'&&n<='9')
			{
				doub*=10;
				doub+=n-'0';
				n=scan();
			}
			else throw new InputMismatchException();
		}
		if(n=='.')
		{
			n=scan();
			double temp=1;
			while(!isWhiteSpace(n))
			{
				if(n>='0'&&n<='9')
				{
					temp/=10;
					doub+=(n-'0')*temp;
					n=scan();
				}
				else throw new InputMismatchException();
			}
		}
		return doub*neg;
	}
	public String nextWord()throws IOException
	{
		StringBuilder sb=new StringBuilder();
		int n=scan();
		while(isWhiteSpace(n)) n=scan();
		while(!isWhiteSpace(n))
		{
			sb.append((char)n);
			n=scan();
		}
		return sb.toString();
	}
	public String nextLine()throws IOException
	{
		StringBuilder sb=new StringBuilder();
		int n=scan();
		while(isWhiteSpaceLine(n)) n=scan();
		while(!isWhiteSpaceLine(n))
		{
			sb.append((char)n);
			n=scan();
		}
		return sb.toString();
	}
	private boolean isWhiteSpace(int n)
	{
		if(n==' '||n=='\n'||n=='\r'||n=='\t'||n==-1)
			return true;
		return false;
	}
	private boolean isWhiteSpaceLine(int n)
	{
		if(n=='\n'||n=='\r'||n=='\t'||n==-1)
			return true;
		return false;
	}
}

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 RookBishopandKing {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int r1=scan.nextInt();
        int c1=scan.nextInt();
        int r2=scan.nextInt();
        int c2=scan.nextInt();
        int r=0,b=0,k=0;
        if(r1==r2||c1==c2)
            r=1;
        else
            r=2;
        if(Math.abs(r1-r2)==Math.abs(c1-c2))
            b=1;
        else if((r1==r2&&Math.abs(c1-c2)+1%2==1)||(c1==c2&&Math.abs(r1-r2)+1%2==1))
            b=2;
        else
            b=0;
        if(b==1)
        {
            k=(int) Math.min(Math.abs(r1-r2),Math.abs(r1-r2));
        }
        else
        {
            k=Math.abs(r1-r2)+Math.abs(c1-c2);
        }
        System.out.println(r+" "+b+" "+k);
    }
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Solution
{	static int x1 =0;
	static int y1 = 0;
	static int x2 =0;
	static int y2 = 0;
	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		x1 = Integer.parseInt(st.nextToken());
		y1 = Integer.parseInt(st.nextToken());
		x2 = Integer.parseInt(st.nextToken());
		y2 = Integer.parseInt(st.nextToken());
		int r=0;
		int b=0;
		int k=0;
		if (x1==x2||y1==y2){
			r=1;

		}else{
			r=2;
		}
		if (x1==x2){
			if (Math.abs(y2-y1)%2==0){
				b=2;
			}
		}
		else if (y1==y2){
			if (Math.abs(x2-x1)%2==0){
				b=2;
			}
		}
		else if (Math.abs(x2-x1)==Math.abs(y2-y1)){
			b=1;
		}
		else if ((x1%2==0&&y1%2==0)||(x1%2!=0&&y1%2!=0)){
				if ((x1%2==0&&y1%2==0)||(x1%2!=0&&y1%2!=0)){
					b=2;
				}
				else {
					b=0;
				}
		}
		else if ((x1%2!=0&&y1%2==0)||(x1%2==0&&y1%2!=0)){
				if ((x1%2!=0&&y1%2==0)||(x1%2==0&&y1%2!=0)){
					b=2;
				}
				else {
					b=0;
				}
		}

		if (x1==x2){

				k=Math.abs(y2-y1);

		}
		else if (y1==y2){
				k = Math.abs(x2-x1);

		}
		else if (Math.abs(x2-x1)==Math.abs(y2-y1)){
			k=Math.abs(x2-x1);
		} else {
			int tempx = Math.abs(x2-x1);
			int tempy = Math.abs(y2-y2);
			if(tempx<tempy){
				k=tempy;
			}
			else{
				k=tempx;
			}
		}
		System.out.println(r+" "+b+" "+k);
	}
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int r1=sc.nextInt();
		int c1=sc.nextInt();
		int r2=sc.nextInt();
		int c2=sc.nextInt();
		int moves1=0;
		int moves2=0;
		int moves3=0;

	 if(r1==r2 || c1==c2)
	 moves1=1;
	 else
	 moves1=2;

	 if((r1+c1)%2!=(r2+c2)%2)
	 moves2=0;
	 else
	 {
	 if((r1+c1)==(r2+c2)||Math.abs(r1-c1)==Math.abs(r2-c2))
	 moves2=1;
	 else
	 moves2=2;
	 }

	 moves3=Math.max(Math.abs(r1-r2),Math.abs(c1-c2));

	 System.out.println(moves1+" "+moves2+" "+moves3);

	}
}

import java.util.Scanner;

public class ProblemA {

    public static int reduced(int r1, int c1, int r2, int c2){
        int min = Integer.MAX_VALUE;
        int cc=c1;
        int rr=r1;
        while(true){
            int move=0;
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1++;
            c1++;

        }
        c1=cc;
        r1=rr;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            int move=0;
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1--;
            c1++;
        }
        c1=cc;
        r1=rr;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            int move=0;
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1++;
            c1--;
        }
        c1=cc;
        r1=rr;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            int move=0;
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1--;
            c1--;
        }
        return min;

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();
        int r, b, k;
        if(r1==r2 && c1==c2){
            r=0;
        }
        else if(r1==r2 || c1==c2){
            r=1;
        }
        else{
            r=2;
        }
        if(r1==r2 && c1==c2){
            b=0;
        }
        else if(Math.abs(r1-r2)==Math.abs(c1-c2)){
            b=1;
        }
        else if(Math.abs(Math.abs(r1-r2)-Math.abs(c1-c2))==1){
            b=0;
        }
        else{
            b=2;
        }
        if(r1==r2 && c1==c2){
            k=0;
        }
        else if(r1==r2 || c1==c2){
            k=reduced(r1, c1, r2, c2);
        }
        k=Math.min(Math.abs(r1-r2), Math.abs(c1-c2))+Math.abs((r1-r2)+(c1-c2));
        System.out.printf("%d %d %d", r, b, k);
    }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.StringTokenizer;

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

		try {
			new RookBishopandKing().go();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public  void go() {

		/*int n=in.nextInt();
		int k=in.nextInt();*/

		int r1=in.nextInt();
		int c1=in.nextInt();
		int r2=in.nextInt();
		int c2=in.nextInt();
		if(r1==r2 || c1==c2)
		System.out.print("1 ");
		else
			System.out.print("2 ");
		if(Math.abs(r1-r2)==Math.abs(c1-c2))
			System.out.print("1 ");
			else {
				boolean flag=false;
				int up=1;
				while(!flag && r1+up <=8 && c1+up<=8){
					int a= r1+up;
					int b =c1+up;
					if(Math.abs(a-r2)==Math.abs(b-c2)){
						System.out.print("2 ");
						flag=true;
						break;
					}
					++up;
				}
				int down=1;
				while(!flag && r1-down >0 && c1-down >0){
					int a= r1-down ;
					int b =c1-down;
					if(Math.abs(a-r2)==Math.abs(b-c2)){
						System.out.print("2 ");
						flag=true;
						break;
					}
					down++;
				}
				up=1;
				while(!flag && r1+up <=8 && c1-up>0){
					int a= r1+up;
					int b =c1-up;
					if(Math.abs(a-r2)==Math.abs(b-c2)){
						System.out.print("2 ");
						flag=true;
						break;
					}
					++up;
				}
				down=1;
				while(!flag && r1-down >0 && c1+down <=8){
					int a= r1-down ;
					int b =c1+down;
					if(Math.abs(a-r2)==Math.abs(b-c2)){
						System.out.print("2 ");
						flag=true;
						break ;
					}
					down++;
				}
				if(!flag)
					System.out.print("0 ");

			}

	LinkedList<Integer>  q1= new LinkedList<Integer>();
			LinkedList<Integer>  q2= new LinkedList<Integer>();
			LinkedList<Integer>  moves= new LinkedList<Integer>();
			q1.add(r1);
			q2.add(c1);
			moves.add(0);
			while(!q1.isEmpty()){
				int r = q1.poll();
				int c = q2.poll();
				int m = moves.poll();
				if(r==r2 && c==c2){
					System.out .println(m);
					return;
				}
				if(r <8 && r >1 && c<8 && c>1){
					q1.add(r+1);
					q2.add(c+1);
					moves.add(m+1);
					q1.add(r-1);
					q2.add(c-1);
					moves.add(m+1);
					q1.add(r+1);
					q2.add(c-1);
					moves.add(m+1);
					q1.add(r-1);
					q2.add(c+1);
					moves.add(m+1);
					q1.add(r);
					q2.add(c+1);
					moves.add(m+1);
					q1.add(r);
					q2.add(c-1);
					moves.add(m+1);
					q1.add(r+1);
					q2.add(c);
					moves.add(m+1);
					q1.add(r-1);
					q2.add(c);
					moves.add(m+1);
				}
			}

	}

}

import java.util.Scanner;

public class RookBishopKing {

    public static void main (String [] args) {
    	Scanner sc=new Scanner(System.in);
    	int r1=sc.nextInt();
    	int c1=sc.nextInt();
    	int r2=sc.nextInt();
    	int c2=sc.nextInt();
    	//rook:
    	int rook=0;
    	int bish=0;
    	int king=0;
    	if (r1==r2){
    		if (c1!=c2)
    			rook=1;
    	}
    	else{
    		if (c1==c2)
    			rook=1;
    		else
    			rook=2;
    	}
    	//bishop:
    	if ((r1+c1)%10==(r2+c2)%10){
    		if (r1+c1==r2+c2 || r1-c1==r2-c2)
    			bish=1;
    		else
    			bish=2;

    	}
    	while (r1!=r2 || c1!=c2){
    		if (r1>r2){
    			r1--;
    		}
    		else{
    			if (r2>r1)
    				r2--;
    		}
    		if (c1>c2){
    			c1--;
    		}
    		else{
    			if (c2>c1)
    				c2--;
    		}
    		king++;
    	}
    	System.out.println(rook + " "+ bish + " " + king);
    }

}

//package div217;
import java.io.*;
import java.util.*;
public class A
{
	BufferedReader in=null;
	PrintWriter ob=null;
	public static void main(String args[])throws IOException
	{
		new A().Solve();
	}
	void Solve()throws IOException
	{
		in=new BufferedReader(new InputStreamReader(System.in));
		ob=new PrintWriter(System.out);
		StringTokenizer st=new StringTokenizer(in.readLine());
		int x1=Integer.parseInt(st.nextToken());
		int y1=Integer.parseInt(st.nextToken());
		int x2=Integer.parseInt(st.nextToken());
		int y2=Integer.parseInt(st.nextToken());
		int d=Integer.MAX_VALUE;
		int crook=0,bishop=0,king=0;
		if(Math.abs(x2-x1)>0 && Math.abs(y2-y1)>0)
		{
			crook=2;
		}
		else
			crook=1;
		if((Math.abs(y2-y1)==Math.abs(x2-x1)))
		{
			bishop=1;
			d=(Math.abs(y2-y1)+Math.abs(x2-x1))/2;
		}
		else{
			bishop=0;
			d=Math.min(d, (Math.abs(y2-y1)+Math.abs(x2-x1)));
		}
		king = d;
		ob.println(crook+" "+bishop+" "+king);
		ob.flush();
	}
}

import java.util.Scanner;
public class Main {
    public static int abs(int a){
        return a>0?a:-a;
    }
    public static void main(String args[]){
        Scanner s=new Scanner(System.in);
        int r1,c1,r2,c2;
        r1=s.nextInt();
        c1=s.nextInt();
        r2=s.nextInt();
        c2=s.nextInt();
        int rook,bishop,king;
        if(r1==r2 && c1==c2){
            System.out.println("0 0 0");
        }
        else{
            if(r1==r2 || c1==c2){
                rook=1;
            }
            else{rook=2;}

            if((r1+c1)%2!=(r2+c2)%2){
                bishop=0;
            }
            else if(abs(r1-r2)==abs(c1=c2)){
                bishop=1;
            }
            else{bishop=2;}

            king=Math.max(abs(r1-r2),abs(c1-c2));
            System.out.println(rook+" "+bishop+" "+king);
        }

    }
}

import java.util.Scanner;
import java.lang.Math;

public class _370A{

	public static void main(String[] args){

		Scanner s = new Scanner(System.in);
		int x1 = s.nextInt();
		int y1 = s.nextInt();
		int x2 = s.nextInt();
		int y2 = s.nextInt();

		int rook = 0;
		if(x1 != x2){
			rook++;
		}
		if(y1 != y2){
			rook++;
		}

		int bishop = 0;
		if(Math.abs(x1-x2) == Math.abs(y1-y2)){
			bishop = 1;
		}
		else{
			if((Math.abs(x1-x2) + Math.abs(y1-y2))%2==0 && (Math.abs(x1-x2) + Math.abs(y1-y2))!=0){
				bishop = 2;
			}
		}

		int king = 0;
		int p = 0;

		if(Math.abs(x1-x2) != Math.abs(y1-y2)){

			int x = Math.abs(x1-x2);
			int y = Math.abs(y1-y2);

			if(x2>x1 && y2>y1){
				p = Math.min(x2-x1, y2-y1);
				x = Math.abs(x1+p-x2);
				y = Math.abs(y1+p-y2);
				//king = p;
				if(x == 1 || y == 1){
					if(x + y != 1){
						king = p + x + y - 1;
					}
					else{
						king = p + x + y;
					}
				}
				else{
					king = p + x + y;
				}

			}
			else{
				if(x == 1 || y == 1){
					if(x + y != 1){
						king = x + y - 1;
					}
					else{
						king = x + y;
					}
				}
				else{
					king = x + y;
				}
			}
		}
		else{
			king = Math.abs(x1-x2);
		}

		//int king = king(x1, y1, x2, y2);

		System.out.println(rook + " " + bishop + " " + king);

	}

	// public static int king(int x1, int y1, int x2, int y2){
		// int x = Math.abs(x1-x2);
		// int y = Math.abs(y1-y2);

		// if(x != y){
			// int p = 0;
			// if(x2>x1 && y2>y1){
				// p += Math.min(x2-x1, y2-y1);
				// return p + king(Math.min(x2-x1, y2-y1), Math.min(x2-x1, y2-y1), x2, y2);
			// }
			// else{
				// return Math.abs(x1-x2) + Math.abs(y1-y2);
			// }

		// }
		// else{
			// return x;
		// }

	// }

}

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 RookBishopandKing {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int r1=scan.nextInt();
        int c1=scan.nextInt();
        int r2=scan.nextInt();
        int c2=scan.nextInt();
        int r=0,b=0,k=0;
        if(r1==r2||c1==c2)
            r=1;
        else
            r=2;
        if(Math.abs(r1-r2)==Math.abs(c1-c2))
            b=1;
        else
            b=0;
        if(b==1)
        {
            k=(int) Math.min(Math.abs(r1-r2),Math.abs(r1-r2));
        }
        else
        {
            k=Math.abs(r1-r2)+Math.abs(c1-c2);
        }
        System.out.println(r+" "+b+" "+k);
    }
}

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

public class chess
{
    public static void main(String []args)
    {
        Scanner sc=new Scanner(System.in);
        int r1=sc.nextInt();
         int c1=sc.nextInt();
          int r2=sc.nextInt();
           int c2=sc.nextInt();
        int c=Math.abs(c1-c2);
        int r=Math.abs(r1-r2);
        if(r1==r2||c1==c2)
        System.out.print("1 ");
        else
        System.out.print("2 ");

        if(r==c)
        System.out.print("1 ");
        else
        System.out.print("0 ");

        System.out.print(Math.max(r,c));
    }
}

/**
 * Created by Omar on 12/20/2015.
 */
import java.util.*;
import java.io.*;
public class RookBishopandKing {
public static void main(String[] args)throws Exception{

    BufferedReader br= new BufferedReader (new InputStreamReader(System.in));
    String[] parts=br.readLine().split(" ");
    int r1=Integer.parseInt(parts[0]);
    int c1=Integer.parseInt(parts[1]);
    int r2=Integer.parseInt(parts[2]);
    int c2=Integer.parseInt(parts[3]);

    int king=0;
    int x=r1,y=c1;
    while(x!=r2 || y!=c2){
        if(x>r2 && y>c2){
            x--;
            y--;
            king++;
            continue;
        }
        if(x<r2 && y<c2){
            x++;
            y++;
            king++;
            continue;
        }
        if(x>r2 && y<c2){
            x--;
            y++;
            king++;
            continue;
        }
        if(x<r2 && y>c2){
            x++;
            y--;
            king++;
            continue;
        }
        if(x>r2){
            x--;
            king++;
        }
     else   if(x<r2){
            x++;
            king++;
        }
        if(y>c2){
            y--;
            king++;
        }
        else if(y<c2){
            y++;
            king++;
        }
    }
    x=r1;
    y=c1;
    int rook=0;
    while(x!=r2 || y!=c2){
        if(x!=r2){
            x=r2; rook++;
        }
        if(y!=c2){
            y=c2; rook++;
        }
    }
    x=r1;
    y=c1;
    int bishop=0;
    boolean w=false;

    if((x%2!=0 && y%2==0) || x==y){
        w=true;
    }
  /*  if((((r2%2!=0 && c2%2==0)||x==y) && w) || (((r2%2==0 && c2%2!=0)||x!=y) && !w)){
        bishop=0;
    }*/
    //else{
    int infinite_loop=0;
        while(x!=r2 || y!=c2){
            infinite_loop++;
            if(infinite_loop==500){
                bishop=0;
                break;
            }
            if(x>r2 && y>c2){
               while(x>r2 && y>c2){
                      x--;
                      y--;}
                bishop++;
                continue;
            }

            //
            if(x<r2 && y<c2){
                while(x<r2 && y<c2){ x++;
                y++;}
                bishop++;
                continue;
            }
            if(x>r2 && y<c2){
                while(x>r2 && y<c2){
                x--;
                y++;}

                bishop++;
                continue;
            }
            if(x<r2 && y>c2){
                while(x<r2 && y>c2){
                x++;
                y--;}
                bishop++;
                continue;
            }
            //
      //  }
    }
System.out.println(rook+" "+bishop+" "+king);
    br.close();}
}

import java.util.Scanner;
import java.lang.Math;

public class _370A{

	public static void main(String[] args){

		//System.out.println("Enter coordinates");
		Scanner s = new Scanner(System.in);
		int x1 = s.nextInt();
		int y1 = s.nextInt();
		int x2 = s.nextInt();
		int y2 = s.nextInt();

		//for rook
		int rook = 0;
		if(x1 != x2){
			rook++;
		}
		if(y1 != y2){
			rook++;
		}

		//for bishop
		int bishop = 0;
		if(Math.abs(x1-x2) == Math.abs(y1-y2)){
			bishop++;
		}

		//for king
		int king = 0;
		if(Math.abs(x1-x2) != Math.abs(y1-y2)){
			king = Math.abs(x1-x2) + Math.abs(y1-y2);
		}
		else{
			king = Math.abs(x1-x2);
		}

		System.out.println(rook + " " + bishop + " " + king);

	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt(); //odd
        int c1 = sc.nextInt(); //odd
        int r2 = sc.nextInt(); //odd
        int c2 = sc.nextInt(); //odd

        int rook = 0;
        int bishop = 0;
        int king = 0;
        //white odd odd
        //black ewen, odd  then     odd, ewen

        if (r1 == r2 && c1 == c2) {
            rook = 0;
            bishop = 0;
            king = 0;
        } else {
            rook = (r1 == r2 || c1 == c2) ? 1 : 2;
            bishop = ((r1 % 2 == 1 && r2 % 2  == 1 && c1 % 2 == 1 && c2 % 2 == 1) || r1 % 2 != c1 % 2 && r2 % 2 != c2 % 2) ? ((Math.abs(r2 - r1) == Math.abs(c2 - c1)) ? 1 :0 ): 0;
          king = (Math.abs(r2 - r1) > Math.abs(c2 - c1)) ? Math.abs(r2 - r1) : Math.abs(c2 - c1);

        }
        System.out.printf("%d %d %d", rook, bishop, king);
    }
}

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

/**
 * Created by 875k on 12/21/13.
 */
public class CF217A {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer tok = new StringTokenizer(br.readLine());
        int r1 = Integer.parseInt(tok.nextToken());
        int c1 = Integer.parseInt(tok.nextToken());
        int r2 = Integer.parseInt(tok.nextToken());
        int c2 = Integer.parseInt(tok.nextToken());
        System.out.print(((Math.abs(r2 - r1) == 0 ? 0 : 1) + (Math.abs(c2 - c1) == 0 ? 0 : 1)) + " ");
        if((r1 + c1) % 2 == (r2 + c2) % 2) {
            for(int i = r1 - 8, j = c1 - 8; i <= r1 + 8; i++) {
                if(i >= 1 && j >= 1 && i <= 8 && j <= 8
                        && Math.abs(i - r2) == Math.abs(j - c2)) {
                    System.out.print(((Math.abs(i - r1) == 0 ? 0 : 1) + (Math.abs(i - r2) == 0 ? 0 : 1)) + " ");
                    break;
                }
                j++;
            }
        }
        else {
            System.out.print(0 + " ");
        }
        System.out.println(Math.max(Math.abs(r2 - r1), Math.abs(c2 - c1)));
    }
}

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

public class A {

	public static void main(String[] agrs) {
		FastScanner sc = new FastScanner();
//		int n = sc.nextInt();
//		while(n-->0) {
//
//		}

		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();

//		the rook

		if(r1 == r2 || c1 == c2) {
			System.out.print(1 + " ");
		}
		else {
			System.out.print(2 + " ");
		}

//		the bishop

		if(Math.abs(r1-r2)-Math.abs(c1-c2) != 0) {
			System.out.print(0 + " ");
		}
		else if(Math.abs(r1-r2)-Math.abs(c1-c2) == 0) {
			System.out.print(1 + " ");
		}
		else {
			System.out.print(2 + " ");
		}

//		the king

		System.out.print(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
		System.out.println();

	}

	static int gcd(int a, int b) {
		return a%b == 0 ? b : gcd(b,a%b);
	}

	static int mod = 1000000007;

	static long pow(int a, int b) {
		if(b == 0) {
			return 1;
		}
		if(b == 1) {
			return a;
		}
		if(b%2 == 0) {

			long ans = pow(a,b/2);
			return ans*ans;
		}
		else {
			long ans = pow(a,(b-1)/2);
			return a * ans * ans;
		}

	}

	static boolean[] sieve(int n) {

		boolean isPrime[] = new boolean[n+1];
		for(int i = 2; i <= n; i++) {
			if(isPrime[i]) continue;
			for(int j = 2*i; j <= n; j+=i) {
				isPrime[j] = true;
			}
		}
		return isPrime;
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}

}

import java.util.Scanner;

public class A
{
	static Scanner sc=new Scanner(System.in);
	static int r1,c1,r2,c2;

	static int abs(int a)
	{
		if(a<0)
			return -a;
		return a;
	}

	public static void main(String[] args)
	{
		r1=sc.nextInt();
		c1=sc.nextInt();
		r2=sc.nextInt();
		c2=sc.nextInt();

		if(c1==c2 || r1==r2)
			System.out.print(1 + " ");
		else
			System.out.print(2 + " ");

		if((r1+c1)%2!=(r2+c2)%2)
			System.out.print(0 + " ");

		else
		{
			if((r1+c1)==(r2+c2))
				System.out.print(1 + " ");
			else
				System.out.print(2 + " ");
		}

		System.out.println(Integer.max(abs(r2-r1) , abs(c2-c1)));
	}
}

import java.util.Scanner;
import java.lang.Math;

public class _370A{

	public static void main(String[] args){

		Scanner s = new Scanner(System.in);
		int x1 = s.nextInt();
		int y1 = s.nextInt();
		int x2 = s.nextInt();
		int y2 = s.nextInt();

		int rook = 0;
		if(x1 != x2){
			rook++;
		}
		if(y1 != y2){
			rook++;
		}

		int bishop = 0;
		if(Math.abs(x1-x2) == Math.abs(y1-y2)){
			bishop = 1;
		}
		else{
			if((Math.abs(x1-x2) + Math.abs(y1-y2))%2==0 && (Math.abs(x1-x2) + Math.abs(y1-y2))!=0){
				bishop = 2;
			}
		}

		int king = 0;
		int p = 0;
		int x = Math.abs(x1-x2);
		int y = Math.abs(y1-y2);
		if(x != y){

			if(x2>x1 && y2>y1){
				p = Math.min(x2-x1, y2-y1);
				x = Math.abs(p-x2);
				y = Math.abs(p-y2);
			}

			if(x == 1 || y == 1){
				if(x + y != 1){
					king = x + y - 1;
				}
				else{
					king = x + y;
				}
			}
			else{
				king = x + y;
			}
		}
		else{
			king = x;
		}

		//int king = king(x1, y1, x2, y2);

		System.out.println(rook + " " + bishop + " " + king);

	}

	// public static int king(int x1, int y1, int x2, int y2){
		// int x = Math.abs(x1-x2);
		// int y = Math.abs(y1-y2);

		// if(x != y){
			// int p = 0;
			// if(x2>x1 && y2>y1){
				// p += Math.min(x2-x1, y2-y1);
				// return p + king(Math.min(x2-x1, y2-y1), Math.min(x2-x1, y2-y1), x2, y2);
			// }
			// else{
				// return Math.abs(x1-x2) + Math.abs(y1-y2);
			// }

		// }
		// else{
			// return x;
		// }

	// }

}

import java.util.*;

public class R217Div2QA {
	public static void main(String[] args){
		Scanner s = new Scanner(System.in);
		int r1 = s.nextInt(), c1 = s.nextInt();
		int r2 = s.nextInt(), c2 = s.nextInt();
		int R = 2;
		if(r1 == r2)	R--;
		if(c1 == c2)	R--;
		int B = 2;
		int dr = Math.abs(r1-r2);
		int dc = Math.abs(c1-c2);
		if(dr == dc)
			B = 1;
		else{
			if(dr % 2 != 0 || dc % 2 != 0)
				B = 0;
		}
		int K = 0;
		if(dr == dc)
			K = dr;
		else
			K = dr + dc;

		System.out.println(R + " " + B + " " + K);
	}
}

import java.util.Scanner;

public class Chess {
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        int r1=s.nextInt();
        int c1=s.nextInt();
        int r2=s.nextInt();
        int c2=s.nextInt();
        int r=Math.abs(r2-r1);int c=Math.abs(c2-c1);
        if(r==0||c==0){
            System.out.print("1"+" ");
            if (r == 0) {
                if(c%2==0){
                    System.out.print(c+" ");
                }
                else System.out.print("0"+" ");
                System.out.print(c+" ");
            }
           else if(c==0){
                if(r%2==0){
                    System.out.print(r+" ");
                }
                else System.out.print("0"+" ");
               System.out.print(r+" ");
            }
        }
        else {
            System.out.print("2"+" ");
            if(r==c){
                System.out.print("1"+" ");
                System.out.print(r+" ");
            }
            else {
                int o=Math.min(c,r);
                System.out.print("0"+" ");
                System.out.print((o+1));
            }

        }
    }
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Young {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();

		int a = 0, b = 0, c = 0;

		if(c1 == c2 || r1 == r2) a = 1; else a = 2;
		if(r1 + c1 == r2 + c2 || r1 - c1 == r2 - c2) b = 1; else b = 0;
		c = Math.max(Math.abs(r1-r2), Math.abs(c1-c2));

		System.out.println(c == 2 ? a+" "+"2"+" "+c : a+" "+b+" "+c);
	}
}

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

public class RookBishopKing
{

	public static void main(String args[])
	{

		FastReader sc= new FastReader();
		PrintWriter out = new PrintWriter(System.out);

		int r1,c1,r2,c2,i;
		String s;

		r1=sc.nextInt();
		c1=sc.nextInt();
		r2=sc.nextInt();
		c2=sc.nextInt();

		if(r1==r2 || c1==c2)
			out.print(1+" ");
		else
			out.print(2+" ");

		if(((r1==r2) || (c1==c2)) && (((r1+c1)%2==0 && (r2+c2)%2==0) || ((r1+c1)%2!=0 && (r2+c2)%2!=0))) {
			out.print(2+" ");
		}
		else {
		if(((r1+c1)%2==0 && (r2+c2)%2==0) || ((r1+c1)%2!=0 && (r2+c2)%2!=0))
			out.print(1+" ");
		else
			out.print(0+" ");
		}

		if(r1==r2 || c1==c2)
		out.println(Math.abs(r1-r2)+Math.abs(c1-c2));
		else
			out.println((Math.min(Math.abs(r1-r2),Math.abs(c1-c2))));

		out.close();
	}

	/*
		FASTREADER
	*/
	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;
        }

		/*DEFINED BY ME
		*/
		int[] readArray(int n){

			int arr[]=new int[n];

			for(int i=0;i<n;i++)
				arr[i]=nextInt();

			return arr;
		}
    }
}

import java.util.*;
public class RookBishopKing
{
public static Scanner sc;
public static void main(String[] args)
{
sc = new Scanner (System.in);
int r1 = sc.nextInt();
int c1 = sc.nextInt();
int r2 = sc.nextInt();
int c2 = sc.nextInt();
char source = 'B';
char target = 'B';
if ((r1%2==0&&c1%2==0)||(r1%2!=0&&c1%2!=0))
    source = 'W';
if ((r2%2==0&&c2%2==0)||(r2%2!=0&&c2%2!=0))
    target = 'W';
int Rook = 0;
int Bishop = 0;
int King = 0;
if (r1==r2||c1==c2)
    Rook = 1;
else
    Rook = 2;
if (source!=target)
    Bishop = 0;
else
{
    if (Math.abs(r1-r2)==Math.abs(c1-c2))
        Bishop = 1;
    else
        Bishop = 2;
}

if (r1==r2||c1==c2)
    King += Math.abs(r1-r2)+Math.abs(c1-c2);
else
{
int min = 0;
if (Math.abs(r1-r2)<Math.abs(c1-c2))
{
    min = Math.abs(r1-r2);
    if (c1>c2)
    c1 -=min-1;
    else
    c1 += min-1;
}
else
{
    min = Math.abs(c1-c2);
    r1 =Math.abs(min-r1);
}
King += min+Math.abs(r1-r2);

}

System.out.println(Rook+" "+Bishop+" "+King);
}
}

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

public class RookBishopAndKing {

    public static void main(String [] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        StringTokenizer st = new StringTokenizer(br.readLine());

        int r1 = Integer.parseInt(st.nextToken());
        int c1 = Integer.parseInt(st.nextToken());
        int r2 = Integer.parseInt(st.nextToken());
        int c2 = Integer.parseInt(st.nextToken());

        if(r1 == r2 && c1 == c2) bw.write("0 0 0");
        else
        {
            if(r1 == r2 || c1 == c2) bw.write("1 ");
            else bw.write("2 ");

            int r = Math.abs(r2-r1);
            int c = Math.abs(c2-c1);

            if( r == c)
                bw.write("1 ");
            else
                if(r % 2 != 0 || c % 2 != 0)
                    bw.write("0 ");
                else
                    bw.write("2 ");

            bw.write(Integer.toString(Math.max(r, c)));

        }

        bw.flush();
    }
}

import java.util.*;

public class jj {
	static Scanner in = new Scanner(System.in);

	public static void main(String[] args) {
		int x1=in.nextInt(),y1=in.nextInt(),x2=in.nextInt(),y2=in.nextInt();
		int rook,bishop,king;
		if(x1==x2||y1==y2)
		{
			rook=1;
		}
		else
		{
			rook=2;
		}
		if((x1+y1)%2 == (x2+y2)%2)
		{
			if(Math.abs(x1-x2)==Math.abs(y1-y2))
			{
				bishop=1;
			}
			else
			{
				bishop=2;
			}
		}
		else
		{
			bishop=0;
		}
		if(x1==x2)
		{
			king =Math.abs(y1-y2);
		}
		else
		{
			king =Math.abs(x1-x2);
		}
		System.out.println(rook+" "+bishop+" "+king);

	}

}

import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

public class TaskA
{
    Scanner in;
    PrintWriter out;

    int c1, c2, r1 ,r2;

    int r, b, k;

    public static void main(String[] args)
    {
        TaskA mainTest = new TaskA();

        mainTest.readData();
        mainTest.solve();
        mainTest.outputData();
    }

    public TaskA()
    {
        in = new Scanner(System.in);
        out = new PrintWriter(new OutputStreamWriter(System.out));
    }

    public void readData()
    {
        c1 = in.nextInt();
        r1 = in.nextInt();
        c2 = in.nextInt();
        r2 = in.nextInt();
    }

    int findRookPath(int c1, int r1, int c2, int r2) {
        if (c1 == c2 && r1 == r2) {
            return 0;
        } else if (c1 == c2 || r1 == r2){
            return 1;
        } else {
            return 2;
        }
    }

    int findBishopPath(int c1, int r1, int c2, int r2) {
        if (c1 == c2 && r1 == r2) {
            return 0;
        } else if (c1 + r1 == c2 + r2 || c1 - r1 == c2 - r2){
            return 1;
        } else if ((c1 + r1) % 2 == (c2 + r2 % 2)) {
            return 2;
        } else {
            return 0;
        }
    }

    int findKingPath(int c1, int r1, int c2, int r2) {
        return Math.max(Math.abs(c1 - c2), Math.abs(r1 - r2));
    }

    public void solve()
    {
        r = findRookPath(c1, r1, c2, r2);
        b = findBishopPath(c1, r1, c2 ,r2);
        k = findKingPath(c1, r1, c2, r2);
    }

    public void outputData()
    {
        out.println(r + " " + b + " " + k);
        out.flush();
    }
}

import java.io.PrintWriter;
import java.util.*;
public class CD1 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();
        if (r1 == r2 || c1 == c2)
            pw.print(1 + " ");
        else
            pw.print(2 + " ");
        //
        if ((r1+c1)%2 != (r2 + c2))
            pw.print(0 + " ");
        else if (r1-c1==r2-c2 || r1+c1==r2+c2)
            pw.print(1 + " ");
        else
            pw.print(2 + " ");
        //
        if (Math.abs(r1-r2) >= Math.abs(c1-c2))
            pw.print(Math.abs(r1-r2));
        else
            pw.print(Math.abs(c1-c2));

        sc.close();
        pw.close();
    }
}

import java.util.*;
public class chessBoard {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int xs=scn.nextInt();
		int ys=scn.nextInt();
		int xd=scn.nextInt();
		int yd=scn.nextInt();

		if(xd==xs || yd==ys)
			System.out.println("1");
		else
			System.out.println("2");

		if(((xs+ys)%2==0 && (xd+yd)%2==0)||((xs+ys)%2!=0 && (xd+yd)%2!=0))
		{
			if(xs+ys==xd+yd)
				System.out.println("1");
			else {
				if((xs>=ys && xd>=yd)||(xs<=ys && xd<=yd))
					System.out.println("1");
				else
					System.out.println("2");
			}
		}
		else {
			System.out.println("0");
		}

	{
		int count=Math.min(Math.abs(xs-xd),Math.abs(ys-yd));
		if(Math.abs(xs-xd)<Math.abs(ys-yd)) {
			if(xs<=xd && ys<yd)
				ys=ys+count;
			else if(xs>=xd && ys>yd)
				ys=ys-count;
			else if(xs<=xd && ys>yd)
				ys=ys-count;
			else if(xs>=xd && ys<yd)
				ys=ys+count;
			System.out.println(count+Math.abs(ys-yd));
		}
		else if(Math.abs(xs-xd)>Math.abs(ys-yd))
		{
			if(xs<xd && ys<=yd)
				xs=xs+count;
			else if(xs>xd && ys>=yd)
				xs=xs-count;
			else if(xs<xd && ys>=yd)
				xs=xs-count;
			else if(xs>xd && ys<=yd)
				xs=xs+count;
			System.out.println(count+Math.abs(xs-xd));
		}
		else
		System.out.println(count);
	}
	}

}

import java.io.*;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
import java.lang.Math;
import java.util.ArrayList;
import java.util.*;
import java.math.*;

public class rook{

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();

		int rook = 0;
		int bishop = 0;
		int king = 0;

		if(r1 == r2 || c1 == c2){
			rook = 1;
		}
		else{
			rook = 2;
		}

		king = Math.max(Math.abs(r1 - r2),Math.abs(c1 - c2));

		if(Math.abs(r1 - r2) == Math.abs(c1 - c2)){
			bishop = 1;
		}

		System.out.println(rook + " " + bishop + " " + king);

	}
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Collections;
import java.lang.Math;
/**
 *
 * @author SONY
 */
public class chess {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
    Scanner s = new Scanner(System.in);
    int r1,r2,c1,c2;
    int n1,n2,n3;
    r1=s.nextInt();
    c1=s.nextInt();
    r2=s.nextInt();
    c2=s.nextInt();
    // if(c2<c1)
      //      n1=n2=n3=0;
     //else
     //{
    //for rook (goes horixontally and vertically any no. of steps )
    if(r1==r2||c1==c2)
    {

    if(r1==r2&&c1==c2)
        n1=0;

    else
        n1=1;
    }
    else
            n1=2;
      //for bishop (goes vertically any no. of steps
    int y =c2-c1;
    int x=r2-r1;
     int x1 ,x2,y1,y2;
    x1=r2-1;
    y1=c2-1;
    x2=r2+1;
    y2=c2-1;
    //diagonal qs
    if(x==y||x==((-1)*y))
    {
        n2=1;
    }

    else if((x2-r1)==(y2-c1)||(x2-r1)==(c1-y2))
        n2=2;
    else if((x1-r1)==(y1-c1)||(x1-r1)==(c1-y1))
        n2=2;
    else
        n2=0;

    // for king (1 move only any direction)
      if(x==y||x==((-1)*y)) //diagonal
      {
            n3=y;
      }
      else if ((r1==r2))
          n3=c2-c1;
        else if ((c1==c2))
          n3=r2-r1;
        else
        {
            if(r2<c2)
            {
                //a=r2;
                int b=c1+r2-r1;
                n3=r2-r1-1+c2-b;

            }
            else //a=c2;
            {
                int c=r1+r2-r1;
                n3=c2-c1+r2-c;
            }
        }
    // }
     n1=Math.abs(n1);
     n2=Math.abs(n2);
     n3=Math.abs(n3);
    System.out.println(n1+" "+n2+" "+n3);
    }
}

import java.util.Scanner;

public class Chess {
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        int r1=s.nextInt();
        int c1=s.nextInt();
        int r2=s.nextInt();
        int c2=s.nextInt();
        int r=Math.abs(r2-r1);int c=Math.abs(c2-c1);
        if(r==0){
            System.out.print("1"+" ");
            System.out.print("0"+" ");
            System.out.println(c);
        }
        else {
            System.out.print("2"+" ");
            if(r==c){
                System.out.print("1"+" ");
                System.out.print(r+" ");
            }
            else {
                int o=Math.min(c,r);
                System.out.print("0"+" ");
                System.out.print((o+1));
            }

        }
    }
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Solution
{	static int x1 =0;
	static int y1 = 0;
	static int x2 =0;
	static int y2 = 0;

	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		x1 = Integer.parseInt(st.nextToken());
		y1 = Integer.parseInt(st.nextToken());
		x2 = Integer.parseInt(st.nextToken());
		y2 = Integer.parseInt(st.nextToken());
		int r=0;
		int b=0;
		int k=0;
		if (x1==x2||y1==y2){
			r=1;

		}else{
			r=2;
		}
		if (x1==x2){
			if (Math.abs(y2-y1)%2==0){
				b=2;
			}
		}
		else if (y1==y2){
			if (Math.abs(x2-x1)%2==0){
				b=2;
			}
		}
		else if (Math.abs(x2-x1)==Math.abs(y2-y1)){
			b=1;
		}
		else if ((x1%2==0&&y1%2==0)||(x1%2!=0&&y1%2!=0)){
				if ((x1%2==0&&y1%2==0)||(x1%2!=0&&y1%2!=0)){
					b=2;
				}
				else {
					b=0;
				}
		}
		else if ((x1%2!=0&&y1%2==0)||(x1%2==0&&y1%2!=0)){
				if ((x1%2!=0&&y1%2==0)||(x1%2==0&&y1%2!=0)){
					b=2;
				}
				else {
					b=0;
				}
		}

		if (x1==x2){

				k=Math.abs(y2-y1);

		}
		else if (y1==y2){
				k = Math.abs(x2-x1);

		}
		else if (Math.abs(x2-x1)==Math.abs(y2-y1)){
			k=Math.abs(x2-x1);
		} else {
			int tempx = Math.abs(x2-x1);
			int tempy = Math.abs(y2-y1);
			if(tempx<tempy){
				k=tempy;
			}
			else{
				k=tempx;
			}
		}
		System.out.println(r+" "+b+" "+k);
	}
}

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

/**
 *
SXXXXX
XFXXXX
XXFFEX
XXXXXX
(1,1)->(3,5) = 5
(1,1)->(3,2)

 12345678
1#####E##
2####*#E#
3###*###E
4##S###E#
5#CX#XC##
6##CXC###
7###C####
8########
 124567
1*D*D*D
2D*D*D*
3*D*D*D
4D*D*D*
5*D*D*D

(4,3)-(1,6)

(1,3)-(3,5)
(1,2)-(2,1)
 *
 *
 * */
public class A_Div2_217 {
    public static void main(String[]arg) throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int r1,c1,r2,c2;
        StringTokenizer st = new StringTokenizer(in.readLine());
        r1 = Integer.parseInt(st.nextToken());
        c1 = Integer.parseInt(st.nextToken());
        r2 = Integer.parseInt(st.nextToken());
        c2 = Integer.parseInt(st.nextToken());
        int rook = 0,bishop = 0,king = 0;
        if(c1 == c2 || r1 == r2)
            rook = 1;
        else
            rook = 2;
        if(Math.abs(c1-c2) == Math.abs(r1-r2))
            bishop = 1;
        else{
            if(Math.abs(c1-c2)%2 == 0 ||  Math.abs(r1-r2)%2 != 1)
                bishop = 2;
        }
        king = Math.max(Math.abs(r1-r2), Math.abs(c1-c2));
        System.out.println(rook+" "+bishop+" "+king);
    }
}

import java.io.*;
import java.security.KeyPair;
import java.util.*;

public class Main
{
	public static int[][] arr = new int[1][1];
	public static boolean[][] visited = new boolean[1][1];
	public static boolean game = false;
    public static void main(String[] args)
    {
    	Scanner sc = new Scanner(System.in);
    	int currenti = sc.nextInt();
    	int currentj = sc.nextInt();
    	int reachi = sc.nextInt();
    	int reachj = sc.nextInt();
    	char[][] arr = new char[8][8];
    	char Point = 'W';
    	for(int i = 0; i < 8;i++) {
    		for(int j = 0; j < 8;j++) {
    			arr[i][j] = Point;
    			if(Point == 'W') {
    				Point = 'B';
    			}else {
    				Point='W';
    			}
    		}
    		if(Point == 'W') {
				Point = 'B';
			}else {
				Point='W';
			}
    	}

    	if(currenti == reachi && currentj == reachj) {
    		System.out.print(0 + " " );
    	}else if(currenti == reachi || currentj == reachj) {
    		System.out.print(1 + " ");
    	}else {
    		System.out.print(2+ " ");
    	}
    	char b = arr[currenti-1][currentj-1];
    	char k = arr[reachi-1][reachj-1];
    	if(b != k) {
    		System.out.print(0+ " ");
    	}else if(checkdiagnol(currenti,currentj,reachi,reachj)) {
    		System.out.print(1+ " ");
    	}else {
    		System.out.print(2+ " ");
    	}
    	System.out.println(Max(Math.abs(currenti-reachi),Math.abs(currentj-reachj)));
    }
   public static int Max(int a , int b) {
	   if(a > b) {
		   return a;
	   }
	   return b;
   }
    public static boolean checkdiagnol(int ci,int cj, int ri,int rj) {
    	int cci = ci;
    	int ccj = cj;
    	while(cci >= 0 && ccj >=0) {
    		if(cci == ri && ccj == rj) {
    			return true;
    		}
    		cci--;
    		ccj--;
    	}
    	cci = ci;
        ccj = cj;
    	while(cci < 8 && ccj < 8) {
    		if(cci == ri && ccj == rj) {
    			return true;
    		}
    		cci++;
    		ccj++;
    	}
    	cci = ci;
        ccj = cj;
    	while(cci >=0 && ccj < 8) {
    		if(cci == ri && ccj == rj) {
    			return true;
    		}
    		cci--;
    		ccj++;
    	}
    	cci = ci;
        ccj = cj;
    	while(cci < 8 && ccj >= 0) {
    		if(cci == ri && ccj == rj) {
    			return true;
    		}
    		cci++;
    		ccj--;
    	}
    	return false;

    }
}

import java.util.*;
public class Ques1{
public static void main(String args[]){
Scanner in=new Scanner(System.in);
int x1=in.nextInt();
int y1=in.nextInt();
int x2=in.nextInt();
int y2=in.nextInt();
int rook=find_rook(x1,y1,x2,y2);
int bishop=find_bishop(x1,y1,x2,y2);
int king=find_king(x1,y1,x2,y2);
System.out.println(rook+" "+bishop+" "+king);

}
private static int find_rook(int x1,int y1,int x2,int y2){
if(x1==x2 || y1==y2)
  return 1;
  else
   return 2;

}

private static int find_bishop(int x1,int y1,int x2,int y2){
if((x1+y1)%2==0 && (x2+y2)%2==0){
if(Math.abs(x1-x2) == Math.abs(y1-y2) || ((x1+x2) ==(y1+y1)))
     return 1;
     else
      return 2;

}
else if((x1+y1)%2==1 && (x2+y2)%2==1){
if(Math.abs(x1-x2) == Math.abs(y1-y2)|| ((x1+x2) ==(y1+y1)))
     return 1;
     else
      return 2;

}
else
 return 0;
}

private static int find_king(int x1,int y1,int x2,int y2){
int k=Math.max(Math.abs(x1-x2),Math.abs(y1-y2));
return k;
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class chess {
     public static void main(String[] args) throws IOException {
        BufferedReader sc = new BufferedReader(new InputStreamReader(System.in));
                String[] s = sc.readLine().split(" ");
                int hathi =0;
                int uth =0;
                int raja =0;
                int r1 = Integer.parseInt(s[0]),c1 = Integer.parseInt(s[1]),r2 = Integer.parseInt(s[2]),c2 = Integer.parseInt(s[3]);
                if(r1!=r2 && c1!=c2){
                      hathi = 2;
                }
                else if((r1==r2 && c1!=c2)||(r1!=r2 && c1==c2)){
                      hathi = 1;
                }
                else if(r1==r2 && c1==c2){
                      hathi = 0;
                }
                if(((r1+c1)%2==0 && (r2+c2)%2==0) || ((r1+c1)%2!=0 && (r2+c2)%2!=0)){
                    if(r1!=r2 && c1!=c2){
                      uth = 1;
                    }
                    else if(r1==r2 && c1==c2){
                      uth = 0;}
                    else if((r1==r2 && c1!=c2)||(r1!=r2 && c1==c2)){
                      uth = 2;
                    }}
                else{ uth =0;}
                raja = Math.max(Math.abs(r1-r2), Math.abs(c1-c2));
                System.out.println(hathi+" "+uth+" "+raja);
     }
}

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

public class Main implements Runnable {

	public void solve() throws IOException {
		int r1 = nextInt();
                int c1 = nextInt();
                int r2 = nextInt();
                int c2 = nextInt();

                int a = (r1 == r2 || c1 == c2) ? 1 : 2;
                int b = 0;
                if(Math.abs(r1 - r2) == Math.abs(c1 - c2)){
                        b = 1;
                }
                else if(Math.abs(r1 - r2) + Math.abs(c1 - c2) % 2 == 0){
                        b = 2;
                }
                else b = 0;

                int c = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));

                System.out.println(a + " " + b + " " + c);
	}

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

	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.*;
import java.math.*;
import java.util.*;

public class A {

	public static void main(String[] agrs) {
		FastScanner sc = new FastScanner();
//		int n = sc.nextInt();
//		while(n-->0) {
//
//		}

		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();

//		the rook

		if(r1 == r2 || c1 == c2) {
			System.out.print(1 + " ");
		}
		else {
			System.out.print(2 + " ");
		}

//		the bishop

		if(Math.abs(r1-r2)-Math.abs(c1-c2) != 0) {
			System.out.print(0 + " ");
		}
		else if((c1%c2 == 0 || c2%c1 == 0) && (r1%r2 == 0 || r2%r1 == 0)) {
			System.out.print(1 + " ");
		}
		else {
			System.out.print(2 + " ");
		}

//		the king

		System.out.print(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
		System.out.println();

	}

	static int gcd(int a, int b) {
		return a%b == 0 ? b : gcd(b,a%b);
	}

	static int mod = 1000000007;

	static long pow(int a, int b) {
		if(b == 0) {
			return 1;
		}
		if(b == 1) {
			return a;
		}
		if(b%2 == 0) {

			long ans = pow(a,b/2);
			return ans*ans;
		}
		else {
			long ans = pow(a,(b-1)/2);
			return a * ans * ans;
		}

	}

	static boolean[] sieve(int n) {

		boolean isPrime[] = new boolean[n+1];
		for(int i = 2; i <= n; i++) {
			if(isPrime[i]) continue;
			for(int j = 2*i; j <= n; j+=i) {
				isPrime[j] = true;
			}
		}
		return isPrime;
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}

}

import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * Created by jizhe on 2015/12/19.
 */
public class RookBishopAndKing {
    public static void main(String[] args) {
        Scanner in = new Scanner(new BufferedInputStream(System.in));

        int r1 = in.nextInt();
        int c1 = in.nextInt();
        int r2 = in.nextInt();
        int c2 = in.nextInt();

        if( r1 == r2 || c1 == c2 )
        {
            System.out.printf("1 ");
        }
        else
        {
            System.out.printf("2 ");
        }

        int rDiff = Math.abs(r1-r2);
        int cDiff = Math.abs(c1-c2);
        if( rDiff == cDiff )
        {
            System.out.printf("1 ");
        }
        else if( (r1 == r2 && cDiff%2 == 0)|| (c1 == c2 && rDiff%2 == 0) )
        {
            System.out.printf("%d ", Math.max(cDiff, rDiff));
        }
        else
        {
            System.out.printf("0 ");
        }

        System.out.printf("%d\n", Math.max(Math.abs(r1-r2), Math.abs(c1-c2)));
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class CF370A {

    static class Info{
        int x;
        int y;
        Info(int x,int y){
            this.x = x;
            this.y = y;
        }
    }
    public static void main(String[] args) {
        FastReader input = new FastReader();
        PrintWriter pw = new PrintWriter(System.out);

        int x1 = input.nextInt();
        int y1 = input.nextInt();
        int x2 = input.nextInt();
        int y2 = input.nextInt();

        int rook = 0;

        if(x1 == x2 && y1  == y2)
            rook = 0;
        else{
            if(x1 == x2 || y1 == y2)
                rook = 1;
            else
                rook = 2;
        }

        int bisop = 0;

        if(x1 == x2 && y1 == y2){
            bisop = 0;
        }
        else{
            int tempX = x1;
            int tempY = y1;

            // left diag
            boolean left = false;

            while (tempX >= 1 && tempY >= 1){
                tempX--;
                tempY--;
                if(tempX == x2 && tempY == y2){
                    left = true;
                    break;
                }
            }
            boolean right = false;
            tempX = x1;
            tempY = y1;

            while (tempX >= 1 && tempY <= 8){
                tempY++;
                tempX--;
                if(tempX == x2 && tempY == y2){
                    right = true;
                    break;
                }
            }
            boolean downLeft = false;
            tempX = x1;
            tempY = y1;

            while (tempX <= 8 && tempY >= 1){
                tempX--;
                tempY--;
                if(tempX == x2 && tempY == y2){
                    downLeft = true;
                    break;
                }
            }
            boolean downRight = false;
            tempX = x1;
            tempY = y1;

            while (tempX <= 8 && tempY <= 8){
                tempX++;
                tempY++;
                if(tempX == x2 && tempY == y2){
                    downRight = true;
                    break;
                }
            }
            if(left || right || downLeft || downRight){
                bisop = 1;
            }
            else{
                boolean[][] visited = new boolean[9][9];
                int[][] level = new int[9][9];

                for(int i = 1;i <= 8;i++){
                    for(int j = 1;j <= 8;j++){
                        level[i][j] = Integer.MAX_VALUE;
                    }
                }

                LinkedList<Info> queue = new LinkedList<Info>();
                queue.add(new Info(x1,y1));
                visited[x1][y1] = true;
                level[x1][y1] = 0;

                while (!queue.isEmpty()){
                    Info curr = queue.poll();

                    int x = curr.x;
                    int y = curr.y;

                    if(x+1 <= 8 && y+1 <= 8){
                        if(!visited[x+1][y+1]){
                            visited[x+1][y+1] = true;
                            level[x+1][y+1] = Math.min(level[x+1][y+1],level[x][y]+1);
                            queue.add(new Info(x+1,y+1));
                        }
                    }

                    if(x-1 >= 1 && y-1 >= 1){
                        if(!visited[x-1][y-1]){
                            visited[x-1][y-1] = true;
                            level[x-1][y-1] = Math.min(level[x-1][y-1],level[x][y]+1);
                            queue.add(new Info(x-1,y-1));
                        }
                    }

                    if(x+1 <= 8 && y-1 >= 1){
                        if(!visited[x+1][y-1]){
                            visited[x+1][y-1] = true;
                            level[x+1][y-1] = Math.min(level[x+1][y-1],level[x][y]+1);
                            queue.add(new Info(x+1,y-1));
                        }
                    }

                    if(x-1 >= 1 && y+1 <= 8){
                        if(!visited[x-1][y+1]){
                            visited[x-1][y+1] = true;
                            level[x-1][y+1] = Math.min(level[x-1][y+1],level[x][y]+1);
                            queue.add(new Info(x-1,y+1));
                        }
                    }

                }

                if(visited[x2][y2]){
                    bisop = 2;
                }
                else{
                    bisop = 0;
                }
            }
        }

        int king = 0;

        if(x1 == x2 && y1 == y2){
            king = 0;
        }
        else{
            boolean[][] visited = new boolean[9][9];
            int[][] level = new int[9][9];

            for(int i = 1;i <= 8;i++){
                for(int j = 1;j <= 8;j++){
                    level[i][j] = Integer.MAX_VALUE;
                }
            }

            LinkedList<Info> queue = new LinkedList<Info>();
            queue.add(new Info(x1,y1));
            visited[x1][y1] = true;
            level[x1][y1] = 0;

            while (!queue.isEmpty()){
                Info curr = queue.poll();

                int x = curr.x;
                int y = curr.y;

                if(x+1 <= 8 && y+1 <= 8){
                    if(!visited[x+1][y+1]){
                        visited[x+1][y+1] = true;
                        level[x+1][y+1] = Math.min(level[x+1][y+1],level[x][y]+1);
                        queue.add(new Info(x+1,y+1));
                    }
                }

                if(x-1 >= 1 && y-1 >= 1){
                    if(!visited[x-1][y-1]){
                        visited[x-1][y-1] = true;
                        level[x-1][y-1] = Math.min(level[x-1][y-1],level[x][y]+1);
                        queue.add(new Info(x-1,y-1));
                    }
                }

                if(x+1 <= 8 && y-1 >= 1){
                    if(!visited[x+1][y-1]){
                        visited[x+1][y-1] = true;
                        level[x+1][y-1] = Math.min(level[x+1][y-1],level[x][y]+1);
                        queue.add(new Info(x+1,y-1));
                    }
                }

                if(x-1 >= 1 && y+1 <= 8){
                    if(!visited[x-1][y+1]){
                        visited[x-1][y+1] = true;
                        level[x-1][y+1] = Math.min(level[x-1][y+1],level[x][y]+1);
                        queue.add(new Info(x-1,y+1));
                    }
                }

                if(x-1 >= 1 && y >= 1 && y <= 8){
                    if(!visited[x-1][y]){
                        visited[x-1][y] = true;
                        level[x-1][y] = Math.min(level[x-1][y],level[x][y] + 1);
                        queue.add(new Info(x-1,y));
                    }
                }
                // down
                if(x+1 <= 8 && y >= 1 && y <= 8){
                    if(!visited[x+1][y]){
                        visited[x+1][y] = true;
                        level[x+1][y] = Math.min(level[x+1][y],level[x][y] + 1);
                        queue.add(new Info(x+1,y));
                    }
                }
                // left
                if(y-1 >= 1 && x >= 1 && x <= 8){
                    if(!visited[x][y-1]){
                        visited[x][y-1] = true;
                        level[x][y-1] = Math.min(level[x][y-1],level[x][y] + 1);
                        queue.add(new Info(x,y-1));
                    }
                }

                // right
                if(y+1 <= 8 && x >= 1 && x <= 8){
                    if(!visited[x][y+1]){
                        visited[x][y+1] = true;
                        level[x][y+1] = Math.min(level[x][y+1],level[x][y] + 1);
                        queue.add(new Info(x,y+1));
                    }
                }

            }

            king = level[x2][y2];
        }

        pw.println(rook + " " + bisop + " " + king);

        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.io.*;
import java.math.*;
import java.util.*;

public class A {

	public static void main(String[] agrs) {
		FastScanner sc = new FastScanner();
//		int n = sc.nextInt();
//		while(n-->0) {
//
//		}

		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();

//		the rook

		if(r1 == r2 || c1 == c2) {
			System.out.print(1 + " ");
		}
		else {
			System.out.print(2 + " ");
		}

//		the bishop

		if(c1%c2 != 0 && c2%c1 != 0) {
			System.out.print(0 + " ");
		}
		else if((c1%c2 == 0 || c2%c1 == 0) && (r1%r2 == 0 || r2%r1 == 0)) {
			System.out.print(1 + " ");
		}
		else {
			System.out.print(2 + " ");
		}

//		the king

		System.out.print(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
		System.out.println();

	}

	static int gcd(int a, int b) {
		return a%b == 0 ? b : gcd(b,a%b);
	}

	static int mod = 1000000007;

	static long pow(int a, int b) {
		if(b == 0) {
			return 1;
		}
		if(b == 1) {
			return a;
		}
		if(b%2 == 0) {

			long ans = pow(a,b/2);
			return ans*ans;
		}
		else {
			long ans = pow(a,(b-1)/2);
			return a * ans * ans;
		}

	}

	static boolean[] sieve(int n) {

		boolean isPrime[] = new boolean[n+1];
		for(int i = 2; i <= n; i++) {
			if(isPrime[i]) continue;
			for(int j = 2*i; j <= n; j+=i) {
				isPrime[j] = true;
			}
		}
		return isPrime;
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}

}

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

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Pranay2516
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(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, FastReader in, PrintWriter out) {
            int r1 = in.nextInt(), c1 = in.nextInt(), r2 = in.nextInt(), c2 = in.nextInt();
            out.print((r1 == r2 || c1 == c2 ? 1 : 2) + " ");
            if ((r1 + c1) % 2 != (r2 + c2) % 2) out.print(0 + " ");
            else out.print((r1 + r2 == c1 + c2 || Math.abs(r1 - r2) == Math.abs(c1 - c2) ? 1 : 2) + " ");
            out.print(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));
        }

    }

    static class FastReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private FastReader.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 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 c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

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

        }

    }
}

import java.util.Scanner;

public class rbk {

	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();
		int rk = 0;
		int bi = 0;
		int k = 0;
		// for rook
		if (r1 == r2 || c1 == c2) {
			rk = 1;
		} else {
			rk = 2;
		}

		// for bishop
		if ((r1 == r2 && Math.abs(c1 - c2) != 2) || c1 == c2) {
			bi = 0;
		} else {
			if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) {
				bi = 1;
			} else if (r1 == r2) {
				bi = Math.abs(c1 - c2);
			} else {
				int x = r1;
				int y = c1;
				int z = r2;
				int w = c2;
				if (r1 > r2) {
					x = x - 3;
					y = y + 3;
				} else {
					x += 3;
					y -= 3;
				}
				if (Math.abs(x - r2) == Math.abs(y - c2)) {
					bi = 2;
				} else {
					bi = 0;
				}

			}
		}

		// for king

		if (r1 == r2) {
			k = Math.abs(c1 - c2);
		} else if (c1 == c2) {
			k = Math.abs(r1 - r2);
		} else {
			k=Math.max(Math.abs(c1 - c2),  Math.abs(r1 - r2));
		}

		System.out.println(rk + " " + bi + " " + k);
	}
}

import java.util.Scanner;

/**
 *
 * @author Rakhat
 */
public class a {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        if (x1 == x2 || y1 == y2) System.out.print(1+" "); else System.out.print(2+" ");
        if ((x1+y1) == (x2 + y2)){
            if((Math.abs(x2 - x1) == Math.abs(y2 - y1))) System.out.print(1+" "); else System.out.print(2+" ");
        } else System.out.print(0+" ");
        System.out.print(Math.max(Math.abs(x1-x2), Math.abs(y1-y2)));
    }
}

import java.util.Scanner;

public class Chess {
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        int r1=s.nextInt();
        int c1=s.nextInt();
        int r2=s.nextInt();
        int c2=s.nextInt();
        int r=Math.abs(r2-r1);int c=Math.abs(c2-c1);
        if(r==0||c==0){
            System.out.print("1"+" ");
            System.out.print("0"+" ");
            if (r == 0) {
                if(c%2==0){
                    System.out.print(c+" ");
                }
                else System.out.println("0"+" ");
                System.out.print(c+" ");
            }
           else if(c==0){
                if(r%2==0){
                    System.out.print(r+" ");
                }
                else System.out.println("0"+" ");
               System.out.print(r+" ");
            }
        }
        else {
            System.out.print("2"+" ");
            if(r==c){
                System.out.print("1"+" ");
                System.out.print(r+" ");
            }
            else {
                int o=Math.min(c,r);
                System.out.print("0"+" ");
                System.out.print((o+1));
            }

        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;

@SuppressWarnings("unused")
public class A {
	public  static  FastScannerA scan = new FastScannerA();
	public static PrintWriter out = new PrintWriter(System.out);
	public static void solve () {
		int r1=scan.nextInt();
		int c1=scan.nextInt();
		int r2=scan.nextInt();
		int c2=scan.nextInt();
		out.print((r1==r2 || c1==c2) ?"1":"2");
		if((r1+c1)%2!=(r2+c2)%2)out.print(" "+"0"+"");
		else {
			out.print((r1 + c1 == r2 + c2 || r1 - c1 == r2 - c2)?" "+"1":"2");
		}
		out.print(" ");
		out.println(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
	}
	public static void main(String[] args) {

		solve();
		out.close();
	}

}
class FastScannerA {
	BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer st= new StringTokenizer("");
	String next() {
		while (!st.hasMoreTokens())
			try {
				st=new StringTokenizer(br.readLine());
			} catch (IOException e) {
				e.printStackTrace();
			}
		return st.nextToken();
	}
	int nextInt() {
		return Integer.parseInt(next());
	}
	int[] readArray(int n) {
		int[] a=new int[n];
		for (int i=0; i<n; i++) a[i]=nextInt();
		return a;
	}
	long nextLong() {
		return Long.parseLong(next());
	}
	void sort(long[] a) {
		ArrayList<Long> l=new ArrayList<>();
		for (long i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

}

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

//package javaapplication1;

import java.util.*;

/**
 *
 * @author 555
 */
public class Main{

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner(System.in);

     int a = sc.nextInt();
     int b= sc.nextInt();
     int c = sc.nextInt();
     int d = sc.nextInt();
     int ret1=0;
     int ret2 =0;
     int ret3=0;
     if(a==c && b==d) ret1=0;
     else if(a==c || b==d) ret1=1;
     else ret1= 2;

     if(a==c && b==d) ret2=0;
     else if(
             (a+b)%2
             ==
             (c+d)%2){
         if(a+b==c+d) ret2 =1;
         else ret2 =2;
     }
     else ret2 =0;

     ret3 = Math.max(Math.abs(a-c),Math.abs(b-d));
     System.out.println(ret1+" "+ret2+" "+ret3);

    }

}

import java.util.*;
public class _370A_ {

    /**
     * @param args
     */
    private int r1;
    private int c1;
    private int r2;
    private int c2;
    private static _370A_ a;
    private static Scanner sc;

    public _370A_(int r1, int c1, int r2, int c2){
        this.r1 = r1;
        this.r2 = r2;
        this.c1 = c1;
        this.c2 = c2;
    }
    public int CheckRock(){
        if(r2 == r1 || c2 == c1)    return 1;
        else   return 2;
    }

    public int CheckBishop(){
        if(r1 == r2 && c1 == c2)   return 0;
        if(r1 != r2 && c1!= c2){
            return 1;
        }
        else{
            if((r2 == r1 && Math.abs(c1 - c2)%2==0) || (c2 == c1 && Math.abs(r2 - r1)==0))   return 2;
            else   return 0;
        }
        }

    public int CheckKing(){
        if(r2 == r1)    return Math.abs(c2 - c1);
        else{
            if(c2 == c1)   return Math.abs(r2 - r1);
            else   return Math.abs(c2 - c1);
        }
    }
    public static void main(String[] args) {
        int rr1, rr2, cc1, cc2;
        sc = new Scanner(System.in);
        rr1 = sc.nextInt();
        cc1 = sc.nextInt();
        rr2 = sc.nextInt();
        cc2 = sc.nextInt();
        a = new _370A_(rr1,cc1,rr2,cc2);
        System.out.printf("%d %d %d",a.CheckRock(), a.CheckBishop(),a.CheckKing());
    }

}

import java.util.Scanner;

public class ProblemA {

    public static int reduced(int r1, int c1, int r2, int c2){
        int min = Integer.MAX_VALUE;
        int cc=c1;
        int rr=r1;
        int move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
        //  System.out.println(move);
            move++;
            r1++;
            c1++;

        }
        c1=cc;
        r1=rr;
        move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1--;
            c1++;
        }
        c1=cc;
        r1=rr;
        move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1++;
            c1--;
        }
        c1=cc;
        r1=rr;
        move=0;
        while(true){
            if(r1<1 || c1<1 || r1>8 || c1>8)
                break;
            if(r1==r2 || c1==c2){
                min=Math.min(min, move+Math.abs(r1-r2)+Math.abs(c1-c2));
            }
            move++;
            r1--;
            c1--;
        }
        return min;

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();
        int r, b, k;
        if(r1==r2 && c1==c2){
            r=0;
        }
        else if(r1==r2 || c1==c2){
            r=1;
        }
        else{
            r=2;
        }
        if(r1==r2 && c1==c2){
            b=0;
        }
        else if(Math.abs(r1-r2)==Math.abs(c1-c2)){
            b=1;
        }
        else if(Math.abs(Math.abs(r1-r2)-Math.abs(c1-c2))==1){
            b=0;
        }
        else{
            b=2;
        }
        if(r1==r2 || c1==c2){
            k=Math.abs(r1-r2)+Math.abs(c1-c2);
        }
        else
            k=reduced(r1, c1, r2, c2);
        System.out.printf("%d %d %d", r, b, k);
    }

}

    import java.util.*;
    import java.io.*;
    public class Main {
        public static long mod= (long) (1e9 +7);
        public static void main(String args[]){
            InputReader s= new InputReader(System.in);
            OutputStream outputStream= System.out;
            PrintWriter out= new PrintWriter(outputStream);
            int r1= s.nextInt();
            int c1= s.nextInt();
            int r2= s.nextInt();
            int c2= s.nextInt();
            if(r1==r2 || c1==c2){
                out.print("1 ");
            }
            else{
                out.print("2 ");
            }
            if(r1%2!=0 && c1%2!=0){
                if(r2%2!=0 && c2%2!= 0){
                    if(Math.abs(r1-r2)==Math.abs(c1-c2)){
                        out.print("1 ");
                    }
                    else{
                        out.print("2 ");
                    }
                }
                else{
                    out.print("0 ");
                }
            }
            else{
                if(r2%2!=0 && c2%2!=0){
                    out.print("0 ");
                }
                else{
                    if(Math.abs(r1-r2)==Math.abs(c1-c2)){
                        out.print("1 ");
                    }
                    else{
                        out.print("2 ");
                    }
                }
            }
            out.println(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
            out.close();
        }
        static class InputReader {

            public BufferedReader reader;
            public StringTokenizer tokenizer;

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

            public 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;
            }
            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 long nextLong() {
                  return Long.parseLong(next());
                }
            public int nextInt() {
              return Integer.parseInt(next());
            }
          }
        public static int gcd(int number1, int number2) {
            if(number2 == 0){
                return number1;
            }
            return gcd(number2, number1%number2);
        }
        public static int combinations(int n,int r){
            if(n==r) return 1;
            if(r==1) return n;
            if(r==0) return 1;
            return combinations(n-1,r)+ combinations(n-1,r-1);
        }

        public static int expo(int a, int b){
            if (b==1)
                return a;
            if (b==2)
                return a*a;

            if (b%2==0){
                    return expo(expo(a,b/2),2);
            }
            else{
                return a*expo(expo(a,(b-1)/2),2);
            }
        }

        public static void sieve(int N){
            int arr[]= new int[N+1];
            for(int i=2;i<Math.sqrt(N);i++){
                if(arr[i]==0){
                    for(int j= i*i;j<= N;j= j+i){
                        arr[j]=1;
                    }
                }
            }
            // All the i for which arr[i]==0 are prime numbers.
        }
    }

import java.util.Scanner;

public class rbk {

	public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();
		int rk = 0;
		int bi = 0;
		int k = 0;
		// for rook
		if (r1 == r2 || c1 == c2) {
			rk = 1;
		} else {
			rk = 2;
		}

		// for bishop
		if ((r1 == r2 && Math.abs(c1 - c2) != 2) || c1 == c2) {
			bi = 0;
		} else {
			if (Math.abs(r1 - r2) == Math.abs(c1 - c2)) {
				bi = 1;
			} else if (r1 == r2) {
				bi = Math.abs(c1 - c2);
			} else {
				bi = 2;
//				int x = r1;
//				int y = c1;
//				int z = r2;
//				int w = c2;
//				if (r1 > r2) {
//					x = x - 3;
//					y = y + 3;
//				} else {
//					x += 3;
//					y -= 3;
//				}
//				if (Math.abs(x - r2) == Math.abs(y - c2)) {
//					bi = 2;
//				} else {
//					bi = 0;
//				}
//
			}
		}

		// for king

		if (r1 == r2) {
			k = Math.abs(c1 - c2);
		} else if (c1 == c2) {
			k = Math.abs(r1 - r2);
		} else {
			k=Math.max(Math.abs(c1 - c2),  Math.abs(r1 - r2));
		}

		System.out.println(rk + " " + bi + " " + k);
	}
}

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

public class rook {
	public static void main(String[] args) throws IOException {
		BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer(bf.readLine());
		int r1=Integer.parseInt(st.nextToken());
		int c1=Integer.parseInt(st.nextToken());
		int r2=Integer.parseInt(st.nextToken());
		int c2=Integer.parseInt(st.nextToken());
		int Rook=0,bishop=0,king=0;
		//are they on the same coloumn
		if(c1==c2){
			Rook=1;
			bishop=0;
			king=Math.abs(r1-r2);
		}
		else if(r1==r2){//on same raw
			Rook=1;
			bishop=0;
			king=Math.abs(c1-c2);
		}
		else if((Math.abs(r1-r2))==(Math.abs(c1-c2))){//on the samediagonal
			Rook=2;
			bishop=1;
			king=Math.abs(r1-r2);
		}
		else{
			Rook=2;bishop=0;
			king=Math.abs(r2-r1)+Math.abs(c1-c2);
		}
		System.out.println(Rook+" "+bishop+" "+king);

	}
}

import java.util.*;

/**
 * _370A
 */
public class _370A {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x1 = sc.nextInt();
        int y1 = sc.nextInt();
        int x2 = sc.nextInt();
        int y2 = sc.nextInt();
        rook(x1, y1, x2, y2);
        bishop(x1, y1, x2, y2);
        king(x1, y1, x2, y2);

    }

    public static void rook(int x1,int y1,int x2,int y2) {
        if(x1==x2||y1==y2){
            System.out.print(1+" ");
        }
        else{
            System.out.print(2+" ");
        }
    }
    public static void bishop(int x1,int y1,int x2,int y2) {
        double slope=0;
        try{
         slope=(Math.abs((x1-x2)/(y1-y2)));
        }
        catch(ArithmeticException e){
            slope=0;
        }
        if(slope==1){
            System.out.print(1+" ");
        }
        else{
            System.out.print(0+" ");
        }
    }
    public static void king(int x1,int y1,int x2,int y2) {
        System.out.print(Math.max(Math.abs(x1-x2),Math.abs(y1-y2))+" ");
    }
}

import java.util.Scanner;

/**
 *
 * @author mohanad elmaghrby
 */
public class Div2_370A {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int r1 , r2 , c1 , c2;
        r1=scan.nextInt();
        c1=scan.nextInt();
        r2=scan.nextInt();
        c2=scan.nextInt();
        int arr[] = new int [3];
        boolean canReach = (r1+c1)%2 == (r2+c2)%2;
        if (r1==r2 || c1==c2){
            /**rook**/
            arr[0]=1;
            /**king*/
            arr[2]=Math.abs((r1-r2+c1-c2));
            if(canReach)
                arr[1]=arr[2];
            else
                arr[1]=0;
        }
        else {
            boolean isDiagonal = (r1+c1)==(r2+c2) || (Math.abs((r1-c1))== (Math.abs((r2-c2))));
            arr[0]=2;
            if (Math.abs(r1-r2)>Math.abs(c2-c1))
                    arr[2]=Math.abs(r1-r2);
                else
                    arr[2]=Math.abs(c1-c2);

            if (isDiagonal){
                arr[1]=1;
                if (Math.abs(r1-r2)>Math.abs(c2-c1))
                    arr[2]=Math.abs(r1-r2);
                else
                    arr[2]=Math.abs(c1-c2);
            }
            else {
                if(!canReach)
                    arr[1]=0;
                else
                    arr[1]= 2;

            }

        }
        System.out.println(arr[0] +" "+arr[1] + " " + arr[2]);
    }

}

import java.util.Scanner;

public class ProblemA {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();
        int r, b, k;
        if(r1==r2 && c1==c2){
            r=0;
        }
        else if(r1==r2 || c1==c2){
            r=1;
        }
        else{
            r=2;
        }
        if(r1==r2 && c1==c2){
            b=0;
        }
        else if(Math.abs(r1-r2)==Math.abs(c1-c2)){
            b=1;
        }
        else if(Math.abs(Math.abs(r1-r2)-Math.abs(c1-c2))==1){
            b=0;
        }
        else{
            b=2;
        }
        if(r1==r2 && c1==c2){
            k=0;
        }
        else if(r1==r2 || c1==c2){
            k=Math.abs(r1-r2)+Math.abs(c1-c2);
        }
        k=Math.min(Math.abs(r1-r2), Math.abs(c1-c2))+Math.abs((r1-r2)+(c1-c2));
        System.out.printf("%d %d %d", r, b, k);
    }

}

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

/**
 *
 * @author Altynbek.Nurgaziyev
 */
public class R217_D2_A {

        public void solution() throws Exception {
                int r1 = in.nextInt();
                int c1 = in.nextInt();
                int r2 = in.nextInt();
                int c2 = in.nextInt();
                int dr = Math.abs(r1 - r2);
                int dc = Math.abs(c1 - c2);
                if (dr == 0 || dc == 0) {
                        out.print(1 + " ");
                } else {
                        out.print(2 + " ");
                }
                if ((r1 + c1) % 2 == (r1 + c2) % 2) {
                        if (dr == dc) {
                                out.print(1 + " ");
                        } else {
                                out.print(2 + " ");
                        }
                } else {
                        out.print(0 + " ");
                }
                out.println(Math.max(dr, dc));
        }

        Scanner in;
        PrintWriter out;
        String input, output;

        public void run() throws Exception {
                if (input != null) {
                        in = new Scanner(new FileReader(input));
                } else {
                        in = new Scanner(System.in);
                }

                if (output != null) {
                        out = new PrintWriter(new File(output));
                } else {
                        out = new PrintWriter(System.out);
                }

                solution();

                out.close();
        }

        public static void main(String[] args) throws Exception {
                new R217_D2_A().run();
        }

        public class Scanner {

                private BufferedReader br;
                private StringTokenizer st;

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

                public Scanner(FileReader fr) {
                        br = new BufferedReader(fr);
                }

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

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

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

                public Double nextDouble() throws Exception {
                        return Double.parseDouble(next());
                }
        }
}

import java.util.*;
public class code{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int x1=sc.nextInt(); int y1= sc.nextInt();
		int x2= sc.nextInt();
		int y2= sc.nextInt();
		int ans1 = rook(x1,y1,x2,y2);
		int ans2 = bishob(x1,x2,y1,y2);
		int ans3 = king(x1,y1,x2,y2);
		System.out.println(ans1+" "+ans2+" "+ans3);

}

public static int rook(int x1,int y1, int x2,int y2){

	if(x1==x2 && y1==y2) return 0 ;
	if(x1==x2 || y1==y2) return 1;
	return 2 ;

}
public static int bishob(int x1,int y1, int x2,int y2){

	if(y2-y1==x2-x1) return 1;
	if(y2-y1==x1-x2)return 1;
	if(x1==x2 && y1==y2) return 0 ;
	if((x1+y1)%2==1 && (x2+y2)%2==0) return 0;
	if((x1+y1)%2==0 && (x2+y2)%2==1) return 0;
	if((y2-y1)/(x2-x1)==1 ||(y2-y1)/(x2-x1)==-1) return 1;
	return 2 ;

}

public static int king(int x1,int y1, int x2,int y2){
	return Math.max(Math.abs(y2-y1), Math.abs(x2-x1));

}

}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		Scanner sc=new Scanner(System.in);
		int r1=sc.nextInt();
		int c1=sc.nextInt();
		int r2=sc.nextInt();
		int c2=sc.nextInt();
		int moves1=0;
		int moves2=0;
		int moves3=0;

	 if(r1==r2 || c1==c2)
	 moves1=1;
	 else
	 moves1=2;

	 if((r1%r2==0) &&(c1%c2==0)||(r2%r1==0) &&(c2%c1==0)||(r1%r2==0) &&(c2%c1==0)||(r2%r1==0) &&(c1%c2==0))
	 moves2=1;
	 else
	 moves2=0;

	 moves3=Math.max(Math.abs(r1-r2),Math.abs(c1-c2));

	 System.out.println(moves1+" "+moves2+" "+moves3);

	}
}

import java.util.*;
public class _370A_ {

    /**
     * @param args
     */
    private int r1;
    private int c1;
    private int r2;
    private int c2;
    private static _370A_ a;
    private static Scanner sc;

    public _370A_(int r1, int c1, int r2, int c2){
        this.r1 = r1;
        this.r2 = r2;
        this.c1 = c1;
        this.c2 = c2;
    }
    public int CheckRock(){
        if(r2 == r1 || c2 == c1)    return 1;
        else   return 2;
    }

    public int CheckBishop(){
        if(r1 == r2 && c1 == c2)   return 0;
        if(r1 != r1 && c1!= c2) return 1;
        else{
            if((r2 == r1 && Math.abs(c1 - c2)%2==0) || (c2 == c1 && Math.abs(r2 - r1)==0))   return 2;
            else   return 0;
        }
    //  if()   return 0;
        //else   return 2;
        }

    public int CheckKing(){
        if(r2 == r1)    return Math.abs(c2 - c1);
        else{
            if(c2 == c1)   return Math.abs(r2 - r1);
            else   return Math.abs(c2 - c1);
        }
    }
    public static void main(String[] args) {
        int rr1, rr2, cc1, cc2;
        sc = new Scanner(System.in);
        rr1 = sc.nextInt();
        cc1 = sc.nextInt();
        rr2 = sc.nextInt();
        cc2 = sc.nextInt();
        a = new _370A_(rr1,cc1,rr2,cc2);
        System.out.printf("%d %d %d",a.CheckRock(), a.CheckBishop(),a.CheckKing());
    }

}

import java.io.*;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Collections;
import java.lang.Math;
import java.util.ArrayList;
import java.util.*;
import java.math.*;

public class rook{

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();

		int rook = 0;
		int bishop = 0;
		int king = 0;

		int flag1 = 0;
		int flag2 = 0;

		if(r1 == r2 || c1 == c2){
			rook = 1;
		}
		else{
			rook = 2;
		}

		king = Math.max(Math.abs(r1 - r2),Math.abs(c1 - c2));

		if(Math.abs(r1 - r2) == Math.abs(c1 - c2)){
			bishop = 1;
		}

		else{
			if(r1 % 2 == 1 && c1 % 2 == 1){
				flag1 = 1;
			}

			else if(r1 % 2 == 0 && c1 % 2 == 0){
				flag1 = 1;
			}

			if(r2 % 2 == 1 && c2 % 2 == 1){
				flag1 = 1;
			}

			else if(r2 % 2 == 0 && c2 % 2 == 0){
				flag1 = 1;
			}

			if(flag1 == flag2){
				bishop = 2;
			}
		}

		System.out.println(rook + " " + bishop + " " + king);

	}
}

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

public class Task370A {

	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 s = new Scanner(is);

			int r1 = s.nextInt();
			int c1 = s.nextInt();
			int r2 = s.nextInt();
			int c2 = s.nextInt();

			pw.print(Math.abs(r1 - r2) + Math.abs(c1 - c2));
			pw.print(" ");
			if ((r1 - c1 + r2 - c2) % 2 != 0) {
				pw.print(0);
			} else {
				int rDiff = Math.abs(r1 - r2);
				int cDiff = Math.abs(c1 - c2);
				pw.print(Math.max(rDiff, cDiff) + Math.abs(rDiff - cDiff));
			}
			pw.print(" ");
			pw.println(Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2)));

			pw.flush();
			s.close();
		}
	}

}

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

public class Main implements Runnable {

	private int r1;
	private int c1;
	private int r2;
	private int c2;

	private void solve() throws IOException {
		r1 = nextInt();
		c1 = nextInt();
		r2 = nextInt();
		c2 = nextInt();

		out.println(rook() + " " + bishop() + " " + king());
	}

	private int king() {
		if (Math.abs(r1 - r2) > Math.abs(c2 - c1)) {
			return Math.abs(r2 - r1);
		} else {
			return Math.abs(c2 - c1);
		}
	}

	private int bishop() {
		if (r1 == r2 && c1 == c2) {
			return 0;
		} else if (Math.abs(r2 - r1) == Math.abs(c2 - c1)) {
			return 1;
		} else if (Math.abs(r2 - r1) % 2 == 0 && Math.abs(c2 - c1) % 2 == 0) {
			return 2;
		} else
			return 0;
	}

	private int rook() {
		if (r1 == r2 && c1 == c2) {
			return 0;
		} else if (r1 == r2) {
			return 1;
		} else if (c1 == c2) {
			return 1;
		} else {
			return 2;
		}
	}

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

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

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

	String next() throws IOException {
		while (!st.hasMoreTokens()) {
			String line = in.readLine();
			if (line == null)
				return null;
			eat(line);
		}
		return st.nextToken();
	}

	public static void main(String[] args) {
		new Thread(null, new Main(), "Main", 1 << 28).start();
	}

	private BufferedReader in;
	private PrintWriter out;
	private StringTokenizer st;
	private String FNAME = "name";

	@Override
	public void run() {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(new OutputStreamWriter(System.out));
			// in = new BufferedReader(new FileReader(FNAME + ".in"));
			// out = new PrintWriter(new FileWriter(FNAME + ".out"));
			eat("");
			solve();
			in.close();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
			System.exit(566);
		}
	}

	private void eat(String s) {
		st = new StringTokenizer(s);
	}

}

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

public class RookBishopAndKing {

    public static void main(String [] args) throws IOException
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        StringTokenizer st = new StringTokenizer(br.readLine());

        int r1 = Integer.parseInt(st.nextToken());
        int c1 = Integer.parseInt(st.nextToken());
        int r2 = Integer.parseInt(st.nextToken());
        int c2 = Integer.parseInt(st.nextToken());

        if(r1 == r2 && c1 == c2) bw.write("0 0 0");
        else
        {
            if(r1 == r2 || c1 == c2) bw.write("1 ");
            else bw.write("2 ");

            int r = Math.abs(r2-r1);
            int c = Math.abs(c2-c1);

            if( r % 2 != 0 || c % 2 != 0)
                bw.write("0 ");
            else
                if(r == c)
                    bw.write("1 ");
                else
                    bw.write("2 ");

            bw.write(Integer.toString(Math.max(r, c)));

        }

        bw.flush();
    }
}

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 RookBishopandKing {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int r1=scan.nextInt();
        int c1=scan.nextInt();
        int r2=scan.nextInt();
        int c2=scan.nextInt();
        int r=0,b=0,k=0;
        if(r1==r2||c1==c2)
            r=1;
        else
            r=2;
        if(Math.abs(r1-r2)==Math.abs(c1-c2))
            b=1;
        else
            b=0;
        if(b==1)
        {
            k=(int) Math.min(Math.abs(r1-r2),Math.abs(r1-r2));
        }
        else
        {
            k=Math.abs(r1-r2)+Math.abs(c1-c2);
        }
        System.out.println(r+" "+b+" "+k);
    }
}

import java.util.Scanner;

public class Chess {
    public static void main(String[] args){
        Scanner s=new Scanner(System.in);
        int r1=s.nextInt();
        int c1=s.nextInt();
        int r2=s.nextInt();
        int c2=s.nextInt();
        int r=Math.abs(r2-r1);int c=Math.abs(c2-c1);
        if(r==0||c==0){
            System.out.print("1"+" ");
            System.out.print("0"+" ");
            if (r == 0) {
                System.out.print(c+" ");
            }
           else if(c==0){
               System.out.print(r+" ");
            }
        }
        else {
            System.out.print("2"+" ");
            if(r==c){
                System.out.print("1"+" ");
                System.out.print(r+" ");
            }
            else {
                int o=Math.min(c,r);
                System.out.print("0"+" ");
                System.out.print((o+1));
            }

        }
    }
}

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) {
        int r1 = in.nextInt();
        int c1 = in.nextInt();
        int r2 = in.nextInt();
        int c2 = in.nextInt();
        if(r1 == r2 || c1 == c2 ){
            out.print("1 ");
        }
        else {
            out.print("2 ");
        }
        if(Math.abs(r1 - r2) == Math.abs(c1 - c2)){
            out.print("1 ");
        }
        else out.print("0 ");

        out.println(Math.max(Math.abs(r1-r2),Math.abs(c1-c2)));
    }
}

class InputReader {
    private BufferedReader br;
    private StringTokenizer st;
    public InputReader(InputStream in) {
        br=new BufferedReader(new InputStreamReader(in));
        try {
            st=new StringTokenizer(br.readLine());
        } catch (IOException ignored) {

        }
    }

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

}

import java.util.*;
public class chessBoard {

	public static void main(String[] args) {
		Scanner scn = new Scanner(System.in);
		int xs=scn.nextInt();
		int ys=scn.nextInt();
		int xd=scn.nextInt();
		int yd=scn.nextInt();

		if(xd==xs || yd==ys)
			System.out.println("1");
		else
			System.out.println("2");

		if(((xs+ys)%2==0 && (xd+yd)%2==0)||((xs+ys)%2!=0 && (xd+yd)%2!=0))
		{
			if(xs+ys==xd+yd)
				System.out.println("1");
			else {
				if((xs>=ys && xd>=yd)||(xs<=ys && xd<=yd))
					System.out.println("1");
				else
					System.out.println("2");
			}
		}
		else {
			System.out.println("0");
		}

	{
		int count=Math.min(Math.abs(xs-xd),Math.abs(ys-yd));
		if(Math.abs(xs-xd)<Math.abs(ys-yd)) {
			if(xs<=xd && ys<yd)
				ys=ys+count;
			else if(xs>=xd && ys>yd)
				ys=ys-count;
			else if(xs<=xd && ys>yd)
				ys=ys-count;
			else if(xs>=xd && ys<yd)
				ys=ys+count;
			System.out.println(count+Math.abs(ys-yd));
		}
		else
		{
			if(xs<xd && ys<=yd)
				xs=xs+count;
			else if(xs>xd && ys>=yd)
				xs=xs-count;
			else if(xs<xd && ys>=yd)
				xs=xs-count;
			else if(xs>xd && ys<=yd)
				xs=xs+count;
			System.out.println(count+Math.abs(xs-xd));
		}
	}
	}

}

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

public class T370A {

	public void solve(int r1, int c1, int r2, int c2) {
		int ans1 = 0, ans2 = 0, ans3 = 0;

		if (r1 - r2 != 0) ans1 ++;
		if (c1 - c2 != 0) ans1 ++;

		if (Math.abs(r1 - r2) == Math.abs(c1 - c2))
			ans2 = 1;
		else if (r1 == r2 && Math.abs(c1 - c2) % 2 == 0 || c1 == c2 && Math.abs(r1 - r2) % 2 == 0)
			ans2 = 2;

		ans3 = Math.max(Math.abs(r1 - r2), Math.abs(c1 - c2));

		System.out.println(ans1 + " " + ans2 + " " + ans3);
	}
	public static void main(String[] args) {
		FastScanner in = new FastScanner();
		new T370A().solve(in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt());

	}
	static class FastScanner {

		BufferedReader br;
		StringTokenizer st;

		public FastScanner(String s) {
			try {
				br = new BufferedReader(new FileReader(s));
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

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

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

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

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

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

	}
}

/**
 * Created by Omar on 12/20/2015.
 */
import java.util.*;
import java.io.*;
public class RookBishopandKing {
public static void main(String[] args)throws Exception{

    BufferedReader br= new BufferedReader (new InputStreamReader(System.in));
    String[] parts=br.readLine().split(" ");
    int r1=Integer.parseInt(parts[0]);
    int c1=Integer.parseInt(parts[1]);
    int r2=Integer.parseInt(parts[2]);
    int c2=Integer.parseInt(parts[3]);

    int king=0;
    int x=r1,y=c1;
    while(x!=r2 || y!=c2){
        if(x>r2 && y>c2){
            x--;
            y--;
            king++;
            continue;
        }
        if(x<r2 && y<c2){
            x++;
            y++;
            king++;
            continue;
        }
        if(x>r2 && y<c2){
            x--;
            y++;
            king++;
            continue;
        }
        if(x<r2 && y>c2){
            x++;
            y--;
            king++;
            continue;
        }
        if(x>r2){
            x--;
            king++;
        }
     else   if(x<r2){
            x++;
            king++;
        }
        if(y>c2){
            y--;
            king++;
        }
        else if(y<c2){
            y++;
            king++;
        }
    }
    x=r1;
    y=c1;
    int rook=0;
    while(x!=r2 || y!=c2){
        if(x!=r2){
            x=r2; rook++;
        }
        if(y!=c2){
            y=c2; rook++;
        }
    }
    x=r1;
    y=c1;
    int bishop=0;
    boolean even=false;
    if(x%2==0 || y%2==0){
        even=true;
    }
    if(((r2%2!=0 || c2%2!=0) && even) || ((r2%2==0 || c2%2==0) && !even)){
        bishop=0;
    }
    else{
        while(x!=r2 || y!=c2){
            if(x>r2 && y>c2){
               while(x>r2 && y>c2){
                      x--;
                      y--;}
                bishop++;
                continue;
            }

            //
            if(x<r2 && y<c2){
                while(x<r2 && y<c2){ x++;
                y++;}
                bishop++;
                continue;
            }
            if(x>r2 && y<c2){
                while(x>r2 && y<c2){
                x--;
                y++;}

                bishop++;
                continue;
            }
            if(x<r2 && y>c2){
                while(x<r2 && y>c2){
                x++;
                y--;}
                bishop++;
                continue;
            }
            //
        }
    }
System.out.println(rook+" "+bishop+" "+king);
    br.close();}
}

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

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

/* Name of the class has to be "Main" only if the class is public. */
public class Solution
{	static int x1 =0;
	static int y1 = 0;
	static int x2 =0;
	static int y2 = 0;
	public static void main (String[] args) throws java.lang.Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		x1 = Integer.parseInt(st.nextToken());
		y1 = Integer.parseInt(st.nextToken());
		x2 = Integer.parseInt(st.nextToken());
		y2 = Integer.parseInt(st.nextToken());
		int r=0;
		int b=0;
		int k=0;
		if (x1==x2||y1==y2){
			r=1;

		}else{
			r=2;
		}
		if (x1==x2){
			if (Math.abs(y2-y1)%2==0){
				b=2;
			}
		}
		else if (y1==y2){
			if (Math.abs(x2-x1)%2==0){
				b=2;
			}
		}
		else if (Math.abs(x2-x1)==Math.abs(y2-y1)){
			b=1;
		}
		else if ((x1%2==0&&y1%2==0)||(x1%2!=0&&y1%2!=0)){
				if ((x1%2==0&&y1%2==0)||(x1%2!=0&&y1%2!=0)){
					b=2;
				}
				else {
					b=0;
				}
		}
		else if ((x1%2!=0&&y1%2==0)||(x1%2==0&&y1%2!=0)){
				if ((x1%2!=0&&y1%2==0)||(x1%2==0&&y1%2!=0)){
					b=2;
				}
				else {
					b=0;
				}
		}

		if (x1==x2){

				k=Math.abs(y2-y1);

		}
		else if (y1==y2){
				k = Math.abs(x2-x1);

		}
		else if (Math.abs(x2-x1)==Math.abs(y2-y1)){
			k=Math.abs(x2-x1);
		} else {
			int tempx = Math.abs(x2-x1);
			int tempy = Math.abs(y2-y1);
			if(tempx<tempy){
				k=tempy;
			}
			else{
				k=tempx;
			}
		}
		System.out.println(r+" "+b+" "+k);
	}
}

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

public class RookBishopKing
{

	public static void main(String args[])
	{

		FastReader sc= new FastReader();
		PrintWriter out = new PrintWriter(System.out);

		int r1,c1,r2,c2,i;
		String s;

		r1=sc.nextInt();
		c1=sc.nextInt();
		r2=sc.nextInt();
		c2=sc.nextInt();

		if(r1==r2 || c1==c2)
			out.print(1+" ");
		else
			out.print(2+" ");
		if(((r1+c1)%2==0 && (r2+c2)%2==0) || ((r1+c1)%2!=0 && (r2+c2)%2!=0))
			out.print(1+" ");
		else
			out.print(0+" ");

//		int temp1=Math.abs(r1-r2)+Math.abs(c1-c2);
//		int temp2=Math.abs(Math.min(Math.abs(r1-r2),Math.abs(c1-c2)));

		if(r1==r2 || c1==c2)
		out.println(Math.abs(r1-r2)+Math.abs(c1-c2));
		else
			out.println((Math.min(Math.abs(r1-r2),Math.abs(c1-c2))));

		out.close();
	}

	/*
		FASTREADER
	*/
	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;
        }

		/*DEFINED BY ME
		*/
		int[] readArray(int n){

			int arr[]=new int[n];

			for(int i=0;i<n;i++)
				arr[i]=nextInt();

			return arr;
		}
    }
}

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

/**
 *
SXXXXX
XFXXXX
XXFFEX
XXXXXX
(1,1)->(3,5) = 5
(1,1)->(3,2)

 12345678
1#####E##
2####*#E#
3###*###E
4##S###E#
5#CX#XC##
6##CXC###
7###C####
8########

(4,3)-(1,6)

(1,3)-(3,5)
(1,2)-(2,1)
 *
 *
 * */
public class A_Div2_217 {
    public static void main(String[]arg) throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int r1,c1,r2,c2;
        StringTokenizer st = new StringTokenizer(in.readLine());
        r1 = Integer.parseInt(st.nextToken());
        c1 = Integer.parseInt(st.nextToken());
        r2 = Integer.parseInt(st.nextToken());
        c2 = Integer.parseInt(st.nextToken());
        int rook = 0,bishop = 0,king = 0;
        if(c1 == c2 || r1 == r2)
            rook = 1;
        else
            rook = 2;
        if(Math.abs(c1-c2) == Math.abs(r1-r2))
            bishop = 1;
        else if(Math.abs(c1-c2) > 1 || Math.abs(r1-r2) > 1)
            bishop = 2;
        else
            bishop = 0;
        king = Math.max(Math.abs(r1-r2), Math.abs(c1-c2));
        System.out.println(rook+" "+bishop+" "+king);
    }
}

import java.util.Scanner;

public class A
{
	static Scanner sc=new Scanner(System.in);
	static int r1,c1,r2,c2;

	static int abs(int a)
	{
		if(a<0)
			return -a;
		return a;
	}

	public static void main(String[] args)
	{
		r1=sc.nextInt();
		c1=sc.nextInt();
		r2=sc.nextInt();
		c2=sc.nextInt();

		if(r1==r2 || c1==c2)
			System.out.print(1 + " ");
		else
			System.out.print(2 + " ");

		if((r1+c1)%2!=(r2+c2)%2)
			System.out.print(0 + " ");
		else
		{
			if((r1+c1)==(r2+c2))
				System.out.print(1 + " ");
			else if(abs(r1-c1)==abs(r2-c2))
				System.out.print(1 + " ");
			else
				System.out.print(2 + " ");
		}

		System.out.println(Integer.max(abs(r2-r1) , abs(c1-c2)));

	}
}

import java.util.Scanner;
public class Main {
    public static int abs(int a){
        return a>0?a:-a;
    }
    public static void main(String args[]){
        Scanner s=new Scanner(System.in);
        int r1,c1,r2,c2;
        r1=s.nextInt();
        c1=s.nextInt();
        r2=s.nextInt();
        c2=s.nextInt();
        int rook,bishop,king;
        if(r1==r2 && c1==c2){
            System.out.println("0 0 0");
        }
        else{
            if(r1==r2 || c1==c2){
                rook=1;
            }
            else{rook=2;}

            if((r1+c1)%2!=(r2+c2)%2){
                bishop=0;
            }
            else if((r1-r2)!=0){
                int slope=(c1-c2)/(r1-r2);
                if(slope==-1|| slope==1){
                    bishop=1;
                }
                else{bishop=2;}
            }
            else{bishop=2;}

            king=Math.max(abs(r1-r2),abs(c1-c2));
            System.out.println(rook+" "+bishop+" "+king);
        }

    }
}

import java.util.Scanner;

public class A
{
	static Scanner sc=new Scanner(System.in);
	static int r1,c1,r2,c2;

	static int abs(int a)
	{
		if(a<0)
			return -a;
		return a;
	}

	public static void main(String[] args)
	{
		r1=sc.nextInt();
		c1=sc.nextInt();
		r2=sc.nextInt();
		c2=sc.nextInt();

		if(c1==c2 || r1==r2)
			System.out.print(1 + " ");
		else
			System.out.print(2 + " ");

		if((r1+c1)%2!=(r2+c2)%2)
			System.out.print(0 + " ");

		else
		{
			if((r1+c1)==(r2+c2) || abs(r1-c1)==abs(r2-c2))
				System.out.print(1 + " ");
			else
				System.out.print(2 + " ");
		}

		System.out.println(Integer.max(abs(r2-r1) , abs(c2-c1)));
	}
}

import java.util.Scanner;
import java.lang.Math;

public class _370A{

    public static void main(String[] args){

        Scanner s = new Scanner(System.in);
        int x1 = s.nextInt();
        int y1 = s.nextInt();
        int x2 = s.nextInt();
        int y2 = s.nextInt();

        int rook = 0;
        if(x1 != x2){
            rook++;
        }
        if(y1 != y2){
            rook++;
        }

        int bishop = 0;
        if(Math.abs(x1-x2) == Math.abs(y1-y2)){
            bishop = 1;
        }

        int king = 0;
        if(Math.abs(x1-x2) != Math.abs(y1-y2)){
            king = Math.abs(x1-x2) + Math.abs(y1-y2);
        }
        else{
            king = Math.abs(x1-x2);
        }

        System.out.println(rook + " " + bishop + " " + king);

    }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int r1 = sc.nextInt();
		int c1 = sc.nextInt();
		int r2 = sc.nextInt();
		int c2 = sc.nextInt();
		if (r1==r2 && r2 ==c2) {
			System.out.println("0 0 0");
		}else{
			if(r1==r2 || r2==c2) {
				System.out.print("1 ");
			}else{
				System.out.print("2 ");
			}
			if((r1+c1)%2 != (r2+c2)%2) {
				System.out.print("0 ");
			}else if(r2-r1 == c2-c1 || r2-r1 == c1-c2) {
				System.out.print("1 ");
			}else{
				System.out.print("2 ");
			}
			System.out.println(Math.max(Math.abs(r2-r1),Math.abs(c2-c1)));
		}
	}

}

import java.util.*;

public class jj {
	static Scanner in = new Scanner(System.in);

	public static void main(String[] args) {
		int x1=in.nextInt(),y1=in.nextInt(),x2=in.nextInt(),y2=in.nextInt();
		int rook,bishop,king;
		if(x1==x2||y1==y2)
		{
			rook=1;
		}
		else
		{
			rook=2;
		}
		if((x1+y1)%2 == (x2+y2)%2)
		{
			if(Math.abs(x1-x2)==Math.abs(y1-y2))
			{
				bishop=1;
			}
			else
			{
				bishop=2;
			}
		}
		else
		{
			bishop=0;
		}
		if(x1==x2)
		{
			king =Math.abs(y1-y2);
		}
		else if(y1==y2)
		{
			king =Math.abs(x1-x2);
		}
		else
		{
			king =Math.min(Math.abs(x1-x2),Math.abs(y1-y2));
		}
		System.out.println(rook+" "+bishop+" "+king);

	}

}

import java.util.*;

public class  Main {

	public static void main(String args[]){

	Scanner sc = new Scanner (System.in);

    int r1 = sc.nextInt();
    int c1 = sc.nextInt();
	int r2 = sc.nextInt();
	int c2 = sc.nextInt();

	int k = r1 - r2;
	int m = c1 - c2;
	int n = k - m;
	n = n>=0 ? n : n*-1;
	k = k>=0 ? k : k*-1;
	m = m>=0 ? m : m*-1;

	int Rook = (k==0 || m==0) ? 1 : 2;
	int Bishop = (k == 0 || m == 0) ? (k==0) ? (m%2 == 0) ? 2 : 0 : (k%2 == 0) ? 2 : 0 : (k==m) ? 1 : (n%2 == 0) ? 2 : 0 ;
	int King = (k==m) ? k : k>m ? k : m;

	System.out.println(Rook+", "+Bishop+", "+King);

}
}

import java.util.Scanner;

public class King {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        int r1 = sc.nextInt();
        int c1 = sc.nextInt();
        int r2 = sc.nextInt();
        int c2 = sc.nextInt();
        int r = rook(r1, c1, r2, c2);
        int b = bishop(r1, c1, r2, c2);
        int k = king(r1, c1, r2, c2);
        System.out.println(r + " " + b + " " + k);
    }

    static int rook(int r1, int c1, int r2, int c2) {
        if (r1 == r2)
            return 1;
        if (c1 == c2)
            return 1;
        return 2;
    }

    static int bishop(int r1, int c1, int r2, int c2) {
        int diag1 = r1 - c1;
        int diag2 = r2 - c2;

        if (diag1 == diag2)
            return 1;

        if (r1 + c1 == r2 + c2) {
            return 1;
        }

        if (diag1 % 2 != diag2 % 2)
            return 0;
        return 2;
    }

    static int king(int r1, int c1, int r2, int c2) {
        int a1 = Math.abs(r2 - r1);
        int a2 = Math.abs(c2 - c1);
        return Math.max(a1, a2);
    }
}

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author mark
 */
public class RookBishopKing {

    private static int[] minMaxX;
    private static int[] minMaxY;

    public static void main(String[] args) throws FileNotFoundException {
        //FileInputStream str = new FileInputStream(new File("/home/mark/tmp/input.txt"));
        //Scanner scan = new Scanner(str);
        Scanner scan = new Scanner(System.in);
        int startY = scan.nextInt() - 1;
        int startX = scan.nextInt() - 1;
        int endY = scan.nextInt() - 1;
        int endX = scan.nextInt() - 1;

        int[] end = {endX, endY};
        int[] start = {startX, startY};

        int rook = 0;
        int bishop = 0;
        int king = 0;

        //Rook
        rook = Math.abs(startX - endX) > 0 ? 1 : 0;
        rook += Math.abs(startY - endY) > 0 ? 1 : 0;

        //Bishop
        if ((startX - endX) % 2 != 0) {
            List<int[]> availableMovesStart = new ArrayList<>();
            getBishopMoves(startX, startY, availableMovesStart);
            List<int[]> availableMovesEnd = new ArrayList<>();
            getBishopMoves(endX, endY, availableMovesEnd);
            if (contains(availableMovesStart,end)) {
                //bishop = countBishopMoves(start, end);
                bishop++;
            } else {
                int[] target = null;
                for (int[] move : availableMovesStart) {
                    if (availableMovesEnd.contains(move)) {
                        Arrays.equals(target, move);
                    }
                }
                if (target != null) {
//                    bishop = countBishopMoves(start, target)
//                            + countBishopMoves(target, end);
                    bishop += 2;
                }
            }
        }
        //King
        minMaxX = new int[2];
        minMaxY = new int[2];
        if (startX > endX) {
            minMaxX[0] = endX;
            minMaxX[1] = startX;
        } else {
            minMaxX[1] = endX;
            minMaxX[0] = startX;
        }

        if (startY > endY) {
            minMaxY[0] = endY;
            minMaxY[1] = startY;
        } else {
            minMaxY[1] = endY;
            minMaxY[0] = startY;
        }
        king = getShortestPath(start, end, new int[8][8],0);
        System.out.println(rook + " " + bishop + " " + king);
    }

    private static boolean contains(List<int[]> availableMoves, int[] dst) {
        for (int[] curr : availableMoves) {
            if (Arrays.equals(curr, dst)) {
                return true;
            }
        }
        return false;
    }

//    private static int countBishopMoves(int[] start, int end[]) {
//        return (int) Math.sqrt(Math.pow(start[0] - end[0], 2)
//                + Math.pow(start[1] - end[1], 2));
//    }

    private static void getBishopMoves(int startX, int startY, List<int[]> availableMoves) {
        int x = startX;
        int y = startY;

        while (x < 8 && y < 8) {
            int move[] = {x, y};
            availableMoves.add(move);
            x++;
            y++;
        }

        x = startX-1;
        y = startY-1;
        while (x >= 0 && y >= 0) {
            int move[] = {x, y};
            availableMoves.add(move);
            x--;
            y--;
        }

        x = startX+1;
        y = startY-1;
        while (x < 8 && y >= 0) {
            int move[] = {x, y};
            availableMoves.add(move);
            x++;
            y--;
        }

        x = startX-1;
        y = startY+1;
        while (x >= 0 && y <8 ) {
            int move[] = {x, y};
            availableMoves.add(move);
            x--;
            y++;
        }

    }

    private static int getShortestPath(int[] src, int[] dst, int[][] visited,int level) {
        visited[src[0]][src[1]] = 1;

        if (Arrays.equals(src, dst)) {
            return 0;
        }
        if (src[0] < minMaxX[0] || src[0] > minMaxX[1] || src[1]<minMaxY[0] || src[1]>minMaxY[1]) {
            return 100000;
        }
        int[] m01 = {src[0] + 1, src[1] - 1};
        int[] m03 = {src[0] - 1, src[1] - 1};
        int[] m02 = {src[0] + 1, src[1] + 1};
        int[] m04 = {src[0] - 1, src[1] + 1};
        int[] m05 = {src[0] + 1, src[1]};
        int[] m06 = {src[0], src[1] + 1};
        int[] m07 = {src[0] - 1, src[1]};
        int[] m08 = {src[0], src[1] - 1};

        int t01 = 100000;
        if (isValid(m01) && visited[m01[0]][m01[1]] == 0) {
            t01 = getShortestPath(m01, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t01,m01,level);
        }
        int t02 = 100000;
        if (isValid(m02) && visited[m02[0]][m02[1]] == 0) {
            t02 = getShortestPath(m02, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t02,m02,level);
        }
        int t03 = 100000;
        if (isValid(m03) && visited[m03[0]][m03[1]] == 0) {
            t03 = getShortestPath(m03, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t03,m03,level);
        }
        int t04 = 100000;
        if (isValid(m04) && visited[m04[0]][m04[1]] == 0) {
            t04 = getShortestPath(m04, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t04,m04,level);
        }
        int t05 = 100000;
        if (isValid(m05) && visited[m05[0]][m05[1]] == 0) {
            t05 = getShortestPath(m05, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t05,m05,level);
        }
        int t06 = 100000;
        if (isValid(m06) && visited[m06[0]][m06[1]] == 0) {
            t06 = getShortestPath(m06, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t06,m06,level);
        }
        int t07 = 100000;
        if (isValid(m07) && visited[m07[0]][m07[1]] == 0) {
            t07 = getShortestPath(m07, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t07,m07,level);
        }
        int t08 = 100000;
        if (isValid(m08) && visited[m08[0]][m08[1]] == 0) {
            t08 = getShortestPath(m08, dst, Arrays.copyOf(visited, visited.length),level+1);
            print(t08,m08,level);
        }
        int val = 1 + Math.min(t01, Math.min(t02, Math.min(t03,
                Math.min(t04, Math.min(t05, Math.min(t06, Math.min(t07, t08)))))));
        //System.out.println("level="+level+" val="+val);
        return val;
    }

    private static boolean isValid(int[] m08) {
        if (m08[0] >= 0 && m08[0] < 8
                && m08[1] >= 0 && m08[1] < 8) {
            return true;
        } else {
            return false;
        }
    }

    private static void print(int count, int[] pos,int level) {
       //System.out.println("level="+level+" t01="+count +" x=" + pos[0]+" y="+ pos[1]);
    }
}

import java.util.*;
public class RookBishopKing
{
public static Scanner sc;
public static void main(String[] args)
{
sc = new Scanner (System.in);
int r1 = sc.nextInt();
int c1 = sc.nextInt();
int r2 = sc.nextInt();
int c2 = sc.nextInt();
char source = 'B';
char target = 'B';
if ((r1%2==0&&c1%2==0)||(r1%2!=0&&c1%2!=0))
    source = 'W';
if ((r2%2==0&&c2%2==0)||(r2%2!=0&&c2%2!=0))
    target = 'W';
int Rook = 0;
int Bishop = 0;
int King = 0;
if (r1==r2||c1==c2)
    Rook = 1;
else
    Rook = 2;
if (source!=target)
    Bishop = 0;
else
{
    if (Math.abs(r1-r2)==Math.abs(c1-c2))
        Bishop = 1;
    else
        Bishop = 2;
}

if (r1==r2||c1==c2)
    King += Math.abs(r1-r2)+Math.abs(c1-c2);
else
{
int min = 0;
if (Math.abs(r1-r2)<Math.abs(c1-c2))
{
    min = Math.abs(r1-r2);
    if (c1>c2)
    c1 -=min-1;
    else
    c1 += min-1;
    King += min+Math.abs(r1-r2);
}
else
{
    if (Math.abs(r1-r2)==Math.abs(c1-c2))
            {
        King = Math.abs(r1-r2);
            }
    else
    {
    min = Math.abs(c1-c2);
    if (r1>r2)
        r1 -=min-1;
        else
        r1 += min-1;
    King += min+Math.abs(r1-r2);
    }
}

}

System.out.println(Rook+" "+Bishop+" "+King);
}
}

/**
 * Created by Omar on 12/20/2015.
 */
import java.util.*;
import java.io.*;
public class RookBishopandKing {
public static void main(String[] args)throws Exception{

    BufferedReader br= new BufferedReader (new InputStreamReader(System.in));
    String[] parts=br.readLine().split(" ");
    int r1=Integer.parseInt(parts[0]);
    int c1=Integer.parseInt(parts[1]);
    int r2=Integer.parseInt(parts[2]);
    int c2=Integer.parseInt(parts[3]);

    int king=0;
    int x=r1,y=c1;
    while(x!=r2 || y!=c2){
        if(x>r2 && y>c2){
            x--;
            y--;
            king++;
            continue;
        }
        if(x<r2 && y<c2){
            x++;
            y++;
            king++;
            continue;
        }
        if(x>r2 && y<c2){
            x--;
            y++;
            king++;
            continue;
        }
        if(x<r2 && y>c2){
            x++;
            y--;
            king++;
            continue;
        }
        if(x>r2){
            x--;
            king++;
        }
     else   if(x<r2){
            x++;
            king++;
        }
        if(y>c2){
            y--;
            king++;
        }
        else if(y<c2){
            y++;
            king++;
        }
    }
    x=r1;
    y=c1;
    int rook=0;
    while(x!=r2 || y!=c2){
        if(x!=r2){
            x=r2; rook++;
        }
        if(y!=c2){
            y=c2; rook++;
        }
    }
    x=r1;
    y=c1;
    int bishop=0;
    boolean w=false;

    if((x%2!=0 && y%2==0) || x==y){
        w=true;
    }
    if(x==r2 && y==c2){
        bishop=1;
    }
    else if(x==r2 || y==c2){
        bishop=2;
    }

    else{
    int infinite_loop=0;
        while(x!=r2 || y!=c2){
            infinite_loop++;
            if(infinite_loop==5000){
                bishop=0;
                break;
            }
            if(x>r2 && y>c2){
               while(x>r2 && y>c2){
                      x--;
                      y--;}
                bishop++;
                continue;
            }

            //
            if(x<r2 && y<c2){
                while(x<r2 && y<c2){ x++;
                y++;}
                bishop++;
                continue;
            }
            if(x>r2 && y<c2){
                while(x>r2 && y<c2){
                x--;
                y++;}

                bishop++;
                continue;
            }
            if(x<r2 && y>c2){
                while(x<r2 && y>c2){
                x++;
                y--;}
                bishop++;
                continue;
            }
            //
        }
    }
System.out.println(rook+" "+bishop+" "+king);
    br.close();}
}