Polycarp takes part in a quadcopter competition. According to the rules a flying robot should:  start the race from some point of a field,  go around the flag,  close cycle returning back to the starting point. Polycarp knows the coordinates of the starting point (x1, y1) and the coordinates of the point where the flag is situated (x2, y2). Polycarp’s quadcopter can fly only parallel to the sides of the field each tick changing exactly one coordinate by 1. It means that in one tick the quadcopter can fly from the point (x, y) to any of four points: (x - 1, y), (x + 1, y), (x, y - 1) or (x, y + 1).Thus the quadcopter path is a closed cycle starting and finishing in (x1, y1) and containing the point (x2, y2) strictly inside.    The picture corresponds to the first example: the starting (and finishing) point is in (1, 5) and the flag is in (5, 2). What is the minimal length of the quadcopter path?

The first line contains two integer numbers x1 and y1 ( - 100 ≤ x1, y1 ≤ 100) — coordinates of the quadcopter starting (and finishing) point. The second line contains two integer numbers x2 and y2 ( - 100 ≤ x2, y2 ≤ 100) — coordinates of the flag. It is guaranteed that the quadcopter starting point and the flag do not coincide.

Print the length of minimal path of the quadcopter to surround the flag and return back.

/*
 * DA-IICT
 * Author: Jugal Kalal
 */
import java.util.*;
import java.io.*;
import java.math.*;
import java.text.DecimalFormat;
public class Hackerrank{
	static long mod=(long)Math.pow(10,9)+7;
	public static void main(String args[]){
        new Thread(null, new Runnable(){
            public void run() {
                try{
                    solve();
                    w.close();
                }
                catch(Exception e){
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();
	}
	static InputReader in;
    static PrintWriter w;
    static void solve(){
        in = new InputReader(System.in);
        w = new PrintWriter(System.out);
        int sx=in.nextInt(),sy=in.nextInt();
        int fx=in.nextInt(),fy=in.nextInt();
        int ans=4;
        if(sx==fx) {
        		ans+=2+2*Math.abs(sy-fy);
        }else if(sy==fy) {
        		ans+=2+2*Math.abs(sx-fx);
        }else
        		ans=4+2*Math.abs(sx-fx)+2*Math.abs(sy-fy);
        w.println(ans);
    }
	static class InputReader{
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, 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 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 readString(){
            int c = read();
            while (isSpaceChar(c)){
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do{
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

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

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

        private boolean isEndOfLine(int c){
            return c == '\n' || c == '\r' || c == -1;
        }
        public interface SpaceCharFilter{
            public boolean isSpaceChar(int ch);
        }
	}
}

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

public class Main {
    static void solve() throws IOException {
        rl();
        int x1 = ni2(), y1 = ni2();
        rl();
        int x2 = ni2(), y2 = ni2();
        if (x1 == x2) {
            ans.append((Math.abs(y1 - y2) + 1) * 2 + 4).append('\n');
        } else if (y1 == y2) {
            ans.append((Math.abs(x1 - x2) + 1) * 2 + 4).append('\n');
        } else {
            ans.append(2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2)).append('\n');
        }
        output.write(ans.toString());
        output.flush();
        output.close();
    }

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

    static BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    static BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
    static StringBuilder ans = new StringBuilder();
    static String line;
    static StringTokenizer stringTokenizer;

    static int ni1() throws IOException {
        return Integer.parseInt(input.readLine());
    }

    static int ni2() throws IOException {
        return Integer.parseInt(stringTokenizer.nextToken());
    }

    static long nl1() throws IOException {
        return Long.parseLong(input.readLine());
    }

    static long nl2() {
        return Long.parseLong(stringTokenizer.nextToken());
    }

    static void rl() throws IOException {
        stringTokenizer = new StringTokenizer(input.readLine());
    }
}

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

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

    static class TaskM {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();
            if (x1 != x2 && y1 != y2)
                out.println(2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2));
            else {
                out.println(2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2) + 2);
            }

            out.close();
        }

    }
}

import java.util.*;
public class Hack_Earth {
	public static void main(String[] arg){
		Scanner scan = new Scanner(System.in);
		int x1=scan.nextInt();
		int y1=scan.nextInt();
		int x2=scan.nextInt();
		int y2=scan.nextInt();
		int sum=0;
		if(y2>y1)
			sum+=y2-y1+1;
		else if(y2==y1)
			sum+=2;
		else
			sum+=y1-y2+1;

		if(x2>x1)
			sum+=x2-x1+1;
		else if(x2==x1)
			sum+=2;
		else
			sum+=x1-x2+1;
		System.out.println(2*sum);

		scan.close();
	}
}

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

import java.util.Scanner;

/**
 *
 * @author rokk-
 */
public class ACM2017M {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner scanner = new Scanner(System.in);
        int rx = scanner.nextInt();
        int ry = scanner.nextInt();
        int fx = scanner.nextInt();
        int fy = scanner.nextInt();
        int dx = rx-fx;
        if (dx==0){
            dx = 1;
        }
        dx = Math.abs(dx)+1;
        int dy = ry-fy;
        if (dy==0){
            dy = 1;
        }
        dy = Math.abs(dy)+1;
        System.out.println(dx*2+dy*2);
    }

}

import java.util.Scanner;

public class QuadcopterCompetition {

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

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

		if (x1 == x2) {
			x1 += 1;
		} else if (y1 == y2) {
			y1 += 1;
		}

		System.out.println(2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2));
	}

}

import java.util.Scanner;

public class QuadcopterCompetition {

	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 result = 2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2);
		if(x1 == x2 || y1 == y2)
			result += 2;
		System.out.println(result);
	}

}

import java.util.*;
public class Main{
  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 h=0,v=0;
    h=Math.abs(x1-x2);
    v=Math.abs(y1-y2);
    if(x1==x2)
    h=(h+1)*2;
    else
    h+=1;
    if(y1==y2)
    v=(v+1)*2;
    else
    v+=1;
    System.out.println((h+v)*2);
  }
}

import java.util.*;

public class Quadcopter {

   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 x = Math.abs(x1-x2)+1;
      int y = Math.abs(y1-y2)+1;
      if (y==1)
         y=2;
      if (x==1)
         x=2;
      System.out.println(2*x+2*y);
   }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int s1 = sc.nextInt(), s2 = sc.nextInt(), f1 = sc.nextInt(), f2 = sc.nextInt();
        int a = Math.abs(s1 - f1) + 1, b = Math.abs(s2 - f2) + 1;

        if (a == 1) {
            a ++;
        }
        if (b == 1) {
            b ++;
        }
        System.out.println(a * 2 + b * 2);
    }
}

import java.util.Scanner;

public class Problem883M {
    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[][] moves = {{-1, -1}, {1, 1}, {1, -1}, {-1, 1}};
        int[][] moves2 = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};

        boolean onPath = false;
        for (int i = 0; i < 4; i++) {
            int x = x2 + moves2[i][0];
            int y = y2 + moves2[i][1];

            if (x1 == x && y1 == y) onPath = true;

            x = x2 + moves[i][0];
            y = y2 + moves[i][1];

            if (x1 == x && y1 == y) onPath = true;
        }
        if (onPath) {
            System.out.println(8);
            return;
        }

        int min = Integer.MAX_VALUE;
        for (int i = 0; i < moves.length; i++) {
            int x = x2 + moves[i][0];
            int y = y2 + moves[i][1];

            int d = Math.abs(x - x1) + Math.abs(y - y1);
//            System.out.println("x = " + x + " y = " + y + " d = " + d);
            min = Math.min(min, d);

            x = x2 + moves2[i][0];
            y = y2 + moves2[i][1];
            d = Math.abs(x - x1) + Math.abs(y - y1);
            min = Math.min(min, d);
        }
        int res = (min * 2) + 8;
        System.out.println(res);
    }
}

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

/**
 * 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;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskM solver = new TaskM();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskM {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int x1 = in.nextInt();
            int y1 = in.nextInt();

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

            int ans = Math.max(0, Math.abs(x1 - x2) - 1);
            ans += Math.max(0, Math.abs(y1 - y2) - 1);

            out.println(ans * 2 + 8);
        }

    }
}

import java.util.Scanner;

public class P883M
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		int x = scan.nextInt();
		int y = scan.nextInt();
		int xx = scan.nextInt();
		int yy = scan.nextInt();
		int d1 = Math.abs(x-xx);
		int d2 = Math.abs(y-yy);
		if (d1 == 0 || d2 == 0)
			System.out.println(2*(d1+d2+2+1));
		else
			System.out.println(2*(d1+d2+2));
	}
}

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int x1=sc.nextInt();
		int y1=sc.nextInt();
		int x2=sc.nextInt();
		int y2=sc.nextInt();
		int ans=0;
		if(x1!=x2&&y1!=y2)
		{
			if(x1<x2&&y1<y2)
			{
				ans=(x2+1-x1)+(y2+1-y1);
				ans=ans*2;
			}
			else if(x1<x2&&y1>y2)
			{
				ans=(x2+1-x1)+(y1-y2+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1<y2)
			{
				ans=(x1-x2+1)+(y2-y1+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1>y2)
			{
				ans=(x1-x2+1)+(y1-y2+1);
				ans=ans*2;
			}
		}
		if(x1==x2&&y1!=y2)
		{
			ans=Math.abs(y1-y2)+1;
			ans=ans*2;
			ans=ans+4;
		}
		else if(x1!=x2&&y1==y2)
		{
			ans=Math.abs(x1-x2)+1;
			ans=ans*2;
			ans=ans+4;
		}
		System.out.println(ans);
	}

}

import java.util.*;
public class quadcopter
{
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int x1=sc.nextInt();
        int y1=sc.nextInt();sc.nextLine();
        int x2=sc.nextInt();
        int y2=sc.nextInt();
        int path=0;
        if(x1!=x2)
            path=1+Math.abs(x1-x2);
        else
            path+=2;
        if(y1!=y2)
            path+=1+Math.abs(y1-y2);
        else
            path+=2;
        System.out.println(2*path);
    }
}

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 Paras
 */
public class ACM {
    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 ans=0;
        int a=Math.abs(x2-x1)+1;
        ans+=a*2;
        ans+=2;
        int b=Math.abs(y2-y1);
        ans+=b*2;
        if(x1==x2 || y1==y2)
            ans+=2;
        System.out.println(ans);
    }
}

//package CodeForce;
import java.io.*;
import java.util.*;
public class ACMICPCNEERCA {

	static int[] A;
    static int[] S;
    static long[] sum;
   public static int mod=1000000007;
   static int[][] dp;
   static boolean[][] isPalin;
   static int max1=5000+10;
   static int[][] g;
   static int ver;
   static int n;
   static boolean[] visit;
   static LinkedList<Pair> l[];
   static int ans=0;
   static int[] color;
  public static void main(String[] args) throws Exception
   {
   	InputReader in = new InputReader(System.in);
   	PrintWriter pw=new PrintWriter(System.out);
     int x1=in.ii();
     int y1=in.ii();
     int x2=in.ii();
     int y2=in.ii();
     if(dist(x1,y1,x2,y2)==1)pw.println(8);
     else{
     int x3=Math.abs(x1-x2);
     int y3=Math.abs(y1-y2);
   if(x3>0)x3--;
   if(y3>0)y3--;
   	pw.println(2*(x3+y3)+8);
    }

   	 pw.close();
   }
  private  static int dist(int x1, int y1, int x2, int y2) {
      return (x2 - x1) *  (x2 - x1) + (y2 - y1) * (y2 - y1);
  }

  static  void dfs(int i)
  {
	  if(visit[i])return ;
	  visit[i]=true;
	  for(int o:g[i])
		  if(!visit[o])
			  dfs(o);

  }
  private static class DSU{
		int[] parent;
		int[] rank;
		int cnt;
		public DSU(int n){
			parent=new int[n];
			rank=new int[n];
			for(int i=0;i<n;i++){
				parent[i]=i;
				rank[i]=1;
			}
			cnt=n;
		}
		int find(int i){
	        while(parent[i] !=i){
	        	parent[i]=parent[parent[i]];
	        	i=parent[i];
	        }
	        return i;
	    }
		int Union(int x, int y){
	        int xset = find(x);
	        int yset = find(y);
	        if(xset!=yset)
	        	cnt--;
	        if(rank[xset]<rank[yset]){
	        	parent[xset] = yset;
		        rank[yset]+=rank[xset];
		        rank[xset]=0;
		        return yset;
	        }else{
	        	parent[yset]=xset;
	        	rank[xset]+=rank[yset];
	        	rank[yset]=0;
	        	return xset;
	        }
	    }
	}
  public static int[][] packU(int n, int[] from, int[] to, int max) {

	    int[][] g = new int[n][];
	    int[] p = new int[n];
	    for (int i = 0; i < max; i++) p[from[i]]++;
	    for (int i = 0; i < max; i++) p[to[i]]++;
	    for (int i = 0; i < n; i++) g[i] = new int[p[i]];
	    for (int i = 0; i < max; i++) {
	        g[from[i]][--p[from[i]]] = to[i];
	        g[to[i]][--p[to[i]]] = from[i];
	    }
	    return g;
	}
	public static int[][] parents3(int[][] g, int root) {
	    int n = g.length;
	    int[] par = new int[n];
	    Arrays.fill(par, -1);

	    int[] depth = new int[n];
	    depth[0] = 0;

	    int[] q = new int[n];
	    q[0] = root;
	    for (int p = 0, r = 1; p < r; p++) {
	        int cur = q[p];
	        for (int nex : g[cur]) {
	            if (par[cur] != nex) {
	                q[r++] = nex;
	                par[nex] = cur;
	                depth[nex] = depth[cur] + 1;
	            }
	        }
	    }
	    return new int[][]{par, q, depth};
	}
	public static int lower_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] < target)
                low = mid + 1;
            else
                high = mid;
        }
        return nums[low] == target ? low : -1;
    }

    public static int upper_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high + 1 - low) / 2;
            if (nums[mid] > target)
                high = mid - 1;
            else
                low = mid;
        }
        return nums[low] == target ? low : -1;
    }
  public static boolean palin(String s)
	{
	   int i=0;
	   int j=s.length()-1;
	   while(i<j)
	   {
		   if(s.charAt(i)==s.charAt(j))
		   {
			   i++;
			   j--;
		   }
		   else return false;
	   }
	   return true;
	}

    static boolean CountPs(String s,int n)
       {
    	boolean b=false;
    	     char[] S=s.toCharArray();
	       int[][] dp=new int[n][n];
	       boolean[][] p=new boolean[n][n];
	       for(int i=0;i<n;i++)p[i][i]=true;

	       for(int i=0;i<n-1;i++)
	       {
	    	   if(S[i]==S[i+1])
	    	   {
	    		p[i][i+1]=true;
	    		dp[i][i+1]=1;
	    		b=true;
	    	   }
	       }

	       for(int gap=2;gap<n;gap++)
	       {
	    	   for(int i=0;i<n-gap;i++)
	    	   {
	    		   int j=gap+i;
	    		   if(S[i]==S[j]&&p[i+1][j-1]){p[i][j]=true;}

	    		  if(p[i][j])
	    			   dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];

	    		   else  dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];

	    		   if(dp[i][j]>=1){b=true;}
	    	   }
	       }

	    return b;
   // return dp[0][n-1];

    }

public static int gcd(int a,int b)
{
	int res=1;
	while(a>0)
	{
		res=a;
		a=b%a;
		b=res;
	}
	return res;
}

public static long pow(long n,long p,long m)
{
	 long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
}
public static long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}

static class Edge implements Comparator<Edge> {
	private int u;
	private int v;
	private int w;
	public Edge() {
	}
	public Edge(int u, int v, int w) {
		this.u=u;
		this.v=v;
		this.w=w;
	}
	public int getU() {
		return u;
	}
	public void setU(int u) {
		this.u = u;
	}
	public int getV() {
		return v;
	}
	public void setV(int v) {
		this.v = v;
	}
	public int getW() {
		return w;
	}
	public void setW(int w) {
		this.w = w;
	      }
	public int compareTo(Edge e)
	  {
		return this.getW() - e.getW();
	}
	@Override
	public String toString() {
		return "Edge [u=" + u + ", v=" + v + ", w=" + w + "]";
	}
	@Override
	public int compare(Edge arg0, Edge arg1) {
		// TODO Auto-generated method stub
		return 0;
	}
}

static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

	public int compareTo(Pair o) {
		// TODO Auto-generated method stub
		if(this.a!=o.a)
		return -Integer.compare(this.a,o.a);
		else
			return -Integer.compare(this.b, o.b);
		//return 0;
	}
	public boolean equals(Object o) {
       if (o instanceof Pair) {
           Pair p = (Pair)o;
           return p.a == a && p.b == b;
       }
       return false;
   }
   public int hashCode() {
       return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
   }
}

static  class InputReader
{
   private InputStream stream;
   private byte[] buf = new byte[1024];

   private SpaceCharFilter filter;
    byte inbuffer[] = new byte[1024];
   int lenbuffer = 0, ptrbuffer = 0;
    final int M = (int) 1e9 + 7;
   int md=(int)(1e7+1);
    int[] SMP=new int[md];
   final double eps = 1e-6;
   final double pi = Math.PI;

	PrintWriter out;
   String check = "";
 InputStream   obj = check.isEmpty() ? System.in : new ByteArrayInputStream(check.getBytes());
   public InputReader(InputStream stream)
   {
       this.stream = stream;
   }

    int readByte() {
	        if (lenbuffer == -1) throw new InputMismatchException();
	        if (ptrbuffer >= lenbuffer) {
	            ptrbuffer = 0;
	            try {
	                lenbuffer = obj.read(inbuffer);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	        }
	        if (lenbuffer <= 0) return -1;
	        return inbuffer[ptrbuffer++];
   }

   public  int read()
   {
       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;
   }

   String is() {
	        int b = skip();
	        StringBuilder sb = new StringBuilder();
	        while (!(isSpaceChar(b))) // when nextLine, (isSpaceChar(b) && b!=' ')
	        {
	            sb.appendCodePoint(b);
	            b = readByte();
	        }
	        return sb.toString();
   }
   public   int ii() {
	        int num = 0, b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }
 public   long il() {
	        long num = 0;
	        int b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }

	    boolean isSpaceChar(int c) {
	        return (!(c >= 33 && c <= 126));
	       }

	      int skip()
	        {
	        int b;
	        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
	        return b;
	        }

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

	    double id() {
	        return Double.parseDouble(is());
	    }

	    char ic() {
	        return (char) skip();
	    }

	    int[] iia(int n) {
	        int a[] = new int[n];
	        for (int i = 0; i<n; i++) a[i] = ii();
	        return a;
	    }

	    long[] ila(int n) {
	        long a[] = new long[n];
	        for (int i = 0; i <n; i++) a[i] = il();
	        return a;
	    }

	    String[] isa(int n) {
	        String a[] = new String[n];
	        for (int i = 0; i < n; i++) a[i] = is();
	        return a;
	    }

		 long mul(long a, long b) { return a * b % M; }

			long div(long a, long b)
				 {
					return mul(a, pow(b, M - 2));

		           }

	    double[][] idm(int n, int m) {
	        double a[][] = new double[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = id();
	        return a;
	        }

	    int[][] iim(int n, int m) {
	        int a[][] = new int[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j <m; j++) a[i][j] = ii();
	        return a;
          }

   public String readLine() {
       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 interface SpaceCharFilter
   {
       public boolean isSpaceChar(int ch);
   }
   public boolean isEndOfLine(int c) {
       return c == '\n' || c == '\r' || c == -1;
   }
}

}

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

public class A {

	public static void main(String[] args) {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int x = scan.nextInt(), y = scan.nextInt(), xx = scan.nextInt(), yy = scan.nextInt();
		int a = Math.abs(x-(xx+1))+Math.abs(y-(yy+1));
		int b = Math.abs(x-(xx+1))+Math.abs(y-(yy-1));
		int c = Math.abs(x-(xx-1))+Math.abs(y-(yy+1));
		int d = Math.abs(x-(xx-1))+Math.abs(y-(yy-1));
		int res = 0x3f3f3f3f;
		res = Math.min(res, a+b+2);
		res = Math.min(res, c+d+2);
		res = Math.min(res, b+d+2);
		res = Math.min(res, a+c+2);
		out.println(res+4);
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

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

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

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

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

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

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

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}

import java.util.Scanner;

public class M {

	static int dist(int x1, int y1, int x2, int y2) {
		return Math.abs(x2 - x1) + Math.abs(y2 - y1);
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int sx = sc.nextInt(), sy = sc.nextInt();
		int ex = sc.nextInt(), ey = sc.nextInt();

		if (sx == ex || sy == ey) {
			System.out.println(2 * (dist(sx, sy, ex, ey) + 1) + 4);
		} else {
			System.out.println((2 * (dist(sx, sy, ex, ey))) + 4);
		}

	}
}

import java.util.Scanner;

public class M883 {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int xSt = sc.nextInt();
    int ySt = sc.nextInt();
    int xEn = sc.nextInt();
    int yEn = sc.nextInt();
    int counter = 0;
    int x = xSt, y = ySt;
    if(xSt == xEn){
      xSt--;
    }
    counter += (Math.abs(xEn - xSt) + 1)*2;
    if(ySt == yEn){
      ySt--;
    }
    counter += (Math.abs(yEn - ySt) + 1)*2;
    System.out.println(counter);
  }
}

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

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

    static class TaskM {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int a = in.nextInt();
            int b = in.nextInt();
            int c = in.nextInt();
            int d = in.nextInt();
            int ans = 2 * (Math.abs(a - c) + 1 + Math.abs(b - d) + 1);
            if (a == c || b == d) {
                ans += 2;
            }
            out.print(ans);
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

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

    }

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

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

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

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

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

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

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

        }

    }
}

import java.util.*;

public class QuadcopterCompetition{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int x1 = sc.nextInt(), y1 = sc.nextInt(), x2 = sc.nextInt(), y2 = sc.nextInt();
        if(x1 == x2){
            System.out.println(2*(2+Math.abs(y1-y2)+1));
        }
        else if(y1 == y2){
            System.out.println(2* (2 + Math.abs(x1 - x2)+1));
        }
        else{
            int p = Math.abs(x1 - x2) + Math.abs(y1 - y2);
            System.out.println(p*2 + 4);
        }

    }
}

import java.util.*;
public class QuadCopter
{
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 Z=(abs(x1-x2)+abs(y1-y2)+2)*2;
if(x1==x2 || y1==y2)
Z=Z+2;
System.out.println(Z);
}
public static int abs(int a)
{
if(a<0)
return (-1)*a;
else
return a;
}
}

