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


public class Flowers {
	
	public static void main(String[] args) throws java.lang.Exception {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(in, out);
		out.close();
	}
}

class TaskA {
	int[][][] dp = new int[10][10][10];
	
	public void solve(InputReader in, PrintWriter out) {
		int r = in.nextInt(), g = in.nextInt(), b = in.nextInt();
		for (int i=0; i<=3; ++i) {
			for (int j=0; j<=3; ++j) {
				for (int k=0; k<=3; ++k) {
					dp[i+1][j+1][k+1] = max(dp[i+1][j+1][k+1], dp[i][j][k]+1);
					dp[i+3][j][k] = max(dp[i+3][j][k], dp[i][j][k]+1);
					dp[i][j+3][k] = max(dp[i][j+3][k], dp[i][j][k]+1);
					dp[i][j][k+3] = max(dp[i][j][k+3], dp[i][j][k]+1);
				}
			}
		}
		
		int ans = 0;
		
		if (r > 0) {
			ans += r / 3;
			r %= 3;
			if (r == 0) {
				r = 3;
				--ans;
			}
		}
		
		if (g > 0) {
			ans += g / 3;
			g %= 3;
			if (g == 0) {
				g = 3;
				--ans;
			}
		}
		
		if (b > 0) {
			ans += b / 3;
			b %= 3;
			if (b == 0) {
				b = 3;
				--ans;
			}
		}
		
		ans += dp[r][g][b];
		out.println(ans);
	}
	
	private int max(int x, int y) {
		return x > y ? x:y;
	}
}

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