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();
    //sc.nextLine();
    int x2=sc.nextInt();
    int y2=sc.nextInt();
    int verticalDistance=Math.abs(x2-x1)+1;
    int horizontalDistance=Math.abs(y2-y1)+1;
    if(y1==y2)
        verticalDistance++;
    if(x2==x1)
        horizontalDistance++;
    System.out.println(2*(verticalDistance+horizontalDistance));
    }
}

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

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

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

}

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

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

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

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

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

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

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

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

    }
}

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

    }

}