import java.util.*;
public class quadcopterCompetition
{
    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 path=0;
        if(((x2-x1)==0)||((y2-y1)==0))//when points are in on a line parallel to x or y axes
        {
            if((x2-x1)==0)
            {
                if((y1*y2)>0)
                {
                    path+=Math.abs(Math.abs(y2)-Math.abs(y1))+1;
                    path+=2;
                }
                else
                {
                    path+=Math.abs(y2)+Math.abs(y1)+1;
                    path+=2;
                }
                path*=2;
            }
            else
            {
                if((x1*x2)>0)
                {
                    path+=Math.abs(Math.abs(x2)-Math.abs(x1))+1;
                    path+=2;
                }
                else
                {
                    path+=Math.abs(x2)+Math.abs(x1)+1;
                    path+=2;
                }
                path*=2;
            }

        }
        else if(((x1*x2)>0)&&((y1*y2)>0))//when points are in the same quadrant
        {
            path+=Math.abs(Math.abs(x2)-Math.abs(x1))+1;
            path+=Math.abs(Math.abs(y2)-Math.abs(y1))+1;
            path*=2;
        }
        else if(((x1*x2)<0)&&((y1*y2)<0))//when points are in either 1st 3rd or 2nd 4th quadrant
        {
            path+=Math.abs(x1)+Math.abs(x2)+1;
            path+=Math.abs(y1)+Math.abs(y2)+1;
            path*=2;
        }

        else
        {
            if((y1*y2)<0)
            {
                path+=Math.abs(x2-x1)+1;
                path+=Math.abs(y2)+Math.abs(y1)+1;
                path=path*2;
            }
            else
            {
                path+=Math.abs(y2-y1)+1;
                path+=Math.abs(x2)+Math.abs(x1)+1;
                path=path*2;
            }
        }
        System.out.println(path);
    }
}

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

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

    static class MQuadcopterCompetition {
        public void solve(int testNumber, InputReader c, OutputWriter w) {
            int x1 = c.readInt(), y1 = c.readInt(), x2 = c.readInt(), y2 = c.readInt();
            if (x1 == x2 || y1 == y2) {
                if (Math.abs(x1 - x2) == 1 || Math.abs(y1 - y2) == 1) {
                    w.printLine(8);
                } else {
                    w.printLine((Math.abs(x1 - x2) + Math.abs(y1 - y2) - 1) * 2 + 8);
                }
            } else {
                if (Math.abs(x1 - x2) == 1 && Math.abs(y1 - y2) == 1) {
                    w.printLine(8);
                } else {
                    w.printLine((Math.abs(x1 - x2) + Math.abs(y1 - y2) - 2) * 2 + 8);
                }
            }
        }

    }

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

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

        public void printLine(int i) {
            writer.println(i);
        }

    }
}

import java.util.Scanner;

public class Quadcopter {
    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 c = 0;
        int d = 0;
        if(x1<x2)c=(x2-x1+1)*2;
        else if(x1>x2) c=(x1-x2+1)*2;
        else c=(x1-x2+2)*2;

        if(y1<y2)d=(y2-y1+1)*2;
        else if(y1>y2)d=(y1-y2+1)*2;
        else d=(y1-y2+2)*2;
        System.out.println(c+d);
    }
}

import java.util.Scanner;

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

        x2 = sc.nextInt();
        y2 = sc.nextInt();

        int xdiffer = Math.abs(x2-x1);
        int ydiffer = Math.abs(y2-y1);
        if(xdiffer == 0){
            xdiffer =1 ;
        }
        if(ydiffer == 0){
            ydiffer = 1;
        }
        int result =2*( xdiffer + ydiffer ) + 4;
        System.out.println(result);
}
}

import java.util.Scanner;

/**
 * Created by makarfi on 10/21/17.
 */
public class M {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

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

        if ((x1 < 0 && x2 > 0) || (x1 > 0 && x2 < 0)) ans += Math.abs(x1) + Math.abs(x2);
        else ans += Math.abs(x1-x2);
        if ((y1 < 0 && y2 > 0) || (y1 > 0 && y2 < 0)) ans += Math.abs(y1) + Math.abs(y2);
        else ans += Math.abs(y1-y2);

        ans *= 2;

        if (x1 == x2 || y1 == y2) ans += 2;
        ans += 4;

        System.out.println(ans);
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class cf
{
    static int n;
    static int arr[];
     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 sum1=Math.abs(x2-x1);
	    int sum2=Math.abs(y2-y1);
	    sum1+=1;
	    sum2+=1;
	    if(x1!=x2&&y1!=y2)
	    {
	    System.out.println(2*sum1+2*sum2);
	   }
	   else
	    System.out.println(2*sum1+2*sum2+2);
    }
}

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

public class MainM {

	public static void main(String[] args) {
		StdIn in = new StdIn();
		int x1=in.nextInt(), y1=in.nextInt(), x2=in.nextInt(), y2=in.nextInt();
		if(x1==x2) {
			System.out.println((Math.abs(y1-y2)+1)*2+4);
		} else if(y1==y2) {
			System.out.println((Math.abs(x1-x2)+1)*2+4);
		} else {
			System.out.println(Math.max(Math.max(2*(Math.abs(x1-x2+1)+Math.abs(y1-y2+1)), 2*(Math.abs(x1-x2-1)+Math.abs(y1-y2+1))),
					Math.max(2*(Math.abs(x1-x2+1)+Math.abs(y1-y2-1)), 2*(Math.abs(x1-x2-1)+Math.abs(y1-y2-1)))));
		}
	}

	interface Input {
		public String next();
		public String nextLine();
		public int nextInt();
		public long nextLong();
		public double nextDouble();
	}
	static class StdIn implements Input {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

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

		public StdIn(String filename) {
			try{
				din = new DataInputStream(new FileInputStream(filename));
			} catch(Exception e) {
				throw new RuntimeException();
			}
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String next() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == ' ' || c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c=read();
			}
			return s.toString();
		}

		public String nextLine() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c = read();
			}
			return s.toString();
		}

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

		public long nextLong() {
			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 long[] readLongArray(int n) {
			long[] ar = new long[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextLong();
			return ar;
		}

		public double nextDouble() {
			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() {
			try{
				if (bufferPointer == bytesRead)
					fillBuffer();
				return buffer[bufferPointer++];
			} catch(IOException e) {
				throw new RuntimeException();
			}
		}

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

    		import java.awt.List;
    		import java.io.*;
    		import java.util.*;

    		/*
    		 *
    		 * daiict
    		 *
    		 *
    		 *
    		 */

    		public class prac {
    			FastScanner in;
    			PrintWriter out;

    			static ArrayList[] adj;

    			static int n;
    			static int m;

    			static int[] dp1;
    			static int[] dp2;
    			static int color[];
    			static int visited[];
    			static int[][] arr;
    			static int[][] brr;
    			static int[][] ans;
    			static int array[];
    			static int pref[];
    			static int tree[];
    			static int maxval = 32;
    			static HashSet<Integer> set;
    			static int sum = 0;
    		//for dfs do not delete
    			static int dir[][] ={{1,0},{0,1},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};

    			static long[] seg;
    			static long count = 1;
    			static long mod = (long)1e9 + 7;
    			static HashMap<String,HashSet<String>> graph;
    			static HashMap<String,String> best;
    			static HashSet<String> vis;

    			static class Pair implements Comparable<Pair>
    		    {
    				int x;int y;

    		        Pair(int l, int m) {

    		        	this.x = l;
    		            this.y = m;

    		        }

    		        public int compareTo(Pair p) {
    		            if (this.x == p.x) {
    		                return (int)(this.y-p.y);
    		            }
    		            return (int)(this.x - p.x);
    		        }

    		        public String toString(){
    		        	return x + " " + y;
    		        }

    		        public boolean equals(Object o){
    		        	if(o instanceof Pair){
    		        		Pair a = (Pair)o;

    		        		return this.x == a.x;
    		        	}

    		        	return false;
    		        }

    		        public int hashCode(){
    		        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
    		        }

    		    }

    			public static int gcd(int a, int b) {
    				if (b == 0) return a;
    				return gcd(b, a%b);
    			}

    			void build(int n) {  // build the tree
    				  for (int i = n - 1; i > 0; --i) seg[i] = Math.min(seg[i<<1],seg[i<<1|1]);
    				}

    			public static void modify(int p, long val,int n) {  // set value at position p
    				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.min(seg[p],seg[p^1]);
    				}

    				long query(int l, int r,int n) {  // sum on interval [l, r)
    				  long res = Long.MAX_VALUE;
    				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
    				    if ((l&1) == 1) res = (long) Math.min(res,seg[l++]);
    				    if ((r&1) == 1) res = (long)Math.min(res,seg[--r]);
    				  }
    				  return res;
    				}

    			public static void update(int x,int val){
    				while(x<=maxval){
    					tree[x] += val;
    					x = (x&-x);
    				}
    			}

    			public static int read(int idx){
    				int sum = 0;

    				while(idx>= 0){
    					sum += tree[idx];
    					idx -= (idx&(-idx));
    				}

    				return sum;
    			}

    		    void solve() throws NumberFormatException, IOException {

    		    //	Scanner in = new Scanner(System.in);
    		    	StringBuilder sb = new StringBuilder();

    		    	int a = in.nextInt();
    		    	int b = in.nextInt();

    		    	int c = in.nextInt();
    		    	int d = in.nextInt();

    		    	int ans = Math.abs(a-c) + Math.abs(b-d);
    		    	ans = ans*2;

    		    	if(ans == 2){
    		    		ans = 8;
    		    	}else{
    		    		if(c == a || b == d){
    		    			ans += 6;
    		    		}else{
    		    			ans += 4;
    		    		}
    		    	}

    		    	out.println(ans);
    		    }

    		    public static int floor(int[] arr,int d){
    		    	int c = -1;
    		    	int l = 0;
    		    	int r = arr.length-1;

    		    	while(l<r){
    		    		int mid = (l+r)/2;
    		    		//System.out.println(l + " " + r+" " +mid + " "+arr[mid]);
    		    		if(arr[mid] >= d){
    		    			r = mid-1;
    		    		}else{
    		    			l = mid;
    		    		}

    		    		if(l == r-1){
    		    			if(arr[r] == d){
    		    				return l;
    		    			}else{
    		    				return r;
    		    			}
    		    		}

    		    		c = l;

    		    	}

    		    	return c;
    		    }

    		    public static int as(long n){
    		    	int c = 0;

    		    	while(n!=0){
    		    		c += n%10;
    		    		n /= 10;
    		    	}
    		    	return c;
    		    }

    		    public static int Floor(int arr[], int low, int high, int x)
    		    {
    		        // If low and high cross each other
    		        if (low > high)
    		            return -1;

    		        // If last element is smaller than x
    		        if (x >= arr[high])
    		            return high;

    		        // Find the middle point
    		        int mid = (low+high)/2;

    		        // If middle point is floor.
    		        if (arr[mid] == x)
    		            return mid;

    		        // If x lies between mid-1 and mid
    		        if (mid > 0 && arr[mid-1] <= x && x < arr[mid])
    		            return mid-1;

    		        // If x is smaller than mid, floor must be in
    		        // left half.
    		        if (x < arr[mid])
    		            return Floor(arr, low, mid-1, x);

    		        // If mid-1 is not floor and x is greater than
    		        // arr[mid],
    		        return Floor(arr, mid+1, high, x);
    		    }

    		    public static String reverse(String s){

    		    	String ans = "";

    		    	for(int i = s.length()-1;i>=0;i--){
    		    		ans += s.charAt(i);
    		    	}

    		    	return ans;

    		    }

    		    public static long sum(long x){
    		    	return x<10?x:x%10 + sum(x/10);
    		    }

    			public static long gcd(long x, long y) {
    				if (x == 0)
    					return y;
    				else
    					return gcd( y % x,x);
    			}
    			static long inv(long x , long mod)
    			{
    				long r,y;
    				for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
    				{
    					if((y&1)==1)
    						r=r*x%mod;

    				}
    				return r;
    			}

    			public static long pow(long x,long y,long n){
    				if(y==0)
    					return 1%n;
    				if(y%2==0){
    					long z=pow(x,y/2,n);
    					return (z*z)%n;
    				}
    				return ((x%n)*pow(x,y-1,n))%n;
    			}

    			public static boolean isPrime(int n) {
    				// Corner cases
    				if (n <= 1)
    					return false;
    				if (n <= 3)
    					return true;

    				// This is checked so that we can skip
    				// middle five numbers in below loop
    				if (n % 2 == 0 || n % 3 == 0)
    					return false;

    				for (int i = 5; i * i <= n; i = i + 6)
    					if (n % i == 0 || n % (i + 2) == 0)
    						return false;

    				return true;
    			}

    			void run() throws NumberFormatException, IOException {
    				in = new FastScanner();
    				out = new PrintWriter(System.out);

    				solve();

    				out.close();
    			}

    			class FastScanner {
    				BufferedReader br;
    				StringTokenizer st;

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

    				String next() {
    					while (st == null || !st.hasMoreTokens()) {
    						try {
    							st = new StringTokenizer(in.br.readLine());
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    					return st.nextToken();
    				}

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

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

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

    			public static void main(String[] args) throws NumberFormatException, IOException {
    				new prac().run();
    			}
    		}

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

public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
	Scanner sc=new Scanner(System.in);

	int x1=sc.nextInt();
	int y1=sc.nextInt();
	int x2=sc.nextInt();
	int y2=sc.nextInt();
	int ans=0;

	if(x1==x2)ans=2*2+(Math.abs(y1-y2)+1)*2;
	else if(y1==y2)ans=2*2+(Math.abs(x1-x2)+1)*2;
	else ans=(Math.abs(x1-x2)+1)*2+(Math.abs(y1-y2)+1)*2;

	System.out.println(ans);
	}

}

import javafx.scene.input.InputMethodTextRun;
import org.omg.CORBA.INTERNAL;
import sun.rmi.server.Activation$ActivationSystemImpl_Stub;

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

public class Newbie {

    static InputReader sc = new InputReader(System.in);
    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) {
        solver s = new solver();
        long t = 1;
        while (t > 0) {
            s.solve();
            t--;
        }
        out.close();
    }

   /* static class descend implements Comparator<pair1> {
        public int compare(pair1 o1, pair1 o2) {
            if (o1.pop != o2.pop)
                return (int) (o1.pop - o2.pop);
            else
                return o1.in - o2.in;
        }
    }*/

    static class InputReader {
        public BufferedReader br;
        public StringTokenizer token;

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

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

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

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

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

    static class card {
        long a;
        int cnt;
        int i;

        public card(long a, int cnt, int i) {
            this.a = a;
            this.cnt = cnt;
            this.i = i;
        }
    }

    static class ascend implements Comparator<pair> {
        public int compare(pair o1, pair o2) {
            if (o1.a != o2.a)
                return (int) (o1.a - o2.a);
            else
                return o1.b - o2.b;
        }
    }

    static class extra {

        static boolean v[] = new boolean[100001];
        static List<Integer> l = new ArrayList<>();
        static int t;

        static void shuffle(long a[]) {
            List<Long> l = new ArrayList<>();
            for (int i = 0; i < a.length; i++)
                l.add(a[i]);
            Collections.shuffle(l);
            for (int i = 0; i < a.length; i++)
                a[i] = l.get(i);
        }

        static int gcd(int a, int b) {
            if (b == 0)
                return a;
            else
                return gcd(b, a % b);
        }

        static boolean valid(int i, int j, int r, int c, char ch[][]) {
            if (i >= 0 && i < r && j >= 0 && j < c && ch[i][j] != '#') {
                // System.out.println(i+" /// "+j);
                return true;
            } else {
                //  System.out.println(i+" //f "+j);
                return false;
            }
        }

        static void seive() {
            for (int i = 2; i < 100001; i++) {
                if (!v[i]) {
                    t++;
                    l.add(i);
                    for (int j = 2 * i; j < 100001; j += i)
                        v[j] = true;
                }
            }
        }

        static int binary(LinkedList<Integer> a, long val, int n) {
            int mid = 0, l = 0, r = n - 1, ans = 0;
            while (l <= r) {
                mid = (l + r) >> 1;
                if (a.get(mid) == val) {
                    r = mid - 1;
                    ans = mid;
                } else if (a.get(mid) > val)
                    r = mid - 1;
                else {
                    l = mid + 1;
                    ans = l;
                }
            }
            return (ans + 1);
        }

        static long fastexpo(int x, int y) {
            long res = 1;
            while (y > 0) {
                if ((y & 1) == 1) {
                    res *= x;
                }
                y = y >> 1;
                x = x * x;
            }
            return res;
        }

        static long lfastexpo(int x, int y, int p) {
            long res = 1;
            x = x % p;
            while (y > 0) {
                if ((y & 1) == 1) {
                    res = (res * x) % p;
                }
                y = y >> 1;
                x = (x * x) % p;
            }
            return res;
        }

       /* void dijsktra(int s, List<pair> l[], int n) {
            PriorityQueue<pair> pq = new PriorityQueue<>(new ascend());
            int dist[] = new int[100005];
            boolean v[] = new boolean[100005];
            for (int i = 1; i <= n; i++)
                dist[i] = 1000000000;
            dist[s] = 0;
            for (int i = 1; i < n; i++) {
                if (i == s)
                    pq.add(new pair(s, 0));
                else
                    pq.add(new pair(i, 1000000000));
            }
            while (!pq.isEmpty()) {
                pair node = pq.remove();
                v[node.a] = true;
                for (int i = 0; i < l[node.a].size(); i++) {
                    int v1 = l[node.a].get(i).a;
                    int w = l[node.a].get(i).b;
                    if (v[v1])
                        continue;
                    if ((dist[node.a] + w) < dist[v1]) {
                        dist[v1] = dist[node.a] + w;
                        pq.add(new pair(v1, dist[v1]));
                    }
                }
            }
        }*/
    }

    static class pair {
        long a;
        int b;

        public pair(long a, int i) {
            this.a = a;
            this.b = i;
        }
    }

    static class pair1 {
        pair p;
        int in;

        public pair1(pair a, int n) {
            this.p = a;
            this.in = n;
        }
    }

    static int inf = 5000013;

    static class solver {
        void solve() {
            int x1=sc.nextInt();
            int y1=sc.nextInt();
            int x2=sc.nextInt();
            int y2=sc.nextInt();
            int x=Math.abs(x1-x2);
            int y=Math.abs(y1-y2);
            if(x==0 || y==0)
                System.out.println((x+y+3)*2);
            else
                System.out.println((x+y+2)*2);
        }
    }
}

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

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

    static class TaskM {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int x = in.ni(), y = in.ni();
            int tx = in.ni(), ty = in.ni();
            int dx = Math.abs(x - tx), dy = Math.abs(y - ty);
            if (dx == 0) {
                out.println((dy + 3) * 2);
            } else if (dy == 0) {
                out.println((dx + 3) * 2);
            } else {
                out.println((dx + dy + 2) * 2);
            }
        }

    }

    static class FastScanner {
        private BufferedReader in;
        private StringTokenizer st;

        public FastScanner(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
        }

        public String ns() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    String rl = in.readLine();
                    if (rl == null) {
                        return null;
                    }
                    st = new StringTokenizer(rl);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

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

    }
}

import java.util.Scanner;

public class QuadcopterCompetition {

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

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

		if (x1 == x2) {
			x1 += 1;
		} else if (y1 == y2) {
			y1 += 1;
		}

		System.out.println(2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2));
	}

}

import java.util.Scanner;
public class cfm {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int x = input.nextInt();
        int y = input.nextInt();
        int xf = input.nextInt();
        int yf = input.nextInt();
        int dis = 0;
        int x1 = Math.abs(xf - x);
        int y1 = Math.abs(yf - y);
        int s;
        if(x == xf || y == yf){
            s = x1 + y1 + 3;
        }else {
            s = x1 + y1 + 2;
        }
        dis = s * 2;
        System.out.println(dis);
    }
}

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

public class PP1 {
	static double eps = (double) 1e-6;

	public static void main(String[] args) throws FileNotFoundException{
		InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		// InputReader in = new InputReader(new FileInputStream("in.txt"));
		// PrintWriter out = new PrintWriter(new FileOutputStream("out.txt"));
		int x1 = in.nextInt();
		int y1 = in.nextInt();
		int x2 = in.nextInt() - x1;
		int y2 = in.nextInt() - y1;
		out.println(Math.max(2, (Math.abs(x2) + 1)) * 2 + Math.max(2, (Math.abs(y2) + 1)) * 2);
		out.close();

	}

	static long gcd(long a, long b){
		if (b == 0)
			return a;
		else
			return gcd(b, a % b);
	}

	static class Pair implements Comparable<Pair> {
		int r;
		int h;
		int t;

		Pair(int rr, int hh, int i) {
			r = rr;
			h = hh;
			t = i;
		}

		@Override
		public int compareTo(Pair edge){
			if (this.h != edge.h) {
				return -Integer.compare(this.h, edge.h);
			} else {
				return -Integer.compare(this.r, edge.r);

			}
		}

	}

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

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

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

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

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

	}

}

import java.util.*;

public class Quadcopter {
    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 moveX = 0;
        int moveY = 0;
        if((x1==x2) || (y1==y2)){
            if(x1 > x2) moveX = x1 - x2;
            else moveX = x2 - x1;

            if(y1 > y2) moveY = y1 - y2;
            else moveY = y2 - y1;

            int ans = (moveX + moveY)*2 + 6;
            System.out.println(ans);
        }else{
            if(x1 > x2) moveX = x1 - x2;
            else moveX = x2 - x1;

            if(y1 > y2) moveY = y1 - y2;
            else moveY = y2 - y1;

            int ans = (moveX + moveY)*2 + 4;
            System.out.println(ans);
        }
    }
}

import java.util.*;
public class AUD
{
	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 ans=((Math.abs(x1-x2)+1)*2+(Math.abs(y1-y2)+1)*2);
		if(x1==x2||y1==y2)System.out.println(ans+2);
		else System.out.println(ans);
	}
}

import java.util.Scanner;

public class QuadcopterCompetition {

	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 result = 2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2);
		if(x1 == x2 || y1 == y2)
			result += 2;
		System.out.println(result);
	}

}

import java.util.Scanner;

public class Demo {

	/**
	 * @param args
	 */
	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 sum=8+2*(Math.abs(x1-x2)-1)+2*(Math.abs(y1-y2)-1);
		if(x1==x2)
			sum=8+2*(Math.abs(y1-y2)-1);
		if(y1==y2)
			sum=8+2*(Math.abs(x1-x2)-1);

		in.close();
		System.out.println(sum);
	}
}

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

