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


/**
 *
 * @author Saju
 *
 */

public class Main {

	private static int dx[] = { 1, 0, -1, 0 };
	private static int dy[] = { 0, -1, 0, 1 };

	private static final long INF = Long.MAX_VALUE;
	private static final int INT_INF = Integer.MAX_VALUE;
	private static final long NEG_INF = Long.MIN_VALUE;
	private static final int NEG_INT_INF = Integer.MIN_VALUE;
	private static final double EPSILON = 1e-10;

	private static final int MAX = 3007;
	
	private static final long MOD = 1000000007;

	private static final int MAXN = 10000007;
	private static final int MAXA = 10000009;
	private static final int MAXLOG = 22;

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

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

//		 InputReader in = new InputReader(new FileInputStream("src/test.in"));
//		 PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("src/test.out")));



/*



*/
		
		long r = in.nextLong();
		long g = in.nextLong();
		long b = in.nextLong();
		
		
		long min = min(r, min(g, b));
		
		if (min >= 3) {
			long r1 = r - min;
			long g1 = g - min;
			long b1 = b - min;
			long max = min;
			max += r1 / 3;
			max += g1 / 3;
			max += b1 / 3;
			
			long max2 = min - 1;
			r1 = r - max2;
			g1 = g - max2;
			b1 = b - max2;
			max2 += r1 / 3;
			max2 += g1 / 3;
			max2 += b1 / 3;
//			System.out.println(max2 + " " + r1 + " " + g1 + " " + b1);
			long max3 = min - 2;
			r1 = r - max3;
			g1 = g - max3;
			b1 = b - max3;
			max3 += r1 / 3;
			max3 += g1 / 3;
			max3 += b1 / 3;
//			System.out.println(max3);
			out.println(max(max, max(max2, max3)));
		}
		else {
			r = r - min;
			g = g - min;
			b = b - min;
			min += r / 3;
			min += g / 3;
			min += b / 3;
			out.println(min);
		}
		
		out.flush();
		out.close();
		System.exit(0);
	}
	
	private static int ceil(int n, int x) {
		int div = n / x;
		if(div * x != n) {
			div++;
		}
		return div;
	}

	private static class Point {
		double x;
		double y;

		Point(double x, double y) {
			this.x = x;
			this.y = y;
		}

		double getDistance(Point p2) {
			Point p1 = this;
			double dx = p1.x - p2.x;
			double dy = p1.y - p2.y;

			return Math.sqrt((dx * dx) + (dy * dy));
		}
	}

	private static int abs(int x) {
		if (x < 0) {
			return -x;
		}
		return x;
	}

	private static long abs(long x) {
		if(x < 0) {
			return -x;
		}
		return x;
	}

	private static int lcm(int a, int b) {
		return (a * b) / gcd(a, b);
	}

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

	private static int log(long x, int base) {
		return (int) (Math.log(x) / Math.log(base));
	}

	private static long min(long a, long b) {
		if (a < b) {
			return a;
		}
		return b;
	}

	private static int min(int a, int b) {
		if (a < b) {
			return a;
		}
		return b;
	}

	private static long max(long a, long b) {
		if (a < b) {
			return b;
		}
		return a;
	}

	private static int max(int a, int b) {
		if (a < b) {
			return b;
		}
		return a;
	}

	private static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream));
			tokenizer = null;
		}

		public String next() {
			try {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					tokenizer = new StringTokenizer(reader.readLine());

				}
			} catch (IOException e) {
				return null;
			}
			return tokenizer.nextToken();
		}

		public String nextLine() {
			String line = null;
			try {
				tokenizer = null;
				line = reader.readLine();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			return line;
		}

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

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

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

		public boolean hasNext() {
			try {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					tokenizer = new StringTokenizer(reader.readLine());
				}
			} catch (Exception e) {
				return false;
			}
			return true;
		}
	}
}