Fox Ciel has some flowers: r red flowers, g green flowers and b blue flowers. She wants to use these flowers to make several bouquets. There are 4 types of bouquets:

  * To make a "red bouquet", it needs 3 red flowers. 
  * To make a "green bouquet", it needs 3 green flowers. 
  * To make a "blue bouquet", it needs 3 blue flowers. 
  * To make a "mixing bouquet", it needs 1 red, 1 green and 1 blue flower. 



Help Fox Ciel to find the maximal number of bouquets she can make.

Input

The first line contains three integers r, g and b (0 ≤ r, g, b ≤ 109) — the number of red, green and blue flowers.

Output

Print the maximal number of bouquets Fox Ciel can make.

Examples

Input

3 6 9


Output

6


Input

4 4 4


Output

4


Input

0 0 0


Output

0

Note

In test case 1, we can make 1 red bouquet, 2 green bouquets and 3 blue bouquets.

In test case 2, we can make 1 red, 1 green, 1 blue and 1 mixing bouquet.
import java.io.*;
import java.lang.*;
import java.util.*;

public class Main
{
	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 r = new FastReader();

		int[] list = new int[3];
		list[0] = r.nextInt();
		list[1] = r.nextInt();
		list[2] = r.nextInt();
		
		Arrays.sort(list);
		int count = 0;
		int temp1 = ((list[1] - list[0])/3);
		int temp2= ((list[2] - list[0])/3);

		list[1] = list[1] - 3*temp1;
		list[2] = list[2] - 3*temp2;

		count = count + temp1 + temp2;

		if((list[1]-list[0]==2)&&(list[2]-list[0]==2)&&(list[0]>=1))
		{
			count = count + 1 + list[0];
		}
		else
		{
			count = count + list[0];
		}
		System.out.println(count);
	}
} 

class Node implements Comparable<Node>
{
	int index;
	int weight;
	ArrayList<Node> neighbours;

	public Node(int index, int weight)
	{
		this.index = index;
		this.weight = weight;
		this.neighbours = new ArrayList<>();
	}

	public int compareTo(Node y)
	{
		return -(this.weight - y.weight);
	}
}

class Graph
{
	int V, E;
	Node[] nodes;
	Graph(int V, int E)
	{
		this.V = V;
		this.E = E;
		nodes = new Node[this.V];
	}

}