public class QuadcopterCompetition {
    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;
        }
    }

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

        FastReader scan = new FastReader();
        int x1 = scan.nextInt(), y1 = scan.nextInt(), x2 = scan.nextInt(), y2 = scan.nextInt();
        int ans = 0;
        if (x1 == x2 || y1 == y2) {
            ans = (Math.abs(x1 - x2) + 1) * 2 + (Math.abs(y1 - y2) + 1) * 2 + 2;
        } else {
            ans = (Math.abs(x1 - x2) + 1) * 2 + (Math.abs(y1 - y2) + 1) * 2;
        }
        System.out.println(ans);
    }
}

import java.util.*;

public class Quadcopter {

   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 x = Math.abs(x1-x2)+1;
      int y = Math.abs(y1-y2)+1;
      if (y==1)
         y=2;
      if (x==1)
         x=2;
      System.out.println(2*x+2*y);
   }
}

import java.util.Scanner;

public class q1 {

	private static Scanner sc;

	public static void main(String[] args) {

		sc = new Scanner(System.in);
		int l=0;
		int x1=sc.nextInt();
		int y1=sc.nextInt();
		int x2=sc.nextInt();
		int y2=sc.nextInt();

		if (x1==x2) {
			l=Math.abs(y2-y1)*2+6;
		}
		else if (y1==y2){
			l=Math.abs(x1-x2)*2+6;
		}
		else {
			l=(Math.abs(x1-x2)+Math.abs(y1-y2)+2)*2;
		}
		System.out.println(l);

	}

}

import java.util.Scanner;

public class Zadacha1 {

	public static void main(String[] args) {
		Per abc = new Per();
		abc.solve();
		abc.print();

	}

}
class Per{
int x1;
int y1;
int x2;
int y2;
int p;
int a;
int b;
int c;
int d;
Per(){
	Scanner con = new Scanner(System.in);
		x1 = con.nextInt();
		y1 = con.nextInt();
		x2 = con.nextInt();
		y2 = con.nextInt();
		con.close();
	}
void solve(){
	a = Math.min(x1, x2-1);
	b = Math.max(y1, y2+1);
	c = Math.max(x1, x2+1);
	d = Math.min(y1, y2-1);
	p=2*(c-a)+2*(b-d);
	}
void print(){
	System.out.println(p);
}
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.SortedSet;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

/**
 * #
 * @author pttrung
 */
public class M_NEERC_2017 {

    public static long MOD = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File(
        // "output.txt")));
        PrintWriter out = new PrintWriter(System.out);
        Scanner in = new Scanner();
        int x1 = in.nextInt();
        int y1 = in.nextInt();
        int x2 = in.nextInt();
        int y2 = in.nextInt();
        int x = Math.abs(x1 - x2) + 1;
        int y = Math.abs(y1 - y2) + 1;
        if (x1 == x2) {
            x = 2;
        }
        if (y1 == y2) {
            y = 2;
        }
        out.println(2 * x + 2 * y);
        out.close();
    }

    public static int[] KMP(String val) {
        int i = 0;
        int j = -1;
        int[] result = new int[val.length() + 1];
        result[0] = -1;
        while (i < val.length()) {
            while (j >= 0 && val.charAt(j) != val.charAt(i)) {
                j = result[j];
            }
            j++;
            i++;
            result[i] = j;
        }
        return result;

    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static int digit(long n) {
        int result = 0;
        while (n > 0) {
            n /= 10;
            result++;
        }
        return result;
    }

    public static double dist(long a, long b, long x, long y) {
        double val = (b - a) * (b - a) + (x - y) * (x - y);
        val = Math.sqrt(val);
        double other = x * x + a * a;
        other = Math.sqrt(other);
        return val + other;

    }

    public static class Point implements Comparable<Point> {

        int x, y;

        public Point(int start, int end) {
            this.x = start;
            this.y = end;
        }

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

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

        @Override
        public int compareTo(Point o) {
            return Integer.compare(x, o.x);
        }
    }

    public static class FT {

        long[] data;

        FT(int n) {
            data = new long[n];
        }

        public void update(int index, long value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public long get(int index) {
            long result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b, long MOD) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2, MOD);
        if (b % 2 == 0) {
            return val * val % MOD;
        } else {
            return val * (val * a % MOD) % MOD;

        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            //  br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("input.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

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

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

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}

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

import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static java.util.Arrays.copyOf;
import static java.util.Arrays.fill;
import static java.util.Arrays.sort;
import static java.util.Collections.asLifoQueue;
import static java.util.Collections.reverseOrder;
import static java.util.Collections.sort;

public class Main {
    private FastScanner in;
    private PrintWriter out;

    private void solve() throws IOException {
        int x1 = in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
        out.println((max(abs(x2 - x1) + 1, 2) + max(abs(y2 - y1) + 1, 2)) * 2);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

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

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

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

        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 nextLine() throws IOException {
            return br.readLine();
        }

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

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // in = new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // out = new PrintWriter(new FileOutputStream(".out"));

        solve();

        out.flush();
        out.close();
    }

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

import java.util.Arrays;
import java.util.Scanner;

public class cf
{
    static int n;
    static int arr[];
     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 sum1=Math.abs(x2-x1);
	    int sum2=Math.abs(y2-y1);
	    sum1+=1;
	    sum2+=1;
	    if(x1!=x2&&y1!=y2)
	    {
	    System.out.println(2*sum1+2*sum2);
	   }
	   else
	    System.out.println(2*sum1+2*sum2+2);
    }
}

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

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

    static class TaskM {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();
            int xMin = Math.min(x1, x2 - 1);
            int yMin = Math.min(y1, y2 - 1);
            int xMax = Math.max(x1, x2 + 1);
            int yMax = Math.max(y1, y2 + 1);
            out.println((xMax - xMin) * 2 + (yMax - yMin) * 2);
        }

    }

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

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

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

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

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

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

    }
}

import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
public class Main implements Runnable {

    public static void main(String[] args) {
        new Thread(null, new Main(), "Check2", 1 << 28).start();// to increse stack size in java
    }
    void init(ArrayList <Integer> adj[], int n){
        for(int i=0;i<=n;i++)adj[i]=new ArrayList<>();
    }

    static long mod = (long) (1e9+7);
    public void run() {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

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

        if(x1-x2!=0&&y1-y2!=0) {
            int val = 2*(abs(x1 - x2)+1) + 2*(abs(y1 - y2) + 1);
            w.println(val);
        }
        else if(x1-x2==0){

            w.println(4+2*(abs(y1-y2))+2);
        }
        else if(y1-y2==0){

            w.println(4+2*(abs(x1-x2))+2);
        }
        else
            w.println(0);

        w.close();
    }

    class pair2  {

        int a,b;
        pair2(int a,int b){
            this.a=a;
            this.b=b;
        }
    }

    static void diji(int s, long dist[], ArrayList<pair> adj[]) {
        dist[s] = 0;
        PriorityQueue<pair> q = new PriorityQueue<>(new cmp());
        q.add(new pair(s, 0));
        while (!q.isEmpty()) {
            pair p1 = q.poll();
            for (pair ne: adj[p1.a]) {

                if ((long) p1.b + (long) ne.b < dist[ne.a]) {
                    dist[ne.a] = (long) p1.b + (long) ne.b;
                    pair p2 = new pair(ne.a, dist[ne.a]);
                    q.add(p2);

                }

            }
        }

    }
    static class cmp implements Comparator<pair>{

        public  int compare(pair o1,pair o2)
        {
            return o1.b<o2.b?-1:o1.b>o2.b?1:0;
        }

    }

    static class pair {
        int a;
        long b;
        pair(int a,long b){
            this.a=a;
            this.b=b;
        }
        public boolean equals(Object obj) {      //  override equals method for object to remove tem from arraylist and sets etc.......
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            pair other = (pair) obj;
            if (b!= other.b||a!=other.a)
                return false;
            return true;
        }
    }

    static long modinv(long a,long b)
    {
        long p=power(b,mod-2);

        p=a%mod*p%mod;
        p%=mod;

        return p;

    }

    static long power(long x,long y){
        if(y==0)return 1%mod;
        if(y==1)return x%mod;

        long res=1;
        x=x%mod;
        while(y>0){

            if((y%2)!=0){
                res=(res*x)%mod;
            }

            y=y/2;
            x=(x*x)%mod;
        }

        return res;

    }
    static  long gcd(long a,long b){

        if(b==0)return a;
        return gcd(b,a%b);
    }

    static  void sev(int a[],int n){

        for(int i=2;i<=n;i++)a[i]=i;
        for(int i=2;i<=n;i++){

            if(a[i]!=0){
                for(int j=2*i;j<=n;){

                    a[j]=0;
                    j=j+i;
                }
            }

        }

    }

    static 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 String nextLine()
        {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
        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 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 double nextDouble()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

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

            return res.toString();
        }

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

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

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

}

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

public class Solution {

    public static void main(String[] args) throws Exception {
        MyReader reader = new MyReader(System.in);
        MyWriter writer = new MyWriter(System.out);
        new Solution().run(reader, writer);
        writer.close();
    }

    private void run(MyReader reader, MyWriter writer) throws IOException {
        int x1 = reader.nextInt();
        int y1 = reader.nextInt();
        int x2 = reader.nextInt();
        int y2 = reader.nextInt();
        int a = Math.abs(x1 - x2);
        int b = Math.abs(y1 - y2);
        a = a == 0 ? 2 : a + 1;
        b = b == 0 ? 2 : b + 1;
        writer.print(2 * (a + b));
    }

    static class MyReader {

        final BufferedInputStream in;
        final int bufSize = 1 << 16;
        final byte buf[] = new byte[bufSize];
        int i = bufSize;
        int k = bufSize;
        final StringBuilder str = new StringBuilder();

        MyReader(InputStream in) {
            this.in = new BufferedInputStream(in, bufSize);
        }

        int nextInt() throws IOException {
            return (int) nextLong();
        }

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

        int[][] nextIntMatrix(int n, int m) throws IOException {
            int[][] a = new int[n][0];
            for (int j = 0; j < n; j++) {
                a[j] = nextIntArray(m);
            }
            return a;
        }

        long nextLong() throws IOException {
            int c;
            long x = 0;
            boolean sign = true;
            while ((c = nextChar()) <= 32) ;
            if (c == '-') {
                sign = false;
                c = nextChar();
            }
            if (c == '+') {
                c = nextChar();
            }
            while (c >= '0') {
                x = x * 10 + (c - '0');
                c = nextChar();
            }
            return sign ? x : -x;
        }

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

        int nextChar() throws IOException {
            if (i == k) {
                k = in.read(buf, 0, bufSize);
                i = 0;
            }
            return i >= k ? -1 : buf[i++];
        }

        String nextString() throws IOException {
            int c;
            str.setLength(0);
            while ((c = nextChar()) <= 32 && c != -1) ;
            if (c == -1) {
                return null;
            }
            while (c > 32) {
                str.append((char) c);
                c = nextChar();
            }
            return str.toString();
        }

        String nextLine() throws IOException {
            int c;
            str.setLength(0);
            while ((c = nextChar()) <= 32 && c != -1) ;
            if (c == -1) {
                return null;
            }
            while (c != '\n') {
                str.append((char) c);
                c = nextChar();
            }
            return str.toString();
        }

        char[] nextCharArray() throws IOException {
            return nextString().toCharArray();
        }

        char[][] nextCharMatrix(int n) throws IOException {
            char[][] a = new char[n][0];
            for (int i = 0; i < n; i++) {
                a[i] = nextCharArray();
            }
            return a;
        }
    }

    static class MyWriter {

        final BufferedOutputStream out;
        final int bufSize = 1 << 16;
        final byte buf[] = new byte[bufSize];
        int i = 0;
        final byte c[] = new byte[30];
        static final String newLine = System.getProperty("line.separator");

        MyWriter(OutputStream out) {
            this.out = new BufferedOutputStream(out, bufSize);
        }

        void print(long x) throws IOException {
            int j = 0;
            if (i + 30 >= bufSize) {
                flush();
            }
            if (x < 0) {
                buf[i++] = (byte) ('-');
                x = -x;
            }
            while (j == 0 || x != 0) {
                c[j++] = (byte) (x % 10 + '0');
                x /= 10;
            }
            while (j-- > 0)
                buf[i++] = c[j];
        }

        void print(int[] m) throws IOException {
            for (int a : m) {
                print(a);
                print(' ');
            }
        }

        void print(long[] m) throws IOException {
            for (long a : m) {
                print(a);
                print(' ');
            }
        }

        void print(String s) throws IOException {
            for (int i = 0; i < s.length(); i++) {
                print(s.charAt(i));
            }
        }

        void print(char x) throws IOException {
            if (i == bufSize) {
                flush();
            }
            buf[i++] = (byte) x;
        }

        void print(char[] m) throws IOException {
            for (char c : m) {
                print(c);
            }
        }

        void println(String s) throws IOException {
            print(s);
            println();
        }

        void println() throws IOException {
            print(newLine);
        }

        void flush() throws IOException {
            out.write(buf, 0, i);
            out.flush();
            i = 0;
        }

        void close() throws IOException {
            flush();
            out.close();
        }
    }
}

import java.util.Scanner;
public class cfm {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int x = input.nextInt();
        int y = input.nextInt();
        int xf = input.nextInt();
        int yf = input.nextInt();
        int dis = 0;
        int x1 = Math.abs(xf - x);
        int y1 = Math.abs(yf - y);
        int s;
        if(x == xf || y == yf){
            s = x1 + y1 + 3;
        }else {
            s = x1 + y1 + 2;
        }
        dis = s * 2;
        System.out.println(dis);
    }
}

import java.util.*;
public class Main{
  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 h=0,v=0;
    h=Math.abs(x1-x2);
    v=Math.abs(y1-y2);
    if(x1==x2)
    h=(h+1)*2;
    else
    h+=1;
    if(y1==y2)
    v=(v+1)*2;
    else
    v+=1;
    System.out.println((h+v)*2);
  }
}

import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.io.IOException;
import java.io.InputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

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

        File file = new File("in.txt");
        File fileOut = new File("out.txt");
        InputStream inputStream = null;
        OutputStream outputStream = null;
        // try {inputStream= new FileInputStream(file);} catch (FileNotFoundException ex){return;};
//        try {outputStream= new FileOutputStream(fileOut);} catch (FileNotFoundException ex){return;};
        inputStream = System.in;
        outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

}

class Task {

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        IntPair start = new IntPair(in.nextInt(), in.nextInt());
        IntPair end = new IntPair(in.nextInt(), in.nextInt());
        Integer val = 2* Math.abs(end.first - start.first) + 2 * Math.abs(end.second - start.second);
        if(!start.first.equals(end.first) && !start.second.equals(end.second)){
            val+=4;
        }
        else{
            val+=6;
        }
        out.println(val);

    }

}

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 String nextLine(){
        try {
            return reader.readLine();
        } catch (IOException e){
            throw new RuntimeException(e);
        }
    }

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

}

class Pair<F, S> {
    public final F first;
    public final S second;

    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair<?, ?> p = (Pair<?, ?>) o;
        return Objects.equals(p.first, first) && Objects.equals(p.second, second);
    }

    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    @Override
    public String toString() {
        return "(" + first + ", " + second + ')';
    }
}

class IntPair extends Pair<Integer, Integer>{
    public IntPair(Integer first, Integer second){
        super(first, second);
    }
}

//package CodeForces_practice;

import java.util.Scanner;

public class M883 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int a=s.nextInt();
		int b=s.nextInt();
		a=Math.abs(a-s.nextInt());
		b=Math.abs(b-s.nextInt());
		int ans=0;
		if(a>1||b>1) ans=Math.abs(a-1)+Math.abs(b)+Math.abs(b-1)+Math.abs(a)+6;
		else ans=8;
		System.out.println(ans);
	}

}

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

public class TestClass{

    static class Parser
    {
        final private int BUFFER_SIZE = 1 << 16;

        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

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

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

        //reads in the next string
        public String next() throws Exception
        {
            StringBuilder ret =  new StringBuilder();
            byte c = read();
            while (c <= ' ') c = read();
            do
            {
                ret = ret.append((char)c);
                c = read();
            } while (c > ' ');
            return ret.toString();
        }

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

        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++];
        }
    }
    static class OutputWriter
    {
        private PrintWriter writer;

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

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

        public void println(int x)
        {
            writer.println(x);
        }

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

        public void println(char x)
        {
            writer.println(x);
        }

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

        public void println(int array[], int size)
        {
            for (int i = 0; i < size; i++)
                println(array[i]);
        }

        public void print(int array[], int size)
        {
            for (int i = 0; i < size; i++)
                print(array[i] + " ");
        }

        public void println(long x)
        {
            writer.println(x);
        }

        public void print(long x)
        {
            writer.print(x);
        }

        public void println(long array[], int size)
        {
            for (int i = 0; i < size; i++)
                println(array[i]);
        }

        public void print(long array[], int size)
        {
            for (int i = 0; i < size; i++)
                print(array[i]);
        }

        public void println(float num)
        {
            writer.println(num);
        }

        public void print(float num)
        {
            writer.print(num);
        }

        public void println(double num)
        {
            writer.println(num);
        }

        public void print(double num)
        {
            writer.print(num);
        }

        public void println(String s)
        {
            writer.println(s);
        }

        public void print(String s)
        {
            writer.print(s);
        }

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

        public void printSpace()
        {
            writer.print(" ");
        }

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

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

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

    }
static class Node{
Node child[]=new Node[2];
    Node(){
        child[0]=null;
        child[1]=null;
    }
}
static long postfix[];
    static long prefix[];
   static Node root;
    static Deque<Integer> binary(long x){
        Deque<Integer> ans=new LinkedList<>();
        while (x>0){
            ans.addFirst((int)(x%2));
            x/=2;
        }
        while (ans.size()<50)
            ans.addFirst(0);
        return ans;
    }
    static void add(long x){
       // System.out.println("yo2");
        Deque<Integer> a=binary(x);
       // System.out.println("yo");
        Node C=root;
        while (a.size()>0){
            if(C.child[a.getFirst()]==null)
                C.child[a.getFirst()]=new Node();
            C=C.child[a.getFirst()];
            a.pollFirst();
        }
    }
    static long query(long x){
        Deque<Integer> a=binary(x);

        Node C=root;
        long ans=0;
        while (a.size()>0){
            if(C.child[1-a.getFirst()]!=null){
                C=C.child[1-a.getFirst()];
                ans*=2;
                ans+=1;
            }
            else{
                C=C.child[a.getFirst()];
                ans*=2;
            }
            a.pollFirst();
        }
        return ans;
    }
   static int X[]={-1,-1,-1,0,0,1,1,1};
       static int Y[]={-1,0,1,-1,1,-1,0,1};

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

        Parser s = new Parser(System.in);
        OutputWriter out = new OutputWriter(System.out);
        int a=s.nextInt();
        int b=s.nextInt();
        int c=s.nextInt();
        int d=s.nextInt();
        long max=Long.MAX_VALUE;
        for (int i = 0; i <8 ; i++) {
            int x=X[i]+c;
            int y=Y[i]+d;
            long calc=Math.abs(x-a)+Math.abs(y-b);

            max=Math.min(calc,max);
        }
        System.out.println(2*max+8);

}}

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

/**
 * 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;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskM solver = new TaskM();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskM {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();
            int x = Math.abs(x1 - x2) + 1;
            int y = Math.abs(y1 - y2) + 1;
            if (x1 == x2) ++y;
            if (y1 == y2) ++x;
            out.println(2 * (x + y));
        }

    }
}

import java.util.Scanner;

public class Quadcopter {
    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 c = 0;
        int d = 0;
        if(x1<x2)c=(x2-x1+1)*2;
        else if(x1>x2) c=(x1-x2+1)*2;
        else c=(x1-x2+2)*2;

        if(y1<y2)d=(y2-y1+1)*2;
        else if(y1>y2)d=(y1-y2+1)*2;
        else d=(y1-y2+2)*2;
        System.out.println(c+d);
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int s1 = sc.nextInt(), s2 = sc.nextInt(), f1 = sc.nextInt(), f2 = sc.nextInt();
        int a = Math.abs(s1 - f1) + 1, b = Math.abs(s2 - f2) + 1;

        if (a == 1) {
            a ++;
        }
        if (b == 1) {
            b ++;
        }
        System.out.println(a * 2 + b * 2);
    }
}

//package com.company;

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

public class Main {

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

//        String str2 = null, str1 = null;
//        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
//            str1 = br.readLine();
//            str2 = br.readLine();
//        } catch (Exception e) {
//        }
//        String[] strAr1 = str1.split(" ");
//        String[] strAr2 = str2.split(" ");
//
//        int cx = Integer.parseInt(strAr1[0]);
//        int cy = Integer.parseInt(strAr1[1]);
//        int fx = Integer.parseInt(strAr2[0]);
//        int fy = Integer.parseInt(strAr2[1]);

        int cx = in.nextInt();
        int cy = in.nextInt();
        int fx = in.nextInt();
        int fy = in.nextInt();

        if (cx == fx) {
            System.out.println(
                    (Math.abs(cy-fy)*2)+6
            );
            return;
        }
        if (cy == fy) {
            System.out.println(
                    (Math.abs(cx-fx)*2)+6
            );
            return;
        }
        System.out.println(
                Math.abs(cx-fx)*2 + Math.abs(cy - fy)*2 + 4
        );
    }
}

/*

        String str2 = null;
        try (BufferedReader br = new BufferedReader(new InputStreamReader(System.in))) {
            str2 = br.readLine();
        } catch (Exception e) {
        }
        String[] strAr = str2.split(" ");

 */

import java.util.*;

public class Quadcopter {

   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 x = Math.abs(x1-x2)+1;
      int y = Math.abs(y1-y2)+1;
      if (y==1)
         y=2;
      if (x==1)
         x=2;
      System.out.println(2*x+2*y);
   }
}

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

public class M {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int x1 = sc.nextInt(), y1 = sc.nextInt(), x2 = sc.nextInt(), y2 = sc.nextInt();
		PrintWriter out = new PrintWriter(System.out);
		if (x1 == x2) {
			out.println(4 + 2 * (Math.abs(y1 - y2) + 1));
		} else if (y1 == y2) {
			out.println(4 + 2 * (Math.abs(x1 - x2) + 1));
		} else {
			out.println(2 * (Math.abs(x1 - x2) + 1) + 2 * (1 + Math.abs(y1 - y2)));
		}
		out.close();
	}
}

import java.io.*;
import java.util.*;
public class MyClass {
    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 ans=0;
        if(x1==x2)
         ans=4+(Math.abs(y1-y2)+1)*2;
         else if(y1==y2)
         ans=4+(Math.abs(x1-x2)+1)*2;
         else
          ans=(Math.abs(x1-x2)+Math.abs(y1-y2)+2)*2;

        System.out.println(ans);
    }
}

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

