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. 
Petya is thinking about the following problem: what minimum number of moves is needed for each of these pieces to move from field (*r*<sub class="lower-index">1</sub>, *c*<sub class="lower-index">1</sub>) to field (*r*<sub class="lower-index">2</sub>, *c*<sub class="lower-index">2</sub>)? 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 *r*<sub class="lower-index">1</sub>, *c*<sub class="lower-index">1</sub>, *r*<sub class="lower-index">2</sub>, *c*<sub class="lower-index">2</sub> (1 ≤ *r*<sub class="lower-index">1</sub>, *c*<sub class="lower-index">1</sub>, *r*<sub class="lower-index">2</sub>, *c*<sub class="lower-index">2</sub> ≤ 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.
# Author :  //- kibrom Hailu -\\

from sys import stdin,stdout
from collections import Counter,defaultdict , deque 
from bisect import bisect , bisect_left ,bisect_right 
from itertools import accumulate 
from heapq import heapify , heappop , heappush , heappushpop , heapreplace

def I(): return int(stdin.readline())
def II(): return map(int, stdin.readline().split())
def IL(): return list(map(int, stdin.readline().split()))
def SIL(): return sorted(map(int, stdin.readline().split()))



def solve():
    
    # write your code here 
    r1,c1,r2,c2 = II()

    # for king 
    def king():
        return max(r2-r1,c2-c1)

        
    # for rook 
    def rook():
        if r1 == r1 and c1 == c2: return 0
        if r1 == r2 or c1 == c2:
            return 1 
        return 2 

    def bishop():
        def inbound(row,col): return 1<=row<=8 and 1<=col<=8
        dirc = [(-1,-1),(1,1),(-1,1),(1,-1)]
        queue = deque([(r1,c1)])
        visited = set([(r1,c1)])
        count = 0
        while queue:
            level = len(queue)
             
            count += 1
            for _ in range(level):
                x,y = queue.pop() 
                for t in range(1,8):
                    for i,j in dirc:
                        xi = x+(i*t)
                        yj = y+(j*t)

                        if inbound(xi,yj) and (xi,yj) not in visited:
                            if (xi,yj) == (r2,c2):
                                return count 
                            queue.append((xi,yj))
                            visited.add((xi,yj))
            
        return 0





    print(rook(),bishop(), king())
                    
                        
            

    
    
    
    
    
    
    
    
    

solve()