public class QuadcopterCompetition {
public static void main(String[] args) throws IOException {
	BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer t=new StringTokenizer(br.readLine());
	int x1=Integer.parseInt(t.nextToken());
	int y1=Integer.parseInt(t.nextToken());

	StringTokenizer t1=new StringTokenizer(br.readLine());
	int x2=Integer.parseInt(t1.nextToken());
	int y2=Integer.parseInt(t1.nextToken());

	int len=0;
	if(x1==x2){
		len=len+4;
	}
	else{
		len=len+(Math.abs(x1-x2)+1)*2;
	}

	if(y1==y2){
		len=len+4;
	}
	else{
		len=len+(Math.abs(y1-y2)+1)*2;
	}

	System.out.println(len);

}
}

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int x1=sc.nextInt();
		int y1=sc.nextInt();
		int x2=sc.nextInt();
		int y2=sc.nextInt();
		int ans=0;
		if(x1!=x2&&y1!=y2)
		{
			if(x1<x2&&y1<y2)
			{
				ans=(x2+1-x1)+(y2+1-y1);
				ans=ans*2;
			}
			else if(x1<x2&&y1>y2)
			{
				ans=(x2+1-x1)+(y1-y2+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1<y2)
			{
				ans=(x1-x2+1)+(y2-y1+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1>y2)
			{
				ans=(x1-x2+1)+(y1-y2+1);
				ans=ans*2;
			}
		}
		if(x1==x2&&y1!=y2)
		{
			ans=Math.abs(y1-y2)+1;
			ans=ans*2;
			ans=ans+4;
		}
		else if(x1!=x2&&y1==y2)
		{
			ans=Math.abs(x1-x2)+1;
			ans=ans*2;
			ans=ans+4;
		}
		System.out.println(ans);
	}

}

import java.util.*;
public class quadcopter
{
    public static void main(String []args){
        Scanner sc=new Scanner(System.in);
        int x1=sc.nextInt();
        int y1=sc.nextInt();sc.nextLine();
        int x2=sc.nextInt();
        int y2=sc.nextInt();
        int path=0;
        if(x1!=x2)
            path=1+Math.abs(x1-x2);
        else
            path+=2;
        if(y1!=y2)
            path+=1+Math.abs(y1-y2);
        else
            path+=2;
        System.out.println(2*path);
    }
}

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

public class Main {

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

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

	public static void main(String[] args) throws IndexOutOfBoundsException {
		InputStream inputStream = System.in;
		InputReader scn = new InputReader(inputStream);

		int x1 = scn.nextInt() + 100, y1 = scn.nextInt() + 100;
		int x2 = scn.nextInt() + 100, y2 = scn.nextInt() + 100;

		int dist = 0;

		if (x1 == x2 || y1 == y2) {
			if (x1 == y1 && x1 == y2 && x2 == y1 && x2 == y2) {
				dist = 8;
			} else if (x1 == x2) {
				dist = 2 * ((Math.abs(y1 - y2) + 1) + 2);
			} else if (y1 == y2) {
				dist = 2 * ((Math.abs(x1 - x2) + 1) + 2);
			}
		} else {
			x2 -= x1;
			y2 -= y1;
			x1 = 0;
			y1 = 0;
			dist = 2 * (Math.abs(x2) + Math.abs(y2) + 2);
		}

		System.out.println(dist);
	}
}

import java.util.Scanner;

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

        x2 = sc.nextInt();
        y2 = sc.nextInt();

        int xdiffer = Math.abs(x2-x1);
        int ydiffer = Math.abs(y2-y1);
        if(xdiffer == 0){
            xdiffer =1 ;
        }
        if(ydiffer == 0){
            ydiffer = 1;
        }
        int result =2*( xdiffer + ydiffer ) + 4;
        System.out.println(result);
}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main {

    static BufferedReader br;
    static StringTokenizer st;

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

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

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

    static Double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    static char nextChar() throws IOException {
        return (char) br.read();
    }

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

    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        //Scanner sc = new Scanner(System.in);
        int x1 = nextInt();
        int y1 = nextInt();
        int x2 = nextInt();
        int y2 = nextInt();
        if(x1 == x2){
            x2++;
        }else if(y1 == y2){
            y2++;
        }
        System.out.println(Math.abs(x2 - x1) * 2 + Math.abs(y2 - y1) * 2 + 4);

    }
}

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner cin = new Scanner(System.in);
        int x1, y1, x2, y2;
        x1 = cin.nextInt();
        y1 = cin.nextInt();
        x2 = cin.nextInt();
        y2 = cin.nextInt();
        int ans = 2* (Math.abs(x1-x2)+1 + Math.abs(y2-y1) + 1);
        if(x1 == x2 && y1 == y2) System.out.println("0");
        else if(x1 == x2 || y1 == y2){
            ans += 2;
            System.out.println(ans);
        }else{
            System.out.println(ans);
        }
    }
}

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

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

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

		 	if(x1== x2)
		 	{
		 		x1++;
		 	}

		 	if(y1==y2)
		 	{
		 		y1++;
		 	}
		out.println(2*(Math.abs(x1-x2)+Math.abs(y1-y2))+4);
	 }

}

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

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

    static class MQuadcopterCompetition {
        PrintWriter out;
        InputReader in;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            this.out = out;
            this.in = in;
            int x1 = ni();
            int y1 = ni();
            int x2 = ni();
            int y2 = ni();
            int dist = 0;
            if (x1 <= x2 && y1 > y2)
                dist = Math.abs(x2 + 1 - x1) + Math.abs(y2 + 1 - y1) + 4 + Math.abs(x2 - 1 - x1) + Math.abs(y2 - 1 - y1);
            else if (x1 <= x2 && y1 <= y2)
                dist = Math.abs(x2 - 1 - x1) + Math.abs(y2 + 1 - y1) + 4 + Math.abs(x2 + 1 - x1) + Math.abs(y2 - 1 - y1);
            else if (x1 >= x2 && y1 >= y2)
                dist = Math.abs(x2 + 1 - x1) + Math.abs(y2 - 1 - y1) + 4 + Math.abs(x2 - 1 - x1) + Math.abs(y2 + 1 - y1);
            else
                dist = Math.abs(x2 - 1 - x1) + Math.abs(y2 + 1 - y1) + 4 + Math.abs(x2 + 1 - x1) + Math.abs(y2 - 1 - y1);
            pn(dist);
        }

        int ni() {
            return in.nextInt();
        }

        void pn(long zx) {
            out.println(zx);
        }

    }

    static 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 UnknownError();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

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

        public String next() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }

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

    }
}

//package CodeForces_practice;

import java.util.Scanner;

public class M883 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner s=new Scanner(System.in);
		int a=s.nextInt();
		int b=s.nextInt();
		a=Math.abs(a-s.nextInt());
		b=Math.abs(b-s.nextInt());
		int ans=0;
		if(a>1||b>1) ans=Math.abs(a-1)+Math.abs(b)+Math.abs(b-1)+Math.abs(a)+6;
		else ans=8;
		System.out.println(ans);
	}

}

import java.util.Scanner;

public class FirstTask {
	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 transX = (x1 == x2) ? (4) : (2 * (Math.abs(x2 - x1) + 1));
		int transY = (y1 == y2) ? (4) : (2 * (Math.abs(y2 - y1) + 1));

		System.out.println(transX + transY);
	}
}

import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Stack;

public class B348 {

	/**
	 * @param args
	 */

	static long min;
	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 ans=0;

	if(x1==x2)
	ans+=4;
	else if(y1==y2)
	ans+=4;

	if(x1!=x2)
	ans+=2*Math.abs(x1-x2)+2;

	if(y1!=y2)
		ans+=2*Math.abs(y1-y2)+2;

	System.out.println(ans);

	}
}

import java.math.BigInteger;
import java.util.Scanner;
import java.util.*;
import java.io.*;//1 1 2 3 3        2 2 4 8 8
public class r{
public static void main(String[] args)throws IOException{
    File f=new File("/home/ujjwal/Desktop/new.txt");
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//BufferedWriter output = new BufferedWriter(new OutputStreamWriter(System.out));
Scanner sc=new Scanner(System.in);
int x1=sc.nextInt(),y1=sc.nextInt(),x2=sc.nextInt(),y2=sc.nextInt(),temp=0,temp2=0;
if(Math.abs(x1-x2)!=0){
temp=(Math.abs(x1-x2)+1);
temp+=temp;//10
}
else{
temp=4;
}
if(Math.abs(y1-y2)!=0){
temp2=(Math.abs(y1-y2))+1;
temp2+=temp2;
}
else{
temp2=4;
}
System.out.println(temp+temp2);

}

}

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

     //--------------->>>>IF YOU ARE HERE FOR QUICKSORT HACK THEN SORRY NO HACK FOR YOU<<<-------------------

public class a{
     static long[] count,count1,count2;
     static Node[] nodes;
     static long[] arr;
     static int[] dp;
     static char[] ch,ch1;
     static long[] darr,farr;
     static char[][] mat,mat1;
     static long x,h;
     static long maxl;
     static double dec;
     static long mx = (long)1e9+7;
     static String s;
     static long minl;
     static int start_row;
     static int start_col;
     static int end_row;
     static int end_col;
     static long mod = (long)1e7+7;
     // static int minl = -1;
     // static long n;
     static int n,n1,n2;
     static long a;
     static long b;
     static long c;
     static long d;
     static long y,z;
     static int m;
     static int k;
     static String[] str,str1;
     static Set<Long> set,set1,set2;
     static SortedSet<Long> ss;
     static List<Integer> list,list1,list2,list3;
     static LinkedList<Node> ll;
     static Map<Integer,List<Integer>> map,map1;
     static StringBuilder sb,sb1,sb2;
     static int index;
     static int[] dx = {0,-1,0,1,-1,1,-1,1};
     static int[] dy = {-1,0,1,0,-1,-1,1,1};

     // public static void solve(){

     //    FastScanner sc = new FastScanner();
     //    // int t = sc.nextInt();
     //    int t = 1;
     //    for(int tt = 0 ; tt < t ; tt++){
     //        int n = sc.nextInt();
     //        int m = sc.nextInt();
     //        int prev = 0;

     //        for(int i = 0 ; i < n ; i++){
     //           int s = sc.nextInt();
     //           int e = sc.nextInt();
     //           if(s > prev){
     //                System.out.println("NO");
     //                return;
     //           }
     //            prev = Math.max(prev,e);
     //        }
     //        if(prev == m)
     //            System.out.println("YES");
     //        else
     //            System.out.println("NO");

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

     // }

     //--------------->>>>IF YOU ARE HERE FOR QUICKSORT HACK THEN SORRY NO HACK FOR YOU<<<-------------------

     public static void solve(){

        if(y == b){
            System.out.println((2*Math.abs(x-a) + 4)+2);
            return;
        }

        if(x == a){
            System.out.println(4 + 2*Math.abs(y-b)+2);
            return;
        }

        System.out.println((2*Math.abs(x-a) + 2*Math.abs(y-b))+4);

     }

     public static void main(String[] args) {

            FastScanner sc = new FastScanner();
            // Scanner sc = new Scanner(System.in);
            // int t = sc.nextInt();
            int t = 1;
            // int l = 1;
            while(t > 0){

                // n = sc.nextInt();
                // n = sc.nextLong();
                a = sc.nextLong();
                b = sc.nextLong();
                // c = sc.nextLong();
                // d = sc.nextLong();

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

                // n = sc.nextLong();
                // n = sc.nextInt();
                // n1 = sc.nextInt();

                // m = sc.nextInt();

                // k = sc.nextInt();
                // s = sc.next();

                // ch = sc.next().toCharArray();
                // ch1 = sc.next().toCharArray();

                // arr = new int[n];
                // for(int i = 0 ; i < n ; i++){
                //     arr[i] = sc.nextInt();
                // }
                // // m = n;
                // darr = new long[n];
                // for(int i = 0; i < n ; i++){
                //     darr[i] = sc.nextLong();
                // }

                // farr = new int[n];
                // for(int i = 0; i < n ; i++){
                //     farr[i] = sc.nextInt();
                // }

                // mat = new char[n][m];
                // for(int i = 0 ; i < n ; i++){
                //     String s = sc.next();
                //     for(int j = 0 ; j < m ; j++){
                //         mat[i][j] = s.charAt(j);
                //     }
                // }

                // str = new String[n];
                // for(int i = 0 ; i < n ; i++)
                //     str[i] = sc.next();

                // nodes = new Node[n];
                // for(int i = 0 ; i < n ;i++)
                //     nodes[i] = new Node(sc.nextInt(),sc.nextInt());

                // System.out.println(solve()?"YES":"NO");
                 solve();
                 // System.out.println(solve());
                 t -= 1;
            }

     }

    public static int log(long n){

         if(n == 0 || n == 1)
             return 0;

         if(n == 2)
             return 1;

         double num = Math.log(n);
         double den = Math.log(2);

         if(den == 0)
             return 0;

         return (int)(num/den);
     }

    public static boolean isPrime(long n) {
    // Corner cases
        if (n <= 1)
            return false;

        if (n <= 3)
            return true;

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n%2 == 0 || n%3 == 0)
            return false;

        for (int i=5; i*i<=n; i=i+6)
            if (n%i == 0 || n%(i+2) == 0)
               return false;

        return true;
    }

     public static long gcd(long a,long b){

        if(b%a == 0){
            return a;
        }
        return gcd(b%a,a);

     }

     // public static void swap(int i,int j){
     //     long temp = arr[j];
     //     arr[j] = arr[i];
     //     arr[i] = temp;
     // }

    static final Random random=new Random();

    static void ruffleSort(long[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n);
            long temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static class Node{
        Integer first;
        Integer second;
        Node(Integer f,Integer s){
            this.first = f;
            this.second = s;
        }
    }

     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 Main{
    public static void main(String[] args){
        Scanner cin = new Scanner(System.in);
        int x1, y1, x2, y2;
        x1 = cin.nextInt();
        y1 = cin.nextInt();
        x2 = cin.nextInt();
        y2 = cin.nextInt();
        int ans = 2* (Math.abs(x1-y1)+1 + Math.abs(x2-y2) + 1);
        if(x1 == x2 && y1 == y2) System.out.println("0");
        else if(x1 == x2 || y1 == y2){
            ans += 2;
            System.out.println(ans);
        }else{
            System.out.println(ans);
        }
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
public class smack {
	InputStream is;
	PrintWriter out;
	int dx[]= {0,0,1,-1},dy[]={+1,-1,0,0};
	static long mod=pow(10,9)+7;
	void solve()
	{
		int x1=ni();
		int y1=ni();
		int x2=ni();
		int y2=ni();
		int dist=Math.abs(x1-x2)+Math.abs(y1-y2);
		if(dist==1)
			out.println("8");
		else
			out.println(2*dist-2+6);
	}
	int small[];
	void pre(int n)
	{
		small=new int[n+1];
		for(int i=2;i*i<=n;i++)
		{
			for(int j=i;j*i<=n;j++)
			{
				if(small[i*j]==0)
					small[i*j]=i;
			}
		}
		for(int i=0;i<=n;i++)
		{
			if(small[i]==0)
				small[i]=i;
		}
	}
	static long d, x, y;
	void extendedEuclid(long A, long B) {
	    if(B == 0) {
	        d = A;
	        x = 1;
	        y = 0;
	    }
	    else {
	        extendedEuclid(B, A%B);
	        long temp = x;
	        x = y;
	        y = temp - (A/B)*y;
	    }
	}
	long modInverse(long A,long M) //A and M are coprime
	{
	    extendedEuclid(A,M);
	    return (x%M+M)%M;    //x may be negative
	}
	public static void mergeSort(int[] arr, int l ,int r){
		if((r-l)>=1){
			int mid = (l+r)/2;
			mergeSort(arr,l,mid);
			mergeSort(arr,mid+1,r);
			merge(arr,l,r,mid);
		}
	}
	public static void merge(int arr[], int l, int r, int mid){
		int n1 = (mid-l+1), n2 = (r-mid);
		int left[] = new int[n1];
		int right[] = new int[n2];
		for(int i =0 ;i<n1;i++) left[i] = arr[l+i];
		for(int i =0 ;i<n2;i++) right[i] = arr[mid+1+i];
		int i =0, j =0, k = l;
		while(i<n1 && j<n2){
			if(left[i]>right[j]){
				arr[k++] = right[j++];
			}
			else{
				arr[k++] = left[i++];
			}
		}
		while(i<n1) arr[k++] = left[i++];
		while(j<n2) arr[k++] = right[j++];
	}
	public static void mergeSort(long[] arr, int l ,int r){
		if((r-l)>=1){
			int mid = (l+r)/2;
			mergeSort(arr,l,mid);
			mergeSort(arr,mid+1,r);
			merge(arr,l,r,mid);
		}
	}
	public static void merge(long arr[], int l, int r, int mid){
		int n1 = (mid-l+1), n2 = (r-mid);
		long left[] = new long[n1];
		long right[] = new long[n2];
		for(int i =0 ;i<n1;i++) left[i] = arr[l+i];
		for(int i =0 ;i<n2;i++) right[i] = arr[mid+1+i];
		int i =0, j =0, k = l;
		while(i<n1 && j<n2){
			if(left[i]>right[j]){
				arr[k++] = right[j++];
			}
			else{
				arr[k++] = left[i++];
			}
		}
		while(i<n1) arr[k++] = left[i++];
		while(j<n2) arr[k++] = right[j++];
	}
	 static class Pair implements Comparable<Pair>{

	       int x,y,k;
	       int i,dir;
	       long cost;
		Pair (int x,int y){
			this.x=x;
			this.y=y;
		}
		public int compareTo(Pair o) {
				return this.y-o.y;
		}

		public String toString(){
			return x+" "+y+" "+k+" "+i;}
		public boolean equals(Object o) {
			if (o instanceof Pair) {
				Pair p = (Pair)o;
				return p.x == x && p.y == y;
			}
			return false;
		}
		public int hashCode() {
			return new Long(y).hashCode()*31 + new Long(x).hashCode() ;
		}
	}
	    public static boolean isPal(String s){
	        for(int i=0, j=s.length()-1;i<=j;i++,j--){
	                if(s.charAt(i)!=s.charAt(j)) return false;
	        }
	        return true;
	    }
	    public static String rev(String s){
			StringBuilder sb=new StringBuilder(s);
			sb.reverse();
			return sb.toString();
	    }

	    public static long gcd(long x,long y){
		if(x%y==0)
			return y;
		else
			return gcd(y,x%y);
	    }

	    public static int gcd(int x,int y){
		if(y==0)
			return x;
		else
			return gcd(y,x%y);
	    }

	    public static long gcdExtended(long a,long b,long[] x){

	        if(a==0){
	            x[0]=0;
	            x[1]=1;
	            return b;
	        }
	        long[] y=new long[2];
	        long gcd=gcdExtended(b%a, a, y);

	        x[0]=y[1]-(b/a)*y[0];
	        x[1]=y[0];

	        return gcd;
	    }

	    public static int abs(int a,int b){
		return (int)Math.abs(a-b);
	    }

	    public static long abs(long a,long b){
		return (long)Math.abs(a-b);
	    }

	    public static int max(int a,int b){
		if(a>b)
			return a;
		else
			return b;
	    }

	    public static int min(int a,int b){
		if(a>b)
			return b;
		else
			return a;
	    }

	    public static long max(long a,long b){
		if(a>b)
			return a;
		else
			return b;
	    }

	    public static long min(long a,long b){
		if(a>b)
			return b;
		else
			return a;
	    }

	    public static long pow(long n,long p,long m){
		 long  result = 1;
		  if(p==0)
		    return 1;
		if (p==1)
		    return n;
		while(p!=0)
		{
		    if(p%2==1)
		        result *= n;
		    if(result>=m)
		    result%=m;
		    p >>=1;
		    n*=n;
		    if(n>=m)
		    n%=m;
		}
		return result;
	    }

	    public static long pow(long n,long p){
		long  result = 1;
		  if(p==0)
		    return 1;
		if (p==1)
		    return n;
		while(p!=0)
		{
		    if(p%2==1)
		        result *= n;
		    p >>=1;
		    n*=n;
		}
		return result;
	    }
	    public static void debug(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
	    void run() throws Exception {
			is = System.in;
			out = new PrintWriter(System.out);
			solve();
			out.flush();
		}

	    public static void main(String[] args) throws Exception {
			new Thread(null, new Runnable() {
				public void run() {
					try {
						new smack().run();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}, "1", 1 << 26).start();
		}
	    private byte[] inbuf = new byte[1024];
		public int lenbuf = 0, ptrbuf = 0;

		private int readByte() {
			if (lenbuf == -1)
				throw new InputMismatchException();
			if (ptrbuf >= lenbuf) {
				ptrbuf = 0;
				try {
					lenbuf = is.read(inbuf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (lenbuf <= 0)
					return -1;
			}
			return inbuf[ptrbuf++];
		}

		private boolean isSpaceChar(int c) {
			return !(c >= 33 && c <= 126);
		}

		private int skip() {
			int b;
			while ((b = readByte()) != -1 && isSpaceChar(b));
			return b;
		}

		private double nd() {
			return Double.parseDouble(ns());
		}

		private char nc() {
			return (char) skip();
		}

		private String ns() {
			int b = skip();
			StringBuilder sb = new StringBuilder();
			while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
				sb.appendCodePoint(b);
				b = readByte();
			}
			return sb.toString();
		}

		private char[] ns(int n) {
			char[] buf = new char[n];
			int b = skip(), p = 0;
			while (p < n && !(isSpaceChar(b))) {
				buf[p++] = (char) b;
				b = readByte();
			}
			return n == p ? buf : Arrays.copyOf(buf, p);
		}

		private char[][] nm(int n, int m) {
			char[][] map = new char[n][];
			for (int i = 0; i < n; i++)
				map[i] = ns(m);
			return map;
		}

		private int[] na(int n) {
			int[] a = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = ni();
			return a;
		}

		private int ni() {
			int num = 0, b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

		private long nl() {
			long num = 0;
			int b;
			boolean minus = false;
			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
				;
			if (b == '-') {
				minus = true;
				b = readByte();
			}

			while (true) {
				if (b >= '0' && b <= '9') {
					num = num * 10 + (b - '0');
				} else {
					return minus ? -num : num;
				}
				b = readByte();
			}
		}

}

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

public class Main {

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

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

	public static void main(String[] args) throws IndexOutOfBoundsException {
		InputStream inputStream = System.in;
		InputReader scn = new InputReader(inputStream);

		int x1 = scn.nextInt() + 100, y1 = scn.nextInt() + 100;
		int x2 = scn.nextInt() + 100, y2 = scn.nextInt() + 100;

		int dist = 0;

		if (x1 == x2 || y1 == y2) {
			if (x1 == y1) {
				dist = 8;
			} else if (x1 == x2) {
				dist = 2 * ((Math.abs(y1 - y2) + 1) + 2);
			} else if (y1 == y2) {
				dist = 2 * ((Math.abs(x1 - x2) + 1) + 2);
			}
		} else {
			x2 -= x1;
			y2 -= y1;
			x1 = 0;
			y1 = 0;
			dist = 2 * (Math.abs(x2) + Math.abs(y2) + 2);
		}

		System.out.println(dist);
	}
}

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

public class Main {

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

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

	public static void main(String[] args) throws IndexOutOfBoundsException {
		InputStream inputStream = System.in;
		InputReader scn = new InputReader(inputStream);

		int x1 = scn.nextInt() + 100, y1 = scn.nextInt() + 100;
		int x2 = scn.nextInt() + 100, y2 = scn.nextInt() + 100;

		int dist = 0;

		if (x1 == x2 || y1 == y2) {
			if (x1 == y1 && x1 == y2) {
				dist = 8;
			} else if (x1 == x2) {
				dist = 2 * ((Math.abs(y1 - y2) + 1) + 2);
			} else if (y1 == y2) {
				dist = 2 * ((Math.abs(x1 - x2) + 1) + 2);
			}
		} else {
			x2 -= x1;
			y2 -= y1;
			x1 = 0;
			y1 = 0;
			dist = 2 * (Math.abs(x2) + Math.abs(y2) + 2);
		}

		System.out.println(dist);
	}
}

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

import java.util.Scanner;

/**
 *
 * @author rokk-
 */
public class ACM2017M {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner scanner = new Scanner(System.in);
        int rx = scanner.nextInt();
        int ry = scanner.nextInt();
        int fx = scanner.nextInt();
        int fy = scanner.nextInt();
        int dx = rx-fx;
        if (dx==0){
            dx = 1;
        }
        dx = Math.abs(dx)+1;
        int dy = ry-fy;
        if (dx==0){
            dx = 1;
        }
        dy = Math.abs(dy)+1;
        System.out.println(dx*2+dy*2);
    }

}

import java.util.Scanner;

/**
 * Created by mahdiya on 11/6/2017.
 */
public class cfm {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int x = input.nextInt();
        int y = input.nextInt();
        int xf = input.nextInt();
        int yf = input.nextInt();
        int dis = 0;

        if (xf >= x && yf >= y){
            dis += yf - y + 1;
            int ny = yf +1;
            dis += xf - x +1;
            int nx = xf + 1;
            dis += ny - y;
            dis += nx - x;
        }else if (xf >= x && yf <= y){
            dis += Math.abs(xf - x) + 1;
            int nx = xf + 1;
            dis += Math.abs(yf - y) + 1;
            int ny = yf - 1;
            dis += Math.abs(x - nx);
            dis += Math.abs(y - ny);
        }else if (xf <= x && yf >= y){
            dis += Math.abs(yf - y) + 1;
            int ny = yf +1;
            dis += Math.abs(xf - x) + 1;
            int nx = xf - 1;
            dis += Math.abs(y - ny);
            dis += Math.abs(x - nx);
        }else {
            dis += Math.abs(xf - x) + 1;
            int nx = xf - 1;
            dis += Math.abs(yf - y) + 1;
            int ny = yf - 1;
            dis += Math.abs(x - nx);
            dis += Math.abs(y - ny);
        }
        System.out.println(dis);
    }
}

import java.util.Scanner ;
public class M883_QuadCopterCompititon {

	public static void main(String[] args) {
		Scanner ss =new Scanner (System.in)  ;
		int x1 ,x2,y1,y2 ;
		x1 = ss.nextInt() ;
		y1 = ss.nextInt() ;
		x2 = ss.nextInt() ;
		y2 = ss.nextInt() ;
		int cir =2* ((int )(Math.abs(x1-x2) + (int ) (y1-y2) + 2 ))  ;
		if (x1== x2 || y1 == y2 ) {
			cir+=2 ;

		}
		System.out.println(cir );
	}

}

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

public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{
	Scanner sc=new Scanner(System.in);

	int x1=sc.nextInt();
	int y1=sc.nextInt();
	int x2=sc.nextInt();
	int y2=sc.nextInt();
	int ans=0;

	if(x1==x2)ans=2*2+(Math.abs(y1-y2)+1)*2;
	else if(y1==y2)ans=2*2+(Math.abs(x1-x2)*2);
	else ans=(Math.abs(x1-x2)+1)*2+(Math.abs(y1-y2)+1)*2;

	System.out.println(ans);
	}

}

    		import java.awt.List;
    		import java.io.*;
    		import java.util.*;

    		/*
    		 *
    		 * daiict
    		 *
    		 *
    		 *
    		 */

    		public class prac {
    			FastScanner in;
    			PrintWriter out;

    			static ArrayList[] adj;

    			static int n;
    			static int m;

    			static int[] dp1;
    			static int[] dp2;
    			static int color[];
    			static int visited[];
    			static int[][] arr;
    			static int[][] brr;
    			static int[][] ans;
    			static int array[];
    			static int pref[];
    			static int tree[];
    			static int maxval = 32;
    			static HashSet<Integer> set;
    			static int sum = 0;
    		//for dfs do not delete
    			static int dir[][] ={{1,0},{0,1},{0,-1},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};

    			static long[] seg;
    			static long count = 1;
    			static long mod = (long)1e9 + 7;
    			static HashMap<String,HashSet<String>> graph;
    			static HashMap<String,String> best;
    			static HashSet<String> vis;

    			static class Pair implements Comparable<Pair>
    		    {
    				int x;int y;

    		        Pair(int l, int m) {

    		        	this.x = l;
    		            this.y = m;

    		        }

    		        public int compareTo(Pair p) {
    		            if (this.x == p.x) {
    		                return (int)(this.y-p.y);
    		            }
    		            return (int)(this.x - p.x);
    		        }

    		        public String toString(){
    		        	return x + " " + y;
    		        }

    		        public boolean equals(Object o){
    		        	if(o instanceof Pair){
    		        		Pair a = (Pair)o;

    		        		return this.x == a.x;
    		        	}

    		        	return false;
    		        }

    		        public int hashCode(){
    		        	return new Long(x).hashCode()*31 + new Long(y).hashCode();
    		        }

    		    }

    			public static int gcd(int a, int b) {
    				if (b == 0) return a;
    				return gcd(b, a%b);
    			}

    			void build(int n) {  // build the tree
    				  for (int i = n - 1; i > 0; --i) seg[i] = Math.min(seg[i<<1],seg[i<<1|1]);
    				}

    			public static void modify(int p, long val,int n) {  // set value at position p
    				  for (seg[p += n] = val; p > 1; p >>= 1) seg[p>>1] = Math.min(seg[p],seg[p^1]);
    				}

    				long query(int l, int r,int n) {  // sum on interval [l, r)
    				  long res = Long.MAX_VALUE;
    				  for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
    				    if ((l&1) == 1) res = (long) Math.min(res,seg[l++]);
    				    if ((r&1) == 1) res = (long)Math.min(res,seg[--r]);
    				  }
    				  return res;
    				}

    			public static void update(int x,int val){
    				while(x<=maxval){
    					tree[x] += val;
    					x = (x&-x);
    				}
    			}

    			public static int read(int idx){
    				int sum = 0;

    				while(idx>= 0){
    					sum += tree[idx];
    					idx -= (idx&(-idx));
    				}

    				return sum;
    			}

    		    void solve() throws NumberFormatException, IOException {

    		    //	Scanner in = new Scanner(System.in);
    		    	StringBuilder sb = new StringBuilder();

    		    	int a = in.nextInt();
    		    	int b = in.nextInt();

    		    	int c = in.nextInt();
    		    	int d = in.nextInt();

    		    	int ans = Math.abs(a-c) + Math.abs(b-d);
    		    	ans = ans*2;

    		    	if(ans == 2){
    		    		ans = 8;
    		    	}else{

        		    	if(a == c || b == d){
        		    		ans += 8;
        		    	}else{
        		    		ans += 4;
        		    	}
    		    	}

    		    	out.println(ans);
    		    }

    		    public static int floor(int[] arr,int d){
    		    	int c = -1;
    		    	int l = 0;
    		    	int r = arr.length-1;

    		    	while(l<r){
    		    		int mid = (l+r)/2;
    		    		//System.out.println(l + " " + r+" " +mid + " "+arr[mid]);
    		    		if(arr[mid] >= d){
    		    			r = mid-1;
    		    		}else{
    		    			l = mid;
    		    		}

    		    		if(l == r-1){
    		    			if(arr[r] == d){
    		    				return l;
    		    			}else{
    		    				return r;
    		    			}
    		    		}

    		    		c = l;

    		    	}

    		    	return c;
    		    }

    		    public static int as(long n){
    		    	int c = 0;

    		    	while(n!=0){
    		    		c += n%10;
    		    		n /= 10;
    		    	}
    		    	return c;
    		    }

    		    public static int Floor(int arr[], int low, int high, int x)
    		    {
    		        // If low and high cross each other
    		        if (low > high)
    		            return -1;

    		        // If last element is smaller than x
    		        if (x >= arr[high])
    		            return high;

    		        // Find the middle point
    		        int mid = (low+high)/2;

    		        // If middle point is floor.
    		        if (arr[mid] == x)
    		            return mid;

    		        // If x lies between mid-1 and mid
    		        if (mid > 0 && arr[mid-1] <= x && x < arr[mid])
    		            return mid-1;

    		        // If x is smaller than mid, floor must be in
    		        // left half.
    		        if (x < arr[mid])
    		            return Floor(arr, low, mid-1, x);

    		        // If mid-1 is not floor and x is greater than
    		        // arr[mid],
    		        return Floor(arr, mid+1, high, x);
    		    }

    		    public static String reverse(String s){

    		    	String ans = "";

    		    	for(int i = s.length()-1;i>=0;i--){
    		    		ans += s.charAt(i);
    		    	}

    		    	return ans;

    		    }

    		    public static long sum(long x){
    		    	return x<10?x:x%10 + sum(x/10);
    		    }

    			public static long gcd(long x, long y) {
    				if (x == 0)
    					return y;
    				else
    					return gcd( y % x,x);
    			}
    			static long inv(long x , long mod)
    			{
    				long r,y;
    				for(r=1,y=mod-2;y!=0;x=x*x%mod,y>>=1)
    				{
    					if((y&1)==1)
    						r=r*x%mod;

    				}
    				return r;
    			}

    			public static long pow(long x,long y,long n){
    				if(y==0)
    					return 1%n;
    				if(y%2==0){
    					long z=pow(x,y/2,n);
    					return (z*z)%n;
    				}
    				return ((x%n)*pow(x,y-1,n))%n;
    			}

    			public static boolean isPrime(int n) {
    				// Corner cases
    				if (n <= 1)
    					return false;
    				if (n <= 3)
    					return true;

    				// This is checked so that we can skip
    				// middle five numbers in below loop
    				if (n % 2 == 0 || n % 3 == 0)
    					return false;

    				for (int i = 5; i * i <= n; i = i + 6)
    					if (n % i == 0 || n % (i + 2) == 0)
    						return false;

    				return true;
    			}

    			void run() throws NumberFormatException, IOException {
    				in = new FastScanner();
    				out = new PrintWriter(System.out);

    				solve();

    				out.close();
    			}

    			class FastScanner {
    				BufferedReader br;
    				StringTokenizer st;

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

    				String next() {
    					while (st == null || !st.hasMoreTokens()) {
    						try {
    							st = new StringTokenizer(in.br.readLine());
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    					return st.nextToken();
    				}

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

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

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

    			public static void main(String[] args) throws NumberFormatException, IOException {
    				new prac().run();
    			}
    		}

import java.util.Scanner;

/**
 * Created by makarfi on 10/21/17.
 */
public class M {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

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

        if ((x1 < 0 && x2 > 0) || (x1 > 0 && x2 < 0)) ans += x1 + x2;
        else ans += Math.abs(x1-x2);
        if ((y1 < 0 && y2 > 0) || (y1 > 0 && y2 < 0)) ans += y1 + y2;
        else ans += Math.abs(y1-y2);

        ans *= 2;

        if (x1 == x2 || y1 == y2) ans += 2;
        ans += 4;

        System.out.println(ans);
    }
}

import java.util.*;
public class quadcopterCompetition
{
    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 path=0;
        if(((x2-x1)==0)||((y2-y1)==0))//when points are in on a line parallel to x or y axes
        {
            if((x2-x1)==0)
            {
                if((y1*y2)>0)
                {
                    path+=Math.abs(Math.abs(y2)-Math.abs(y1))+1;
                    path+=2;
                }
                else
                {
                    path+=Math.abs(y2)+Math.abs(y1)+1;
                    path+=2;
                }
                path*=2;
            }
            else
            {
                if((x1*x2)>0)
                {
                    path+=Math.abs(Math.abs(x2)-Math.abs(x1))+1;
                    path+=2;
                }
                else
                {
                    path+=Math.abs(x2)+Math.abs(x1)+1;
                    path+=2;
                }
                path*=2;
            }

        }
        else if(((x1*x2)>0)&&((y1*y2)>0))//when points are in the same quadrant
        {
            path+=Math.abs(Math.abs(x2)-Math.abs(x1))+1;
            path+=Math.abs(Math.abs(y2)-Math.abs(y1))+1;
            path*=2;
        }
        else if(((x1*x2)<0)&&((y1*y2)<0))//when points are in either 1st 3rd or 2nd 4th quadrant
        {
            path+=Math.abs(x1)+Math.abs(x2)+1;
            path+=Math.abs(y1)+Math.abs(y2)+1;
            path*=2;
        }

        else
        {
            if((y1*y2)<0)
            {
                path+=x2-x1+1;
                path+=Math.abs(y2)+Math.abs(y1)+1;
                path*=2;
            }
            else
            {
                path+=y2-y1+1;
                path+=Math.abs(x2)+Math.abs(x1)+1;
                path*=2;
            }
        }
        System.out.println(path);
    }
}

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

public class Main {

    static class TaskA {

        private void solve(int test, FastScanner in, PrintWriter out) {
            int x1 = in.nextInt();
            int y1 = in.nextInt();
            int x2 = in.nextInt();
            int y2 = in.nextInt();

            int dist = (Math.abs(Math.abs(x2) - Math.abs(x1)) + Math.abs(Math.abs(y2) - Math.abs(y1))) * 2;
            if (x1 == x2 || y1 == y2) {
                out.println(dist + 6);
            } else {
                out.println(dist + 4);
            }
        }

    }

    public static void main(String[] args) throws IOException {
        FastScanner in = new FastScanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
//        FastScanner in = new FastScanner("1.in");
//        PrintWriter out = new PrintWriter(new FileWriter("1.out"));
        new TaskA().solve(1, in, out);
        out.close();
    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer token;

        public FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastScanner(String s) {
            try {
                br = new BufferedReader(new FileReader(s));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

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

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

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

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

import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
public class Main implements Runnable {

    public static void main(String[] args) {
        new Thread(null, new Main(), "Check2", 1 << 28).start();// to increse stack size in java
    }
    void init(ArrayList <Integer> adj[], int n){
        for(int i=0;i<=n;i++)adj[i]=new ArrayList<>();
    }
    static long mod = (long) (1e9+7);
    public void run() {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

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

        if(x1-x2!=0&&y1-y2!=0) {
            int val = abs(x1 - x2) + (y1 - y2) + 2;
            val *= 2;
            w.println(val);
        }
        else if(x1-x2==0){

            w.println(4+2*(abs(y1-y2))+2);
        }
        else if(y1-y2==0){

            w.println(4+2*(abs(x1-x2))+2);
        }
        else
            w.println(0);

        w.close();
    }

    class pair2  {

        int a,b;
        pair2(int a,int b){
            this.a=a;
            this.b=b;
        }
    }

    static void diji(int s, long dist[], ArrayList<pair> adj[]) {
        dist[s] = 0;
        PriorityQueue<pair> q = new PriorityQueue<>(new cmp());
        q.add(new pair(s, 0));
        while (!q.isEmpty()) {
            pair p1 = q.poll();
            for (pair ne: adj[p1.a]) {

                if ((long) p1.b + (long) ne.b < dist[ne.a]) {
                    dist[ne.a] = (long) p1.b + (long) ne.b;
                    pair p2 = new pair(ne.a, dist[ne.a]);
                    q.add(p2);

                }

            }
        }

    }
    static class cmp implements Comparator<pair>{

        public  int compare(pair o1,pair o2)
        {
            return o1.b<o2.b?-1:o1.b>o2.b?1:0;
        }

    }

    static class pair {
        int a;
        long b;
        pair(int a,long b){
            this.a=a;
            this.b=b;
        }
        public boolean equals(Object obj) {      //  override equals method for object to remove tem from arraylist and sets etc.......
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            pair other = (pair) obj;
            if (b!= other.b||a!=other.a)
                return false;
            return true;
        }
    }

    static long modinv(long a,long b)
    {
        long p=power(b,mod-2);

        p=a%mod*p%mod;
        p%=mod;

        return p;

    }

    static long power(long x,long y){
        if(y==0)return 1%mod;
        if(y==1)return x%mod;

        long res=1;
        x=x%mod;
        while(y>0){

            if((y%2)!=0){
                res=(res*x)%mod;
            }

            y=y/2;
            x=(x*x)%mod;
        }

        return res;

    }
    static  long gcd(long a,long b){

        if(b==0)return a;
        return gcd(b,a%b);
    }

    static  void sev(int a[],int n){

        for(int i=2;i<=n;i++)a[i]=i;
        for(int i=2;i<=n;i++){

            if(a[i]!=0){
                for(int j=2*i;j<=n;){

                    a[j]=0;
                    j=j+i;
                }
            }

        }

    }

    static 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 String nextLine()
        {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
        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 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 double nextDouble()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

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

            return res.toString();
        }

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

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

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

}

import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
public class Main implements Runnable {

    public static void main(String[] args) {
        new Thread(null, new Main(), "Check2", 1 << 28).start();// to increse stack size in java
    }
    void init(ArrayList <Integer> adj[], int n){
        for(int i=0;i<=n;i++)adj[i]=new ArrayList<>();
    }
    static long mod = (long) (1e9+7);
    public void run() {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

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

        if(x1-x2!=0&&y1-y2!=0) {
            int val = 2*(abs(x1 - x2)+1) + 2*((y1 - y2) + 1);
            w.println(val);
        }
        else if(x1-x2==0){

            w.println(4+2*(abs(y1-y2))+2);
        }
        else if(y1-y2==0){

            w.println(4+2*(abs(x1-x2))+2);
        }
        else
            w.println(0);

        w.close();
    }

    class pair2  {

        int a,b;
        pair2(int a,int b){
            this.a=a;
            this.b=b;
        }
    }

    static void diji(int s, long dist[], ArrayList<pair> adj[]) {
        dist[s] = 0;
        PriorityQueue<pair> q = new PriorityQueue<>(new cmp());
        q.add(new pair(s, 0));
        while (!q.isEmpty()) {
            pair p1 = q.poll();
            for (pair ne: adj[p1.a]) {

                if ((long) p1.b + (long) ne.b < dist[ne.a]) {
                    dist[ne.a] = (long) p1.b + (long) ne.b;
                    pair p2 = new pair(ne.a, dist[ne.a]);
                    q.add(p2);

                }

            }
        }

    }
    static class cmp implements Comparator<pair>{

        public  int compare(pair o1,pair o2)
        {
            return o1.b<o2.b?-1:o1.b>o2.b?1:0;
        }

    }

    static class pair {
        int a;
        long b;
        pair(int a,long b){
            this.a=a;
            this.b=b;
        }
        public boolean equals(Object obj) {      //  override equals method for object to remove tem from arraylist and sets etc.......
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            pair other = (pair) obj;
            if (b!= other.b||a!=other.a)
                return false;
            return true;
        }
    }

    static long modinv(long a,long b)
    {
        long p=power(b,mod-2);

        p=a%mod*p%mod;
        p%=mod;

        return p;

    }

    static long power(long x,long y){
        if(y==0)return 1%mod;
        if(y==1)return x%mod;

        long res=1;
        x=x%mod;
        while(y>0){

            if((y%2)!=0){
                res=(res*x)%mod;
            }

            y=y/2;
            x=(x*x)%mod;
        }

        return res;

    }
    static  long gcd(long a,long b){

        if(b==0)return a;
        return gcd(b,a%b);
    }

    static  void sev(int a[],int n){

        for(int i=2;i<=n;i++)a[i]=i;
        for(int i=2;i<=n;i++){

            if(a[i]!=0){
                for(int j=2*i;j<=n;){

                    a[j]=0;
                    j=j+i;
                }
            }

        }

    }

    static 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 String nextLine()
        {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
        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 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 double nextDouble()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

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

            return res.toString();
        }

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

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

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

}

import java.io.*;
import java.util.*;
import java.lang.*;
import static java.lang.Math.*;
public class Main implements Runnable {

    public static void main(String[] args) {
        new Thread(null, new Main(), "Check2", 1 << 28).start();// to increse stack size in java
    }
    void init(ArrayList <Integer> adj[], int n){
        for(int i=0;i<=n;i++)adj[i]=new ArrayList<>();
    }
    static long mod = (long) (1e9+7);
    public void run() {
        InputReader in = new InputReader(System.in);
        PrintWriter w = new PrintWriter(System.out);

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

        if(x1-x2!=0&&y1-y2!=0) {
            int val = abs(x1 - x2) + (y1 - y2) + 2;
            val *= 2;
            w.println(val);
        }
        else if(x1-x2==0){

            w.println(4+2*(abs(y1-y2))+2);
        }
        else{

            w.println(4+2*(abs(x1-x2))+2);
        }

        w.close();
    }

    class pair2  {

        int a,b;
        pair2(int a,int b){
            this.a=a;
            this.b=b;
        }
    }

    static void diji(int s, long dist[], ArrayList<pair> adj[]) {
        dist[s] = 0;
        PriorityQueue<pair> q = new PriorityQueue<>(new cmp());
        q.add(new pair(s, 0));
        while (!q.isEmpty()) {
            pair p1 = q.poll();
            for (pair ne: adj[p1.a]) {

                if ((long) p1.b + (long) ne.b < dist[ne.a]) {
                    dist[ne.a] = (long) p1.b + (long) ne.b;
                    pair p2 = new pair(ne.a, dist[ne.a]);
                    q.add(p2);

                }

            }
        }

    }
    static class cmp implements Comparator<pair>{

        public  int compare(pair o1,pair o2)
        {
            return o1.b<o2.b?-1:o1.b>o2.b?1:0;
        }

    }

    static class pair {
        int a;
        long b;
        pair(int a,long b){
            this.a=a;
            this.b=b;
        }
        public boolean equals(Object obj) {      //  override equals method for object to remove tem from arraylist and sets etc.......
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            pair other = (pair) obj;
            if (b!= other.b||a!=other.a)
                return false;
            return true;
        }
    }

    static long modinv(long a,long b)
    {
        long p=power(b,mod-2);

        p=a%mod*p%mod;
        p%=mod;

        return p;

    }

    static long power(long x,long y){
        if(y==0)return 1%mod;
        if(y==1)return x%mod;

        long res=1;
        x=x%mod;
        while(y>0){

            if((y%2)!=0){
                res=(res*x)%mod;
            }

            y=y/2;
            x=(x*x)%mod;
        }

        return res;

    }
    static  long gcd(long a,long b){

        if(b==0)return a;
        return gcd(b,a%b);
    }

    static  void sev(int a[],int n){

        for(int i=2;i<=n;i++)a[i]=i;
        for(int i=2;i<=n;i++){

            if(a[i]!=0){
                for(int j=2*i;j<=n;){

                    a[j]=0;
                    j=j+i;
                }
            }

        }

    }

    static 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 String nextLine()
        {
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
        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 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 double nextDouble()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.')
            {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.')
            {
                c = read();
                double m = 1;
                while (!isSpaceChar(c))
                {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

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

            return res.toString();
        }

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

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

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

}

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

/**
 * 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;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskM solver = new TaskM();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskM {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int x1 = in.nextInt();
            int y1 = in.nextInt();

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

            int ans = Math.max(0, Math.abs(x1 - y1) - 1);
            ans += Math.max(0, Math.abs(x2 - y2) - 1);

            out.println(ans * 2 + 8);
        }

    }
}

import java.util.*;

public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        int x1,x2,y1,y2;
        x1=sc.nextInt();
        y1=sc.nextInt();
        x2=sc.nextInt();
        y2=sc.nextInt();
        if(Math.abs(x1-x2)==1){
          System.out.println((Math.abs(y1-y2)+1)*2+4);
        }
        else if(Math.abs(y1-y2)==1){
          System.out.println((Math.abs(x1-x2)+1)*2+4);
        }
        else{
          System.out.println((Math.abs(x1-x2)+1)*2+(Math.abs(y1-y2)+1)*2);
        }

    }

}

import java.util.*;

public class Main{
    public static void main(String [] args){
        Scanner sc=new Scanner(System.in);
        int x1,x2,y1,y2;
        x1=sc.nextInt();
        y1=sc.nextInt();
        x2=sc.nextInt();
        y2=sc.nextInt();
        if(Math.abs(x1-x2)<=1){
          System.out.println((Math.abs(y1-y2)+1)*2+4);
        }
        else if(Math.abs(y1-y2)<=1){
          System.out.println((Math.abs(x1-x2)+1)*2+4);
        }
        else{
          System.out.println((Math.abs(x1-x2)+1)*2+(Math.abs(y1-y2)+1)*2);
        }

    }

}

// package codeforces;

import java.util.*;

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

        int sx = in.nextInt();
        int sy = in.nextInt();
        int dx = in.nextInt();
        int dy = in.nextInt();

        int minDis = 2;
        if (dx > sx && dy > sy)
        {   // 终点在起点右上方
            minDis += Math.abs(dx+1-sx) + Math.abs(dy-sy)+ Math.abs(dy+1-sy) + Math.abs(dx-sx);
        }
        else if (dx > sx && dy < sy)
        {   // 终点在起点右下方
            minDis += Math.abs(dx+1-sx) + Math.abs(dy-sy) + Math.abs(dy-1-sy) + Math.abs(dx-sx);
        }
        else if (dx < sx && dy > sy)
        {   // 终点在起点左上方
            minDis += Math.abs(dx-1-sx) + Math.abs(dy-sy)+ Math.abs(dy+1-sy) + Math.abs(dx-sx);
        }
        else if (dx < sx && dy < sy)
        {   // 终点在起点的左下方
            minDis += Math.abs(dx-1-sx) + Math.abs(dy-sy)+ Math.abs(dy-1-sy) + Math.abs(dx-sx);
        }
        else
        {
            if (dx == sx)
            {
                minDis = 2*2*(Math.abs(dy-sy)+1);
            }
            else
            {
                minDis = 2*2*(Math.abs(sx-dx)+1);
            }
        }

        System.out.print(minDis);
    }
}

import java.util.Scanner;

public class QuadcopterCompetition {

	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 result = 2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2);
		if(x1 == x2 || y1 == y2)
			result += 2;
		System.out.println(2 * (Math.abs(x1 - x2) + Math.abs(y1 - y2) + 2));
	}

}

import java.util.*;

public class QuadcopterCompetition{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int x1 = sc.nextInt(), y1 = sc.nextInt(), x2 = sc.nextInt(), y2 = sc.nextInt();
        if(x1 == x2){
            System.out.println(2*(2+Math.abs(y1-y2)+1));
        }
        else if(y1 == y2){
            System.out.println(2* (2 + Math.abs(x1 - x2)));
        }
        else{
            int p = Math.abs(x1 - x2) + Math.abs(y1 - y2);
            System.out.println(p*2 + 4);
        }

    }
}

import java.util.Scanner;

public class ProblemM {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int startX, startY, flagX, flagY, needPointX, needPointY;
        startX = scanner.nextInt();
        startY = scanner.nextInt();
        scanner.nextLine();
        flagX = scanner.nextInt();
        flagY = scanner.nextInt();
        double d = Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY)*(startY - flagY)));
        needPointX = flagX - 1;
        needPointY = flagY;
        if (d > Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY + 1)*(startY - flagY + 1)))){
            d = Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY + 1)*(startY - flagY + 1)));
            needPointX = flagX - 1;
            needPointY = flagY + 1;
        }
        if (d > Math.sqrt(((startX - flagX)*(startX - flagX)
                + (startY - flagY + 1)*(startY - flagY + 1)))){
            d = Math.sqrt(((startX - flagX)*(startX - flagX)
                    + (startY - flagY + 1)*(startY - flagY + 1)));
            needPointX = flagX;
            needPointY = flagY + 1;
        }
        if (d > Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY + 1)*(startY - flagY + 1)))){
            d = Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY + 1)*(startY - flagY + 1)));
            needPointX = flagX + 1;
            needPointY = flagY + 1;
        }
        if (d > Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY)*(startY - flagY)))){
            d = Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY)*(startY - flagY)));
            needPointX = flagX + 1;
            needPointY = flagY;
        }
        if (d > Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY - 1)*(startY - flagY - 1)))){
            d = Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY - 1)*(startY - flagY - 1)));
            needPointX = flagX + 1;
            needPointY = flagY - 1;
        }
        if (d > Math.sqrt(((startX - flagX)*(startX - flagX)
                + (startY - flagY - 1)*(startY - flagY - 1)))){
            d = Math.sqrt(((startX - flagX)*(startX - flagX)
                + (startY - flagY - 1)*(startY - flagY - 1)));
            needPointX = flagX;
            needPointY = flagY - 1;
        }
        if (d > Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY - 1)*(startY - flagY - 1)))){
            d = Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY - 1)*(startY - flagY - 1)));
            needPointX = flagX - 1;
            needPointY = flagY - 1;
        }
        int result = Math.abs(startX - needPointX) + Math.abs(startY - needPointY);
        result <<= 1;
        //result +=8;
        System.out.println(result);
    }
}

import java.util.Scanner;

public class ProblemM {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int startX, startY, flagX, flagY, needPointX, needPointY;
        startX = scanner.nextInt();
        startY = scanner.nextInt();
        scanner.nextLine();
        flagX = scanner.nextInt();
        flagY = scanner.nextInt();
        double d = Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY)*(startY - flagY)));
        needPointX = flagX - 1;
        needPointY = flagY;
        if (d > Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY + 1)*(startY - flagY + 1)))){
            d = Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY + 1)*(startY - flagY + 1)));
            needPointX = flagX - 1;
            needPointY = flagY + 1;
        }
        if (d > Math.sqrt(((startX - flagX)*(startX - flagX)
                + (startY - flagY + 1)*(startY - flagY + 1)))){
            d = Math.sqrt(((startX - flagX)*(startX - flagX)
                    + (startY - flagY + 1)*(startY - flagY + 1)));
            needPointX = flagX;
            needPointY = flagY + 1;
        }
        if (d > Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY + 1)*(startY - flagY + 1)))){
            d = Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY + 1)*(startY - flagY + 1)));
            needPointX = flagX + 1;
            needPointY = flagY + 1;
        }
        if (d > Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY)*(startY - flagY)))){
            d = Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY)*(startY - flagY)));
            needPointX = flagX + 1;
            needPointY = flagY;
        }
        if (d > Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY - 1)*(startY - flagY - 1)))){
            d = Math.sqrt(((startX - flagX + 1)*(startX - flagX + 1)
                + (startY - flagY - 1)*(startY - flagY - 1)));
            needPointX = flagX + 1;
            needPointY = flagY - 1;
        }
        if (d > Math.sqrt(((startX - flagX)*(startX - flagX)
                + (startY - flagY - 1)*(startY - flagY - 1)))){
            d = Math.sqrt(((startX - flagX)*(startX - flagX)
                + (startY - flagY - 1)*(startY - flagY - 1)));
            needPointX = flagX;
            needPointY = flagY - 1;
        }
        if (d > Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY - 1)*(startY - flagY - 1)))){
            d = Math.sqrt(((startX - flagX - 1)*(startX - flagX - 1)
                + (startY - flagY - 1)*(startY - flagY - 1)));
            needPointX = flagX - 1;
            needPointY = flagY - 1;
        }
        int result = Math.abs(startX - needPointX) + Math.abs(startY - needPointY);
        result <<= 1;
        result +=8;
        System.out.println(result);
    }
}

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int x1=sc.nextInt();
		int y1=sc.nextInt();
		int x2=sc.nextInt();
		int y2=sc.nextInt();
		int ans=0;
		if(x1!=x2&&y1!=y2)
		{
			if(x1<x2&&y1<y2)
			{
				ans=(x2+1-x1)+(y2+1-y1);
				ans=ans*2;
			}
			else if(x1<x2&&y1>y2)
			{
				ans=(x2+1-x1)+(y1-y2+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1<y2)
			{
				ans=(x1-x2+1)+(y2-y1+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1>y2)
			{
				ans=(x2-x1+1)+(y2-y1+1);
				ans=ans*2;
			}
		}
		if(x1==x2&&y1!=y2)
		{
			ans=Math.abs(y1-y2);
			ans=ans*2;
			ans=ans+4;
		}
		else if(x1!=x2&&y1==y2)
		{
			ans=Math.abs(x1-x2);
			ans=ans*2;
			ans=ans+4;
		}
		System.out.println(ans);
	}

}

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int x1=sc.nextInt();
		int y1=sc.nextInt();
		int x2=sc.nextInt();
		int y2=sc.nextInt();
		int ans=0;
		if(x1!=x2&&y1!=y2)
		{
			if(x1<x2&&y1<y2)
			{
				ans=(x2+1-x1)+(y2+1-y1);
				ans=ans*2;
			}
			else if(x1<x2&&y1>y2)
			{
				ans=(x2+1-x1)+(y1-y2+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1<y2)
			{
				ans=(x1-x2+1)+(y2-y1+1);
				ans=ans*2;
			}
			else if(x1>x2&&y1>y2)
			{
				ans=(x2-x1+1)+(y2-y1+1);
				ans=ans*2;
			}
		}
		if(x1==x2&&y1!=y2)
		{
			ans=Math.abs(y1-y2)+1;
			ans=ans*2;
			ans=ans+4;
		}
		else if(x1!=x2&&y1==y2)
		{
			ans=Math.abs(x1-x2)+1;
			ans=ans*2;
			ans=ans+4;
		}
		System.out.println(ans);
	}

}

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

     //--------------->>>>IF YOU ARE HERE FOR QUICKSORT HACK THEN SORRY NO HACK FOR YOU<<<-------------------

public class a{
     static long[] count,count1,count2;
     static Node[] nodes;
     static long[] arr;
     static int[] dp;
     static char[] ch,ch1;
     static long[] darr,farr;
     static char[][] mat,mat1;
     static long x,h;
     static long maxl;
     static double dec;
     static long mx = (long)1e9+7;
     static String s;
     static long minl;
     static int start_row;
     static int start_col;
     static int end_row;
     static int end_col;
     static long mod = (long)1e7+7;
     // static int minl = -1;
     // static long n;
     static int n,n1,n2;
     static long a;
     static long b;
     static long c;
     static long d;
     static long y,z;
     static int m;
     static int k;
     static String[] str,str1;
     static Set<Long> set,set1,set2;
     static SortedSet<Long> ss;
     static List<Integer> list,list1,list2,list3;
     static LinkedList<Node> ll;
     static Map<Integer,List<Integer>> map,map1;
     static StringBuilder sb,sb1,sb2;
     static int index;
     static int[] dx = {0,-1,0,1,-1,1,-1,1};
     static int[] dy = {-1,0,1,0,-1,-1,1,1};

     // public static void solve(){

     //    FastScanner sc = new FastScanner();
     //    // int t = sc.nextInt();
     //    int t = 1;
     //    for(int tt = 0 ; tt < t ; tt++){
     //        int n = sc.nextInt();
     //        int m = sc.nextInt();
     //        int prev = 0;

     //        for(int i = 0 ; i < n ; i++){
     //           int s = sc.nextInt();
     //           int e = sc.nextInt();
     //           if(s > prev){
     //                System.out.println("NO");
     //                return;
     //           }
     //            prev = Math.max(prev,e);
     //        }
     //        if(prev == m)
     //            System.out.println("YES");
     //        else
     //            System.out.println("NO");

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

     // }

     //--------------->>>>IF YOU ARE HERE FOR QUICKSORT HACK THEN SORRY NO HACK FOR YOU<<<-------------------

     public static void solve(){

        int signy;
        int signx;

        if(x < 0)
            signx = -1;
        else
            signx = 1;

        if(y < 0)
            signy = -1;
        else
            signy = 1;

        if(y == b){
            System.out.println((2*Math.abs(x-a) + 4)+2);
            return;
        }

        if(x == a){
            System.out.println(4 + 2*Math.abs(y-b)+2);
            return;
        }

        if(y < b){
            y -= signy*1;
            x += signx*1;
        }
        else if(y > b){
            y += signy*1;
            x += signx*1;
        }

        System.out.println(2*(Math.abs(x-a) + Math.abs(y-b)));

     }

     public static void main(String[] args) {

            FastScanner sc = new FastScanner();
            // Scanner sc = new Scanner(System.in);
            // int t = sc.nextInt();
            int t = 1;
            // int l = 1;
            while(t > 0){

                // n = sc.nextInt();
                // n = sc.nextLong();
                a = sc.nextLong();
                b = sc.nextLong();
                // c = sc.nextLong();
                // d = sc.nextLong();

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

                // n = sc.nextLong();
                // n = sc.nextInt();
                // n1 = sc.nextInt();

                // m = sc.nextInt();

                // k = sc.nextInt();
                // s = sc.next();

                // ch = sc.next().toCharArray();
                // ch1 = sc.next().toCharArray();

                // arr = new int[n];
                // for(int i = 0 ; i < n ; i++){
                //     arr[i] = sc.nextInt();
                // }
                // // m = n;
                // darr = new long[n];
                // for(int i = 0; i < n ; i++){
                //     darr[i] = sc.nextLong();
                // }

                // farr = new int[n];
                // for(int i = 0; i < n ; i++){
                //     farr[i] = sc.nextInt();
                // }

                // mat = new char[n][m];
                // for(int i = 0 ; i < n ; i++){
                //     String s = sc.next();
                //     for(int j = 0 ; j < m ; j++){
                //         mat[i][j] = s.charAt(j);
                //     }
                // }

                // str = new String[n];
                // for(int i = 0 ; i < n ; i++)
                //     str[i] = sc.next();

                // nodes = new Node[n];
                // for(int i = 0 ; i < n ;i++)
                //     nodes[i] = new Node(sc.nextInt(),sc.nextInt());

                // System.out.println(solve()?"YES":"NO");
                 solve();
                 // System.out.println(solve());
                 t -= 1;
            }

     }

    public static int log(long n){

         if(n == 0 || n == 1)
             return 0;

         if(n == 2)
             return 1;

         double num = Math.log(n);
         double den = Math.log(2);

         if(den == 0)
             return 0;

         return (int)(num/den);
     }

    public static boolean isPrime(long n) {
    // Corner cases
        if (n <= 1)
            return false;

        if (n <= 3)
            return true;

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n%2 == 0 || n%3 == 0)
            return false;

        for (int i=5; i*i<=n; i=i+6)
            if (n%i == 0 || n%(i+2) == 0)
               return false;

        return true;
    }

     public static long gcd(long a,long b){

        if(b%a == 0){
            return a;
        }
        return gcd(b%a,a);

     }

     // public static void swap(int i,int j){
     //     long temp = arr[j];
     //     arr[j] = arr[i];
     //     arr[i] = temp;
     // }

    static final Random random=new Random();

    static void ruffleSort(long[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n);
            long temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static class Node{
        Integer first;
        Integer second;
        Node(Integer f,Integer s){
            this.first = f;
            this.second = s;
        }
    }

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

     //--------------->>>>IF YOU ARE HERE FOR QUICKSORT HACK THEN SORRY NO HACK FOR YOU<<<-------------------

public class a{
     static long[] count,count1,count2;
     static Node[] nodes;
     static long[] arr;
     static int[] dp;
     static char[] ch,ch1;
     static long[] darr,farr;
     static char[][] mat,mat1;
     static long x,h;
     static long maxl;
     static double dec;
     static long mx = (long)1e9+7;
     static String s;
     static long minl;
     static int start_row;
     static int start_col;
     static int end_row;
     static int end_col;
     static long mod = (long)1e7+7;
     // static int minl = -1;
     // static long n;
     static int n,n1,n2;
     static long a;
     static long b;
     static long c;
     static long d;
     static long y,z;
     static int m;
     static int k;
     static String[] str,str1;
     static Set<Long> set,set1,set2;
     static SortedSet<Long> ss;
     static List<Integer> list,list1,list2,list3;
     static LinkedList<Node> ll;
     static Map<Integer,List<Integer>> map,map1;
     static StringBuilder sb,sb1,sb2;
     static int index;
     static int[] dx = {0,-1,0,1,-1,1,-1,1};
     static int[] dy = {-1,0,1,0,-1,-1,1,1};

     // public static void solve(){

     //    FastScanner sc = new FastScanner();
     //    // int t = sc.nextInt();
     //    int t = 1;
     //    for(int tt = 0 ; tt < t ; tt++){
     //        int n = sc.nextInt();
     //        int m = sc.nextInt();
     //        int prev = 0;

     //        for(int i = 0 ; i < n ; i++){
     //           int s = sc.nextInt();
     //           int e = sc.nextInt();
     //           if(s > prev){
     //                System.out.println("NO");
     //                return;
     //           }
     //            prev = Math.max(prev,e);
     //        }
     //        if(prev == m)
     //            System.out.println("YES");
     //        else
     //            System.out.println("NO");

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

     // }

     //--------------->>>>IF YOU ARE HERE FOR QUICKSORT HACK THEN SORRY NO HACK FOR YOU<<<-------------------

     public static void solve(){

        if(y == b){
            System.out.println((2*Math.abs(x-a) + 4)+2);
            return;
        }

        if(x == a){
            System.out.println(4 + 2*Math.abs(y-b)+2);
            return;
        }

        if(y < b){
            y -= 1;
            x += 1;
        }
        else if(y > b){
            y += 1;
            x += 1;
        }

        System.out.println(2*(Math.abs(x-a) + Math.abs(y-b)));

     }

     public static void main(String[] args) {

            FastScanner sc = new FastScanner();
            // Scanner sc = new Scanner(System.in);
            // int t = sc.nextInt();
            int t = 1;
            // int l = 1;
            while(t > 0){

                // n = sc.nextInt();
                // n = sc.nextLong();
                a = sc.nextLong();
                b = sc.nextLong();
                // c = sc.nextLong();
                // d = sc.nextLong();

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

                // n = sc.nextLong();
                // n = sc.nextInt();
                // n1 = sc.nextInt();

                // m = sc.nextInt();

                // k = sc.nextInt();
                // s = sc.next();

                // ch = sc.next().toCharArray();
                // ch1 = sc.next().toCharArray();

                // arr = new int[n];
                // for(int i = 0 ; i < n ; i++){
                //     arr[i] = sc.nextInt();
                // }
                // // m = n;
                // darr = new long[n];
                // for(int i = 0; i < n ; i++){
                //     darr[i] = sc.nextLong();
                // }

                // farr = new int[n];
                // for(int i = 0; i < n ; i++){
                //     farr[i] = sc.nextInt();
                // }

                // mat = new char[n][m];
                // for(int i = 0 ; i < n ; i++){
                //     String s = sc.next();
                //     for(int j = 0 ; j < m ; j++){
                //         mat[i][j] = s.charAt(j);
                //     }
                // }

                // str = new String[n];
                // for(int i = 0 ; i < n ; i++)
                //     str[i] = sc.next();

                // nodes = new Node[n];
                // for(int i = 0 ; i < n ;i++)
                //     nodes[i] = new Node(sc.nextInt(),sc.nextInt());

                // System.out.println(solve()?"YES":"NO");
                 solve();
                 // System.out.println(solve());
                 t -= 1;
            }

     }

    public static int log(long n){

         if(n == 0 || n == 1)
             return 0;

         if(n == 2)
             return 1;

         double num = Math.log(n);
         double den = Math.log(2);

         if(den == 0)
             return 0;

         return (int)(num/den);
     }

    public static boolean isPrime(long n) {
    // Corner cases
        if (n <= 1)
            return false;

        if (n <= 3)
            return true;

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n%2 == 0 || n%3 == 0)
            return false;

        for (int i=5; i*i<=n; i=i+6)
            if (n%i == 0 || n%(i+2) == 0)
               return false;

        return true;
    }

     public static long gcd(long a,long b){

        if(b%a == 0){
            return a;
        }
        return gcd(b%a,a);

     }

     // public static void swap(int i,int j){
     //     long temp = arr[j];
     //     arr[j] = arr[i];
     //     arr[i] = temp;
     // }

    static final Random random=new Random();

    static void ruffleSort(long[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n);
            long temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static class Node{
        Integer first;
        Integer second;
        Node(Integer f,Integer s){
            this.first = f;
            this.second = s;
        }
    }

     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.*;
import java.util.*;
public class ACMICPCNEERCA {

	static int[] A;
    static int[] S;
    static long[] sum;
   public static int mod=1000000007;
   static int[][] dp;
   static boolean[][] isPalin;
   static int max1=5000+10;
   static int[][] g;
   static int ver;
   static int n;
   static boolean[] visit;
   static LinkedList<Pair> l[];
   static int ans=0;
   static int[] color;
  public static void main(String[] args) throws Exception
   {
   	InputReader in = new InputReader(System.in);
   	PrintWriter pw=new PrintWriter(System.out);
     int x1=in.ii();
     int y1=in.ii();
     int x2=in.ii();
     int y2=in.ii();
     if(dist(x1,y1,x2,y2)==1)pw.println(8);
     else{
     int x3=Math.abs(x1-x2);
     int y3=Math.abs(y1-y2);
   	int ans=x3-1+y3-1;
   	ans*=2;

   	pw.println(ans+8);
     }

   	 pw.close();
   }
  private  static int dist(int x1, int y1, int x2, int y2) {
      return (x2 - x1) *  (x2 - x1) + (y2 - y1) * (y2 - y1);
  }

  static  void dfs(int i)
  {
	  if(visit[i])return ;
	  visit[i]=true;
	  for(int o:g[i])
		  if(!visit[o])
			  dfs(o);

  }
  private static class DSU{
		int[] parent;
		int[] rank;
		int cnt;
		public DSU(int n){
			parent=new int[n];
			rank=new int[n];
			for(int i=0;i<n;i++){
				parent[i]=i;
				rank[i]=1;
			}
			cnt=n;
		}
		int find(int i){
	        while(parent[i] !=i){
	        	parent[i]=parent[parent[i]];
	        	i=parent[i];
	        }
	        return i;
	    }
		int Union(int x, int y){
	        int xset = find(x);
	        int yset = find(y);
	        if(xset!=yset)
	        	cnt--;
	        if(rank[xset]<rank[yset]){
	        	parent[xset] = yset;
		        rank[yset]+=rank[xset];
		        rank[xset]=0;
		        return yset;
	        }else{
	        	parent[yset]=xset;
	        	rank[xset]+=rank[yset];
	        	rank[yset]=0;
	        	return xset;
	        }
	    }
	}
  public static int[][] packU(int n, int[] from, int[] to, int max) {

	    int[][] g = new int[n][];
	    int[] p = new int[n];
	    for (int i = 0; i < max; i++) p[from[i]]++;
	    for (int i = 0; i < max; i++) p[to[i]]++;
	    for (int i = 0; i < n; i++) g[i] = new int[p[i]];
	    for (int i = 0; i < max; i++) {
	        g[from[i]][--p[from[i]]] = to[i];
	        g[to[i]][--p[to[i]]] = from[i];
	    }
	    return g;
	}
	public static int[][] parents3(int[][] g, int root) {
	    int n = g.length;
	    int[] par = new int[n];
	    Arrays.fill(par, -1);

	    int[] depth = new int[n];
	    depth[0] = 0;

	    int[] q = new int[n];
	    q[0] = root;
	    for (int p = 0, r = 1; p < r; p++) {
	        int cur = q[p];
	        for (int nex : g[cur]) {
	            if (par[cur] != nex) {
	                q[r++] = nex;
	                par[nex] = cur;
	                depth[nex] = depth[cur] + 1;
	            }
	        }
	    }
	    return new int[][]{par, q, depth};
	}
	public static int lower_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] < target)
                low = mid + 1;
            else
                high = mid;
        }
        return nums[low] == target ? low : -1;
    }

    public static int upper_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high + 1 - low) / 2;
            if (nums[mid] > target)
                high = mid - 1;
            else
                low = mid;
        }
        return nums[low] == target ? low : -1;
    }
  public static boolean palin(String s)
	{
	   int i=0;
	   int j=s.length()-1;
	   while(i<j)
	   {
		   if(s.charAt(i)==s.charAt(j))
		   {
			   i++;
			   j--;
		   }
		   else return false;
	   }
	   return true;
	}

    static boolean CountPs(String s,int n)
       {
    	boolean b=false;
    	     char[] S=s.toCharArray();
	       int[][] dp=new int[n][n];
	       boolean[][] p=new boolean[n][n];
	       for(int i=0;i<n;i++)p[i][i]=true;

	       for(int i=0;i<n-1;i++)
	       {
	    	   if(S[i]==S[i+1])
	    	   {
	    		p[i][i+1]=true;
	    		dp[i][i+1]=1;
	    		b=true;
	    	   }
	       }

	       for(int gap=2;gap<n;gap++)
	       {
	    	   for(int i=0;i<n-gap;i++)
	    	   {
	    		   int j=gap+i;
	    		   if(S[i]==S[j]&&p[i+1][j-1]){p[i][j]=true;}

	    		  if(p[i][j])
	    			   dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];

	    		   else  dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];

	    		   if(dp[i][j]>=1){b=true;}
	    	   }
	       }

	    return b;
   // return dp[0][n-1];

    }

public static int gcd(int a,int b)
{
	int res=1;
	while(a>0)
	{
		res=a;
		a=b%a;
		b=res;
	}
	return res;
}

public static long pow(long n,long p,long m)
{
	 long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
}
public static long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}

static class Edge implements Comparator<Edge> {
	private int u;
	private int v;
	private int w;
	public Edge() {
	}
	public Edge(int u, int v, int w) {
		this.u=u;
		this.v=v;
		this.w=w;
	}
	public int getU() {
		return u;
	}
	public void setU(int u) {
		this.u = u;
	}
	public int getV() {
		return v;
	}
	public void setV(int v) {
		this.v = v;
	}
	public int getW() {
		return w;
	}
	public void setW(int w) {
		this.w = w;
	      }
	public int compareTo(Edge e)
	  {
		return this.getW() - e.getW();
	}
	@Override
	public String toString() {
		return "Edge [u=" + u + ", v=" + v + ", w=" + w + "]";
	}
	@Override
	public int compare(Edge arg0, Edge arg1) {
		// TODO Auto-generated method stub
		return 0;
	}
}

static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

	public int compareTo(Pair o) {
		// TODO Auto-generated method stub
		if(this.a!=o.a)
		return -Integer.compare(this.a,o.a);
		else
			return -Integer.compare(this.b, o.b);
		//return 0;
	}
	public boolean equals(Object o) {
       if (o instanceof Pair) {
           Pair p = (Pair)o;
           return p.a == a && p.b == b;
       }
       return false;
   }
   public int hashCode() {
       return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
   }
}

static  class InputReader
{
   private InputStream stream;
   private byte[] buf = new byte[1024];

   private SpaceCharFilter filter;
    byte inbuffer[] = new byte[1024];
   int lenbuffer = 0, ptrbuffer = 0;
    final int M = (int) 1e9 + 7;
   int md=(int)(1e7+1);
    int[] SMP=new int[md];
   final double eps = 1e-6;
   final double pi = Math.PI;

	PrintWriter out;
   String check = "";
 InputStream   obj = check.isEmpty() ? System.in : new ByteArrayInputStream(check.getBytes());
   public InputReader(InputStream stream)
   {
       this.stream = stream;
   }

    int readByte() {
	        if (lenbuffer == -1) throw new InputMismatchException();
	        if (ptrbuffer >= lenbuffer) {
	            ptrbuffer = 0;
	            try {
	                lenbuffer = obj.read(inbuffer);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	        }
	        if (lenbuffer <= 0) return -1;
	        return inbuffer[ptrbuffer++];
   }

   public  int read()
   {
       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;
   }

   String is() {
	        int b = skip();
	        StringBuilder sb = new StringBuilder();
	        while (!(isSpaceChar(b))) // when nextLine, (isSpaceChar(b) && b!=' ')
	        {
	            sb.appendCodePoint(b);
	            b = readByte();
	        }
	        return sb.toString();
   }
   public   int ii() {
	        int num = 0, b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }
 public   long il() {
	        long num = 0;
	        int b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }

	    boolean isSpaceChar(int c) {
	        return (!(c >= 33 && c <= 126));
	       }

	      int skip()
	        {
	        int b;
	        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
	        return b;
	        }

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

	    double id() {
	        return Double.parseDouble(is());
	    }

	    char ic() {
	        return (char) skip();
	    }

	    int[] iia(int n) {
	        int a[] = new int[n];
	        for (int i = 0; i<n; i++) a[i] = ii();
	        return a;
	    }

	    long[] ila(int n) {
	        long a[] = new long[n];
	        for (int i = 0; i <n; i++) a[i] = il();
	        return a;
	    }

	    String[] isa(int n) {
	        String a[] = new String[n];
	        for (int i = 0; i < n; i++) a[i] = is();
	        return a;
	    }

		 long mul(long a, long b) { return a * b % M; }

			long div(long a, long b)
				 {
					return mul(a, pow(b, M - 2));

		           }

	    double[][] idm(int n, int m) {
	        double a[][] = new double[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = id();
	        return a;
	        }

	    int[][] iim(int n, int m) {
	        int a[][] = new int[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j <m; j++) a[i][j] = ii();
	        return a;
          }

   public String readLine() {
       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 interface SpaceCharFilter
   {
       public boolean isSpaceChar(int ch);
   }
   public boolean isEndOfLine(int c) {
       return c == '\n' || c == '\r' || c == -1;
   }
}

}

///package CodeForce;
import java.io.*;
import java.util.*;
public class ACMICPCNEERCA {

	static int[] A;
    static int[] S;
    static long[] sum;
   public static int mod=1000000007;
   static int[][] dp;
   static boolean[][] isPalin;
   static int max1=5000+10;
   static int[][] g;
   static int ver;
   static int n;
   static boolean[] visit;
   static LinkedList<Pair> l[];
   static int ans=0;
   static int[] color;
  public static void main(String[] args) throws Exception
   {
   	InputReader in = new InputReader(System.in);
   	PrintWriter pw=new PrintWriter(System.out);
     int x1=in.ii();
     int y1=in.ii();
     int x2=in.ii();
     int y2=in.ii();
     if(dist(x1,y1,x2,y2)==1)pw.println(8);
     else{
     int x3=Math.abs(x1-x2);
     int y3=Math.abs(y1-y2);
   	int ans=x3-1+y3-1+1;
   	ans*=2;
   	ans+=6;
   	pw.println(ans);
     }

   	 pw.close();
   }
  private  static int dist(int x1, int y1, int x2, int y2) {
      return (x2 - x1) *  (x2 - x1) + (y2 - y1) * (y2 - y1);
  }

  static  void dfs(int i)
  {
	  if(visit[i])return ;
	  visit[i]=true;
	  for(int o:g[i])
		  if(!visit[o])
			  dfs(o);

  }
  private static class DSU{
		int[] parent;
		int[] rank;
		int cnt;
		public DSU(int n){
			parent=new int[n];
			rank=new int[n];
			for(int i=0;i<n;i++){
				parent[i]=i;
				rank[i]=1;
			}
			cnt=n;
		}
		int find(int i){
	        while(parent[i] !=i){
	        	parent[i]=parent[parent[i]];
	        	i=parent[i];
	        }
	        return i;
	    }
		int Union(int x, int y){
	        int xset = find(x);
	        int yset = find(y);
	        if(xset!=yset)
	        	cnt--;
	        if(rank[xset]<rank[yset]){
	        	parent[xset] = yset;
		        rank[yset]+=rank[xset];
		        rank[xset]=0;
		        return yset;
	        }else{
	        	parent[yset]=xset;
	        	rank[xset]+=rank[yset];
	        	rank[yset]=0;
	        	return xset;
	        }
	    }
	}
  public static int[][] packU(int n, int[] from, int[] to, int max) {

	    int[][] g = new int[n][];
	    int[] p = new int[n];
	    for (int i = 0; i < max; i++) p[from[i]]++;
	    for (int i = 0; i < max; i++) p[to[i]]++;
	    for (int i = 0; i < n; i++) g[i] = new int[p[i]];
	    for (int i = 0; i < max; i++) {
	        g[from[i]][--p[from[i]]] = to[i];
	        g[to[i]][--p[to[i]]] = from[i];
	    }
	    return g;
	}
	public static int[][] parents3(int[][] g, int root) {
	    int n = g.length;
	    int[] par = new int[n];
	    Arrays.fill(par, -1);

	    int[] depth = new int[n];
	    depth[0] = 0;

	    int[] q = new int[n];
	    q[0] = root;
	    for (int p = 0, r = 1; p < r; p++) {
	        int cur = q[p];
	        for (int nex : g[cur]) {
	            if (par[cur] != nex) {
	                q[r++] = nex;
	                par[nex] = cur;
	                depth[nex] = depth[cur] + 1;
	            }
	        }
	    }
	    return new int[][]{par, q, depth};
	}
	public static int lower_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] < target)
                low = mid + 1;
            else
                high = mid;
        }
        return nums[low] == target ? low : -1;
    }

    public static int upper_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high + 1 - low) / 2;
            if (nums[mid] > target)
                high = mid - 1;
            else
                low = mid;
        }
        return nums[low] == target ? low : -1;
    }
  public static boolean palin(String s)
	{
	   int i=0;
	   int j=s.length()-1;
	   while(i<j)
	   {
		   if(s.charAt(i)==s.charAt(j))
		   {
			   i++;
			   j--;
		   }
		   else return false;
	   }
	   return true;
	}

    static boolean CountPs(String s,int n)
       {
    	boolean b=false;
    	     char[] S=s.toCharArray();
	       int[][] dp=new int[n][n];
	       boolean[][] p=new boolean[n][n];
	       for(int i=0;i<n;i++)p[i][i]=true;

	       for(int i=0;i<n-1;i++)
	       {
	    	   if(S[i]==S[i+1])
	    	   {
	    		p[i][i+1]=true;
	    		dp[i][i+1]=1;
	    		b=true;
	    	   }
	       }

	       for(int gap=2;gap<n;gap++)
	       {
	    	   for(int i=0;i<n-gap;i++)
	    	   {
	    		   int j=gap+i;
	    		   if(S[i]==S[j]&&p[i+1][j-1]){p[i][j]=true;}

	    		  if(p[i][j])
	    			   dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];

	    		   else  dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];

	    		   if(dp[i][j]>=1){b=true;}
	    	   }
	       }

	    return b;
   // return dp[0][n-1];

    }

public static int gcd(int a,int b)
{
	int res=1;
	while(a>0)
	{
		res=a;
		a=b%a;
		b=res;
	}
	return res;
}

public static long pow(long n,long p,long m)
{
	 long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
}
public static long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}

static class Edge implements Comparator<Edge> {
	private int u;
	private int v;
	private int w;
	public Edge() {
	}
	public Edge(int u, int v, int w) {
		this.u=u;
		this.v=v;
		this.w=w;
	}
	public int getU() {
		return u;
	}
	public void setU(int u) {
		this.u = u;
	}
	public int getV() {
		return v;
	}
	public void setV(int v) {
		this.v = v;
	}
	public int getW() {
		return w;
	}
	public void setW(int w) {
		this.w = w;
	      }
	public int compareTo(Edge e)
	  {
		return this.getW() - e.getW();
	}
	@Override
	public String toString() {
		return "Edge [u=" + u + ", v=" + v + ", w=" + w + "]";
	}
	@Override
	public int compare(Edge arg0, Edge arg1) {
		// TODO Auto-generated method stub
		return 0;
	}
}

static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

	public int compareTo(Pair o) {
		// TODO Auto-generated method stub
		if(this.a!=o.a)
		return -Integer.compare(this.a,o.a);
		else
			return -Integer.compare(this.b, o.b);
		//return 0;
	}
	public boolean equals(Object o) {
       if (o instanceof Pair) {
           Pair p = (Pair)o;
           return p.a == a && p.b == b;
       }
       return false;
   }
   public int hashCode() {
       return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
   }
}

static  class InputReader
{
   private InputStream stream;
   private byte[] buf = new byte[1024];

   private SpaceCharFilter filter;
    byte inbuffer[] = new byte[1024];
   int lenbuffer = 0, ptrbuffer = 0;
    final int M = (int) 1e9 + 7;
   int md=(int)(1e7+1);
    int[] SMP=new int[md];
   final double eps = 1e-6;
   final double pi = Math.PI;

	PrintWriter out;
   String check = "";
 InputStream   obj = check.isEmpty() ? System.in : new ByteArrayInputStream(check.getBytes());
   public InputReader(InputStream stream)
   {
       this.stream = stream;
   }

    int readByte() {
	        if (lenbuffer == -1) throw new InputMismatchException();
	        if (ptrbuffer >= lenbuffer) {
	            ptrbuffer = 0;
	            try {
	                lenbuffer = obj.read(inbuffer);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	        }
	        if (lenbuffer <= 0) return -1;
	        return inbuffer[ptrbuffer++];
   }

   public  int read()
   {
       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;
   }

   String is() {
	        int b = skip();
	        StringBuilder sb = new StringBuilder();
	        while (!(isSpaceChar(b))) // when nextLine, (isSpaceChar(b) && b!=' ')
	        {
	            sb.appendCodePoint(b);
	            b = readByte();
	        }
	        return sb.toString();
   }
   public   int ii() {
	        int num = 0, b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }
 public   long il() {
	        long num = 0;
	        int b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }

	    boolean isSpaceChar(int c) {
	        return (!(c >= 33 && c <= 126));
	       }

	      int skip()
	        {
	        int b;
	        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
	        return b;
	        }

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

	    double id() {
	        return Double.parseDouble(is());
	    }

	    char ic() {
	        return (char) skip();
	    }

	    int[] iia(int n) {
	        int a[] = new int[n];
	        for (int i = 0; i<n; i++) a[i] = ii();
	        return a;
	    }

	    long[] ila(int n) {
	        long a[] = new long[n];
	        for (int i = 0; i <n; i++) a[i] = il();
	        return a;
	    }

	    String[] isa(int n) {
	        String a[] = new String[n];
	        for (int i = 0; i < n; i++) a[i] = is();
	        return a;
	    }

		 long mul(long a, long b) { return a * b % M; }

			long div(long a, long b)
				 {
					return mul(a, pow(b, M - 2));

		           }

	    double[][] idm(int n, int m) {
	        double a[][] = new double[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = id();
	        return a;
	        }

	    int[][] iim(int n, int m) {
	        int a[][] = new int[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j <m; j++) a[i][j] = ii();
	        return a;
          }

   public String readLine() {
       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 interface SpaceCharFilter
   {
       public boolean isSpaceChar(int ch);
   }
   public boolean isEndOfLine(int c) {
       return c == '\n' || c == '\r' || c == -1;
   }
}

}

//package CodeForce;
import java.io.*;
import java.util.*;
public class ACMICPCNEERCA {

	static int[] A;
    static int[] S;
    static long[] sum;
   public static int mod=1000000007;
   static int[][] dp;
   static boolean[][] isPalin;
   static int max1=5000+10;
   static int[][] g;
   static int ver;
   static int n;
   static boolean[] visit;
   static LinkedList<Pair> l[];
   static int ans=0;
   static int[] color;
  public static void main(String[] args) throws Exception
   {
   	InputReader in = new InputReader(System.in);
   	PrintWriter pw=new PrintWriter(System.out);
     int x1=in.ii();
     int y1=in.ii();
     int x2=in.ii();
     int y2=in.ii();
     if(dist(x1,y1,x2,y2)==1)pw.println(8);
     else{
     int x3=Math.abs(x1-x2);
     int y3=Math.abs(y1-y2);
   	int ans=x3-1+y3-1+3;
   	ans*=2;

   	pw.println(ans+2);
    }

   	 pw.close();
   }
  private  static int dist(int x1, int y1, int x2, int y2) {
      return (x2 - x1) *  (x2 - x1) + (y2 - y1) * (y2 - y1);
  }

  static  void dfs(int i)
  {
	  if(visit[i])return ;
	  visit[i]=true;
	  for(int o:g[i])
		  if(!visit[o])
			  dfs(o);

  }
  private static class DSU{
		int[] parent;
		int[] rank;
		int cnt;
		public DSU(int n){
			parent=new int[n];
			rank=new int[n];
			for(int i=0;i<n;i++){
				parent[i]=i;
				rank[i]=1;
			}
			cnt=n;
		}
		int find(int i){
	        while(parent[i] !=i){
	        	parent[i]=parent[parent[i]];
	        	i=parent[i];
	        }
	        return i;
	    }
		int Union(int x, int y){
	        int xset = find(x);
	        int yset = find(y);
	        if(xset!=yset)
	        	cnt--;
	        if(rank[xset]<rank[yset]){
	        	parent[xset] = yset;
		        rank[yset]+=rank[xset];
		        rank[xset]=0;
		        return yset;
	        }else{
	        	parent[yset]=xset;
	        	rank[xset]+=rank[yset];
	        	rank[yset]=0;
	        	return xset;
	        }
	    }
	}
  public static int[][] packU(int n, int[] from, int[] to, int max) {

	    int[][] g = new int[n][];
	    int[] p = new int[n];
	    for (int i = 0; i < max; i++) p[from[i]]++;
	    for (int i = 0; i < max; i++) p[to[i]]++;
	    for (int i = 0; i < n; i++) g[i] = new int[p[i]];
	    for (int i = 0; i < max; i++) {
	        g[from[i]][--p[from[i]]] = to[i];
	        g[to[i]][--p[to[i]]] = from[i];
	    }
	    return g;
	}
	public static int[][] parents3(int[][] g, int root) {
	    int n = g.length;
	    int[] par = new int[n];
	    Arrays.fill(par, -1);

	    int[] depth = new int[n];
	    depth[0] = 0;

	    int[] q = new int[n];
	    q[0] = root;
	    for (int p = 0, r = 1; p < r; p++) {
	        int cur = q[p];
	        for (int nex : g[cur]) {
	            if (par[cur] != nex) {
	                q[r++] = nex;
	                par[nex] = cur;
	                depth[nex] = depth[cur] + 1;
	            }
	        }
	    }
	    return new int[][]{par, q, depth};
	}
	public static int lower_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            if (nums[mid] < target)
                low = mid + 1;
            else
                high = mid;
        }
        return nums[low] == target ? low : -1;
    }

    public static int upper_bound(int[] nums, int target) {
        int low = 0, high = nums.length - 1;
        while (low < high) {
            int mid = low + (high + 1 - low) / 2;
            if (nums[mid] > target)
                high = mid - 1;
            else
                low = mid;
        }
        return nums[low] == target ? low : -1;
    }
  public static boolean palin(String s)
	{
	   int i=0;
	   int j=s.length()-1;
	   while(i<j)
	   {
		   if(s.charAt(i)==s.charAt(j))
		   {
			   i++;
			   j--;
		   }
		   else return false;
	   }
	   return true;
	}

    static boolean CountPs(String s,int n)
       {
    	boolean b=false;
    	     char[] S=s.toCharArray();
	       int[][] dp=new int[n][n];
	       boolean[][] p=new boolean[n][n];
	       for(int i=0;i<n;i++)p[i][i]=true;

	       for(int i=0;i<n-1;i++)
	       {
	    	   if(S[i]==S[i+1])
	    	   {
	    		p[i][i+1]=true;
	    		dp[i][i+1]=1;
	    		b=true;
	    	   }
	       }

	       for(int gap=2;gap<n;gap++)
	       {
	    	   for(int i=0;i<n-gap;i++)
	    	   {
	    		   int j=gap+i;
	    		   if(S[i]==S[j]&&p[i+1][j-1]){p[i][j]=true;}

	    		  if(p[i][j])
	    			   dp[i][j]=dp[i][j-1]+dp[i+1][j]+1-dp[i+1][j-1];

	    		   else  dp[i][j]=dp[i][j-1]+dp[i+1][j]-dp[i+1][j-1];

	    		   if(dp[i][j]>=1){b=true;}
	    	   }
	       }

	    return b;
   // return dp[0][n-1];

    }

public static int gcd(int a,int b)
{
	int res=1;
	while(a>0)
	{
		res=a;
		a=b%a;
		b=res;
	}
	return res;
}

public static long pow(long n,long p,long m)
{
	 long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    if(result>=m)
	    result%=m;
	    p >>=1;
	    n*=n;
	    if(n>=m)
	    n%=m;
	}
	return result;
}
public static long pow(long n,long p)
{
	long  result = 1;
	  if(p==0)
	    return 1;
	if (p==1)
	    return n;
	while(p!=0)
	{
	    if(p%2==1)
	        result *= n;
	    p >>=1;
	    n*=n;
	}
	return result;

}

static class Edge implements Comparator<Edge> {
	private int u;
	private int v;
	private int w;
	public Edge() {
	}
	public Edge(int u, int v, int w) {
		this.u=u;
		this.v=v;
		this.w=w;
	}
	public int getU() {
		return u;
	}
	public void setU(int u) {
		this.u = u;
	}
	public int getV() {
		return v;
	}
	public void setV(int v) {
		this.v = v;
	}
	public int getW() {
		return w;
	}
	public void setW(int w) {
		this.w = w;
	      }
	public int compareTo(Edge e)
	  {
		return this.getW() - e.getW();
	}
	@Override
	public String toString() {
		return "Edge [u=" + u + ", v=" + v + ", w=" + w + "]";
	}
	@Override
	public int compare(Edge arg0, Edge arg1) {
		// TODO Auto-generated method stub
		return 0;
	}
}

static class Pair implements Comparable<Pair>
{
	int a,b;
	Pair (int a,int b)
	{
		this.a=a;
		this.b=b;
	}

	public int compareTo(Pair o) {
		// TODO Auto-generated method stub
		if(this.a!=o.a)
		return -Integer.compare(this.a,o.a);
		else
			return -Integer.compare(this.b, o.b);
		//return 0;
	}
	public boolean equals(Object o) {
       if (o instanceof Pair) {
           Pair p = (Pair)o;
           return p.a == a && p.b == b;
       }
       return false;
   }
   public int hashCode() {
       return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
   }
}

static  class InputReader
{
   private InputStream stream;
   private byte[] buf = new byte[1024];

   private SpaceCharFilter filter;
    byte inbuffer[] = new byte[1024];
   int lenbuffer = 0, ptrbuffer = 0;
    final int M = (int) 1e9 + 7;
   int md=(int)(1e7+1);
    int[] SMP=new int[md];
   final double eps = 1e-6;
   final double pi = Math.PI;

	PrintWriter out;
   String check = "";
 InputStream   obj = check.isEmpty() ? System.in : new ByteArrayInputStream(check.getBytes());
   public InputReader(InputStream stream)
   {
       this.stream = stream;
   }

    int readByte() {
	        if (lenbuffer == -1) throw new InputMismatchException();
	        if (ptrbuffer >= lenbuffer) {
	            ptrbuffer = 0;
	            try {
	                lenbuffer = obj.read(inbuffer);
	            } catch (IOException e) {
	                throw new InputMismatchException();
	            }
	        }
	        if (lenbuffer <= 0) return -1;
	        return inbuffer[ptrbuffer++];
   }

   public  int read()
   {
       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;
   }

   String is() {
	        int b = skip();
	        StringBuilder sb = new StringBuilder();
	        while (!(isSpaceChar(b))) // when nextLine, (isSpaceChar(b) && b!=' ')
	        {
	            sb.appendCodePoint(b);
	            b = readByte();
	        }
	        return sb.toString();
   }
   public   int ii() {
	        int num = 0, b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }
 public   long il() {
	        long num = 0;
	        int b;
	        boolean minus = false;
	        while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
	        if (b == '-') {
	            minus = true;
	            b = readByte();
	        }
	        while (true) {
	            if (b >= '0' && b <= '9') {
	                num = num * 10 + (b - '0');
	            } else {
	                return minus ? -num : num;
	            }
	            b = readByte();
	        }
   }

	    boolean isSpaceChar(int c) {
	        return (!(c >= 33 && c <= 126));
	       }

	      int skip()
	        {
	        int b;
	        while ((b = readByte()) != -1 && isSpaceChar(b)) ;
	        return b;
	        }

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

	    double id() {
	        return Double.parseDouble(is());
	    }

	    char ic() {
	        return (char) skip();
	    }

	    int[] iia(int n) {
	        int a[] = new int[n];
	        for (int i = 0; i<n; i++) a[i] = ii();
	        return a;
	    }

	    long[] ila(int n) {
	        long a[] = new long[n];
	        for (int i = 0; i <n; i++) a[i] = il();
	        return a;
	    }

	    String[] isa(int n) {
	        String a[] = new String[n];
	        for (int i = 0; i < n; i++) a[i] = is();
	        return a;
	    }

		 long mul(long a, long b) { return a * b % M; }

			long div(long a, long b)
				 {
					return mul(a, pow(b, M - 2));

		           }

	    double[][] idm(int n, int m) {
	        double a[][] = new double[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = id();
	        return a;
	        }

	    int[][] iim(int n, int m) {
	        int a[][] = new int[n][m];
	        for (int i = 0; i < n; i++) for (int j = 0; j <m; j++) a[i][j] = ii();
	        return a;
          }

   public String readLine() {
       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 interface SpaceCharFilter
   {
       public boolean isSpaceChar(int ch);
   }
   public boolean isEndOfLine(int c) {
       return c == '\n' || c == '\r' || c == -1;
   }
}

}

import java.util.Scanner;

public class Demo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);

		int x1=in.nextInt();
		int x2=in.nextInt();
		int y1=in.nextInt();
		int y2=in.nextInt();
		int sum=8+2*(Math.abs(x1-x2)-1)+2*(Math.abs(y1-y2)-1);
		if(x1==x2)
			sum=8+2*(Math.abs(y1-y2)-1);
		if(y1==y2)
			sum=8+2*(Math.abs(x1-x2)-1);

		in.close();
		System.out.println(sum);
	}
}

import java.util.*;
public class Hack_Earth {
	public static void main(String[] arg){
		Scanner scan = new Scanner(System.in);
		int x1=scan.nextInt();
		int y1=scan.nextInt();
		int x2=scan.nextInt();
		int y2=scan.nextInt();
		int sum=0;
		if(y2>y1)
			sum+=y2-y1+1;
		else if(y2==y1)
			sum+=1;
		else
			sum+=y1-y2+1;

		if(x2>x1)
			sum+=x2-x1+1;
		else if(x2==x1)
			sum+=2;
		else
			sum+=x1-x2+1;
		System.out.println(2*sum);

		scan.close();
	}
}

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

public class Quad {
    static BufferedReader in;

    public static void solve() throws IOException {
        Integer[] quad = nextArray(2);
        Integer[] flag = nextArray(2);

        if(quad[0] != flag[0] && quad[1] != flag[1]){
            int one = 2*(Math.abs(quad[0] - flag[0]) + 1);
            int two = 2*(Math.abs(quad[1] - flag[1]) + 1);

            System.out.println(one+two);
            return;
        }

        int tmp =Math.max(quad[0] - flag[0], quad[1] - flag[1])+6;

        System.out.println(tmp);

    }

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

    static int nextInt() throws IOException {
        return Integer.parseInt(in.readLine().trim());

    }

    static long nextLong() throws IOException {
        return Long.parseLong(in.readLine().trim());
    }

    static Integer[] nextArray(int n) throws IOException {
        StringTokenizer st = new StringTokenizer(in.readLine());
        Integer[] tmp = new Integer[n];
        for (int i = 0; i < tmp.length; i++) {
            tmp[i] = Integer.parseInt(st.nextToken());
        }

        return tmp;
    }

    static Integer[] nextLinesArray(int n) throws IOException {
        StringTokenizer st;
        Integer[] tmp = new Integer[n];
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(in.readLine().trim());
            tmp[i] = Integer.parseInt(st.nextToken());
        }

        return tmp;
    }

}

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

public class Quad {
    static BufferedReader in;

    public static void solve() throws IOException {
        Integer[] quad = nextArray(2);
        Integer[] flag = nextArray(2);

        if(quad[0] != flag[0] && quad[1] != flag[1]){
            int one = 2*(Math.abs(quad[0] - flag[0]) + 1);
            int two = 2*(Math.abs(quad[1] - flag[1]) + 1);

            System.out.println(one+two);
            return;
        }

        int tmp =4*Math.max(quad[0] - flag[0], quad[1] - flag[1])+4;

        System.out.println(tmp);

    }

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

    static int nextInt() throws IOException {
        return Integer.parseInt(in.readLine().trim());

    }

    static long nextLong() throws IOException {
        return Long.parseLong(in.readLine().trim());
    }

    static Integer[] nextArray(int n) throws IOException {
        StringTokenizer st = new StringTokenizer(in.readLine());
        Integer[] tmp = new Integer[n];
        for (int i = 0; i < tmp.length; i++) {
            tmp[i] = Integer.parseInt(st.nextToken());
        }

        return tmp;
    }

    static Integer[] nextLinesArray(int n) throws IOException {
        StringTokenizer st;
        Integer[] tmp = new Integer[n];
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(in.readLine().trim());
            tmp[i] = Integer.parseInt(st.nextToken());
        }

        return tmp;
    }

}

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

public class Quad {
    static BufferedReader in;

    public static void solve() throws IOException {
        Integer[] quad = nextArray(2);
        Integer[] flag = nextArray(2);

        if(quad[0] != flag[0] && quad[1] != flag[1]){
            int one = 2*(Math.abs(quad[0] - flag[0]) + 1);
            int two = 2*(Math.abs(quad[1] - flag[1]) + 1);

            System.out.println(one+two);
            return;
        }

        int tmp =2*Math.max(quad[0] - flag[0], quad[1] - flag[1])+6;

        System.out.println(tmp);

    }

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

    static int nextInt() throws IOException {
        return Integer.parseInt(in.readLine().trim());

    }

    static long nextLong() throws IOException {
        return Long.parseLong(in.readLine().trim());
    }

    static Integer[] nextArray(int n) throws IOException {
        StringTokenizer st = new StringTokenizer(in.readLine());
        Integer[] tmp = new Integer[n];
        for (int i = 0; i < tmp.length; i++) {
            tmp[i] = Integer.parseInt(st.nextToken());
        }

        return tmp;
    }

    static Integer[] nextLinesArray(int n) throws IOException {
        StringTokenizer st;
        Integer[] tmp = new Integer[n];
        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(in.readLine().trim());
            tmp[i] = Integer.parseInt(st.nextToken());
        }

        return tmp;
    }

}

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

public class Main {

    public static void main(String[] args) {
        new M().solve();
    }
}

class M{

    Scanner in = new Scanner(new BufferedInputStream(System.in)) ;
    PrintWriter out = new PrintWriter(System.out) ;

    void solve(){
        P o = new P(in.nextInt() , in.nextInt()) ;
        int x2 = in.nextInt() ;
        int y2 = in.nextInt() ;
        P[] ps = {new P(x2-1,y2-1),new P(x2-1,y2+1),new P(x2+1,y2-1),new P(x2+1,y2+1)} ;
        int res = 0 ;
        for(int i = 0 ; i < ps.length ; i++){
            res = Math.max(res , o.dis(ps[i])) ;
        }
        out.println(Math.max(8 , res*2));
        out.flush();
    }
}

class P{
    int x ;
    int y ;
    P(int x , int y){
        this.x = x ;
        this.y = y ;
    }
    int dis(P o){
        return Math.abs(this.x - o.x) + Math.abs(this.y - o.y) ;
    }
}

import java.util.Scanner;

public class Problem883M {
    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[][] moves = {{-1, -1}, {1, 1}, {1, -1}, {-1, 1}};
        int[][] moves2 = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};

        boolean onPath = false;
        for (int i = 0; i < 4; i++) {
            int x = x2 + moves2[i][0];
            int y = y2 + moves2[i][1];

            if (x1 == x && y1 == y) onPath = true;
        }
        if (onPath) {
            System.out.println(8);
            return;
        }

        int min = Integer.MAX_VALUE;
        for (int i = 0; i < moves.length; i++) {
            int x = x2 + moves[i][0];
            int y = y2 + moves[i][1];

            int d = Math.abs(x - x1) + Math.abs(y - y1);
//            System.out.println("x = " + x + " y = " + y + " d = " + d);
            min = Math.min(min, d);
        }
        int res = (min * 2) + 8;
        System.out.println(res);
    }
}

 import java.util.Scanner;
public class Copter{
    public static void main( String[] args ){
        Scanner coordScan = new Scanner(System.in);
        String[] badCopterCoords = coordScan.nextLine().split( " " );
        String[] badFlagCoords = coordScan.nextLine().split( " " );
        int[] copterCoords = new int[2];
        int[] flagCoords = new int[2];
        for( int i = 0 ; i < 2 ; i++ ){
            copterCoords[i] = Integer.parseInt( badCopterCoords[i] );
            flagCoords[i] = Integer.parseInt( badFlagCoords[i] );
        }
        System.out.println( ( 4+2*Math.abs(copterCoords[0]-flagCoords[0] )+2*Math.abs(copterCoords[1]-flagCoords[1]) ) );
    }
}

import java.util.Scanner;
public class Copter{
    public static void main( String[] args ){
        Scanner coordScan = new Scanner(System.in);
        String[] badCopterCoords = coordScan.nextLine().split( " " );
        String[] badFlagCoords = coordScan.nextLine().split( " " );
        int[] copterCoords = new int[2];
        int[] flagCoords = new int[2];
        for( int i = 0 ; i < 2 ; i++ ){
            copterCoords[i] = Integer.parseInt( badCopterCoords[i] );
            flagCoords[i] = Integer.parseInt( badFlagCoords[i] );
        }
        System.out.println( ( Math.abs(copterCoords[0]-flagCoords[0] )+Math.abs(copterCoords[1]-flagCoords[1]) ) );
    }
}

import java.util.Scanner;
public class Copter{
    public static void main( String[] args ){
        Scanner coordScan = new Scanner(System.in);
        String[] badCopterCoords = coordScan.nextLine().split( " " );
        String[] badFlagCoords = coordScan.nextLine().split( " " );
        int[] copterCoords = new int[2];
        int[] flagCoords = new int[2];
        for( int i = 0 ; i < 2 ; i++ ){
            copterCoords[i] = Integer.parseInt( badCopterCoords[i] );
            flagCoords[i] = Integer.parseInt( badFlagCoords[i] );
        }
        System.out.println( ( 2+2*Math.abs(copterCoords[0]-flagCoords[0] )+2*Math.abs(copterCoords[1]-flagCoords[1]) ) );
    }
}

import java.util.*;
import java.util.Map.Entry;
import java.lang.*;
import java.math.*;
import java.text.*;
import java.io.*;
		public final class Solution {
		static PrintWriter out = new PrintWriter(System.out);
		static void flush() {
	 	out.flush();
	 	}
		static class FastReader {
	    BufferedReader br;
	    StringTokenizer st;

	    public FastReader() {
	    br = new BufferedReader(new
	    InputStreamReader(System.in));
	    }
	    static boolean isPalindrome(String str1, String str2) {
	    String str3 = str1+str2;
	    int i = 0, j = str3.length()-1;
	    while(i < j) {
	    char a = str3.charAt(i), b = str3.charAt(j);
	    if(a != b) return false;
	    i++;j--;
	    }
	    return true;
	    }
	    static boolean isPalindrome(String str) {
	    int i = 0, j = str.length()-1;
	    while(i < j) {
	    char a = str.charAt(i), b = str.charAt(j);
	    if(a != b) return false;
	    i++;j--;
	    }
	    return true;
	    }
	    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());}
	    static int fact(int n) {
	    if(n == 1) return 1;
	    return n * fact(n-1);
	   	}
	    public int[] readIntArray(int n) {
	    int[] arr = new int[n];
		for(int i=0; i<n; ++i)
		arr[i]=nextInt();
		return arr;
		}
	    public int[][] readIntArray(int m, int n){
		int[][] arr = new int[m][n];
		for(int i = 0;i<m;i++)
		for(int j = 0;j<n;j++)
		arr[i][j] = nextInt();
		return arr;
	    }
	    public String[] readStringArray(int n) {
		String[] arr = new String[n];
		for(int i=0; i<n; ++i)
		arr[i]= nextLine();
		return arr;
	    }
		static int gcd(int a, int b) {
		if (b == 0) return a;
		return gcd(b, a % b);
		}
	    double nextDouble() {return Double.parseDouble(next());}
	    String nextLine() {
	    String str = "";
	    try{str = br.readLine();}
	    catch (IOException e) {e.printStackTrace();}
	    return str;}
	    }

		static int solve(int x1, int y1, int x2, int y2) {
			if(x1 == x2 || y1 == y2) {
				return ((int)Math.pow(Math.abs(x2) - Math.abs(x1), 2) +((int)Math.pow(Math.abs(y2) - Math.abs(y1)
						, 2))) * 4 + 4;
			}
			int r = Math.abs(x1 - x2) + 1;
			int s = Math.abs(y1 -y2) + 1;

			return r*2 + s*2;
		}
		public static void main(String args[]) throws Exception {
	    FastReader sc = new FastReader();
	    long start = System.currentTimeMillis();
	    int x1 = sc.nextInt(), y1 = sc.nextInt();
	    int x2 = sc.nextInt(), y2 = sc.nextInt();
	    out.println(solve(x1, y1, x2, y2));
	    flush();
	    long end = System.currentTimeMillis();
	    NumberFormat formatter = new DecimalFormat("#0.00000");
	    //System.out.print("Execution time is " + formatter.format((end - start) / 1000d) + " seconds");
	    }
	}

import java.util.*;
import java.util.Map.Entry;
import java.lang.*;
import java.math.*;
import java.text.*;
import java.io.*;
		public final class Solution {
		static PrintWriter out = new PrintWriter(System.out);
		static void flush() {
	 	out.flush();
	 	}
		static class FastReader {
	    BufferedReader br;
	    StringTokenizer st;

	    public FastReader() {
	    br = new BufferedReader(new
	    InputStreamReader(System.in));
	    }
	    static boolean isPalindrome(String str1, String str2) {
	    String str3 = str1+str2;
	    int i = 0, j = str3.length()-1;
	    while(i < j) {
	    char a = str3.charAt(i), b = str3.charAt(j);
	    if(a != b) return false;
	    i++;j--;
	    }
	    return true;
	    }
	    static boolean isPalindrome(String str) {
	    int i = 0, j = str.length()-1;
	    while(i < j) {
	    char a = str.charAt(i), b = str.charAt(j);
	    if(a != b) return false;
	    i++;j--;
	    }
	    return true;
	    }
	    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());}
	    static int fact(int n) {
	    if(n == 1) return 1;
	    return n * fact(n-1);
	   	}
	    public int[] readIntArray(int n) {
	    int[] arr = new int[n];
		for(int i=0; i<n; ++i)
		arr[i]=nextInt();
		return arr;
		}
	    public int[][] readIntArray(int m, int n){
		int[][] arr = new int[m][n];
		for(int i = 0;i<m;i++)
		for(int j = 0;j<n;j++)
		arr[i][j] = nextInt();
		return arr;
	    }
	    public String[] readStringArray(int n) {
		String[] arr = new String[n];
		for(int i=0; i<n; ++i)
		arr[i]= nextLine();
		return arr;
	    }
		static int gcd(int a, int b) {
		if (b == 0) return a;
		return gcd(b, a % b);
		}
	    double nextDouble() {return Double.parseDouble(next());}
	    String nextLine() {
	    String str = "";
	    try{str = br.readLine();}
	    catch (IOException e) {e.printStackTrace();}
	    return str;}
	    }

		static int solve(int x1, int y1, int x2, int y2) {
			if(x1 == x2 || y1 == y2) {
				return ((int)Math.pow(Math.abs(x2) - Math.abs(x1), 2) +((int)Math.pow(Math.abs(y2) - Math.abs(y1)
						, 2))) * 4 + 4;
			}
			int r = Math.abs(Math.abs(x1) - Math.abs(x2)) + 1;
			int s = Math.abs(Math.abs(y1) - Math.abs(y2)) + 1;

			return r*2 + s*2;
		}
		public static void main(String args[]) throws Exception {
	    FastReader sc = new FastReader();
	    long start = System.currentTimeMillis();
	    int x1 = sc.nextInt(), y1 = sc.nextInt();
	    int x2 = sc.nextInt(), y2 = sc.nextInt();
	    out.println(solve(x1, y1, x2, y2));
	    flush();
	    long end = System.currentTimeMillis();
	    NumberFormat formatter = new DecimalFormat("#0.00000");
	    //System.out.print("Execution time is " + formatter.format((end - start) / 1000d) + " seconds");
	    }
	}

import java.math.BigInteger;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int x1,y1,x2,y2;
        x1 = input.nextInt();
        y1 = input.nextInt();
        x2 = input.nextInt();
        y2 = input.nextInt();
        long ans1 = (Math.abs(x2-x1)+1)*2;
        long ans2 = (Math.abs(y2-y1)+1)*2;

        if(x2==0&&y2==0)
        {
            System.out.println(Math.max(ans1, ans2)*2);
            return;
        }
        System.out.println(ans1+ans2);

    }

}

import java.math.BigInteger;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int x1,y1,x2,y2;
        x1 = input.nextInt();
        y1 = input.nextInt();
        x2 = input.nextInt();
        y2 = input.nextInt();
        long ans1 = (Math.abs(x2-x1)+1)*2;
        long ans2 = (Math.abs(y2-y1)+1)*2;
        System.out.println(ans1+" "+ans2);
        if(x2==0&&y2==0)
        {
            System.out.println(Math.max(ans1, ans2)*2);
            return;
        }
        System.out.println(ans1+ans2);

    }

}