Alice and Bob are decorating a Christmas Tree. 

Alice wants only $3$ types of ornaments to be used on the Christmas Tree: yellow, blue and red. They have $y$ yellow ornaments, $b$ blue ornaments and $r$ red ornaments.

In Bob's opinion, a Christmas Tree will be beautiful if:  the number of blue ornaments used is greater by exactly $1$ than the number of yellow ornaments, and  the number of red ornaments used is greater by exactly $1$ than the number of blue ornaments. 

That is, if they have $8$ yellow ornaments, $13$ blue ornaments and $9$ red ornaments, we can choose $4$ yellow, $5$ blue and $6$ red ornaments ($5=4+1$ and $6=5+1$).

Alice wants to choose as many ornaments as possible, but she also wants the Christmas Tree to be beautiful according to Bob's opinion.

In the example two paragraphs above, we would choose $7$ yellow, $8$ blue and $9$ red ornaments. If we do it, we will use $7+8+9=24$ ornaments. That is the maximum number.

Since Alice and Bob are busy with preparing food to the New Year's Eve, they are asking you to find out the maximum number of ornaments that can be used in their beautiful Christmas Tree! 

It is guaranteed that it is possible to choose at least $6$ ($1+2+3=6$) ornaments.


-----Input-----

The only line contains three integers $y$, $b$, $r$ ($1 \leq y \leq 100$, $2 \leq b \leq 100$, $3 \leq r \leq 100$) — the number of yellow, blue and red ornaments. 

It is guaranteed that it is possible to choose at least $6$ ($1+2+3=6$) ornaments.


-----Output-----

Print one number — the maximum number of ornaments that can be used. 


-----Examples-----
Input
8 13 9

Output
24
Input
13 3 6

Output
9


-----Note-----

In the first example, the answer is $7+8+9=24$.

In the second example, the answer is $2+3+4=9$.

Difficulty: EASY

Solutions:
(A, B, C) = map(int, input().split())
if B >= C:
	B = C - 1
if A < B - 1:
	B = A + 1
print(3 * B)


(y, b, r) = map(int, input().split())
x = min(y + 2, b + 1, r)
print(x * 3 - 3)


(y, b, r) = map(int, input().split())
y = y + 1
r -= 1
print(3 * min(y, b, r))


a = []
a = input().split()
for i in range(3):
	a[i] = int(a[i])
for i in range(a[0], 0, -1):
	if i + 1 <= a[1] and i + 2 <= a[2]:
		print(i + i + i + 3)
		break


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
m = min(y, b, r)
if m == y:
	if m + 1 <= b and m + 2 <= r:
		print(3 * m + 3)
	else:
		while m + 1 > b or m + 2 > r:
			m -= 1
		print(3 * m + 3)
elif m == b:
	if m - 1 <= y and m + 1 <= r:
		print(3 * m)
	else:
		while m - 1 > y or m + 1 > r:
			m -= 1
		print(3 * m)
elif m - 1 <= b and m - 2 <= y:
	print(3 * m - 3)
else:
	while m - 1 > b or m - 2 > y:
		m -= 1
	print(3 * m - 3)


(a, b, c) = input().strip().split(' ')
a = int(a)
b = int(b)
c = int(c)
print(min(a, b - 1, c - 2) * 3 + 3)


import sys
pin = sys.stdin.readline
pout = sys.stdout.write
total = list(map(int, pin().split()))
print(min(total[0] + 2, min(total[1] + 1, total[2])) * 3 - 3)


(a, b, c) = [int(x) for x in input().split()]
mi = min(a, b, c)
if mi == c:
	print(c + (c - 1) + (c - 2))
elif mi == b:
	print(b - 1 + b + (b + 1))
elif mi == c - 1:
	print(a + (a - 1) + (a + 1))
else:
	print(a + (a + 1) + (a + 2))


(y, b, r) = map(int, input().split())
print(min(y + 2 + y + 1 + y, b - 1 + b + b + 1, r - 2 + r - 1 + r))


from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import combinations
import functools
import sys
import math
MAX = sys.maxsize
MAXN = 10 ** 6 + 10
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b, x, y):
	return abs(a - x) + abs(b - y)

def numIN():
	return map(int, sys.stdin.readline().strip().split())

def charIN():
	return sys.stdin.readline().strip().split()
t = [0] * 1000010

def create(a, n):
	global t
	for i in range(n, 2 * n):
		t[i] = a[i - n]
	for i in range(n - 1, 0, -1):
		t[i] = t[2 * i] + t[2 * i + 1]

def ncr(n, k):
	res = 1
	c = [0] * (k + 1)
	c[0] = 1
	for i in range(1, n + 1):
		for j in range(min(i, k), 0, -1):
			c[j] = (c[j] + c[j - 1]) % MOD
	return c[k]
(y, b, r) = numIN()
for i in range(y, 0, -1):
	if b >= i + 1 and r >= i + 2:
		print(i + i + 1 + i + 2)
		exit(0)


from sys import stdin
(y, b, r) = map(int, stdin.readline().split())
minC = min(y, b, r)
sum = 6
y -= 1
r -= 3
b -= 2
while y > 0 and b > 0 and (r > 0):
	sum += 3
	y -= 1
	b -= 1
	r -= 1
print(sum)


(y, b, r) = map(int, input().strip().split(' '))
mi = min(y, b, r)
yy = 1
bb = 2
rr = 3
for i in range(mi):
	if yy + 1 <= y and bb + 1 <= b and (rr + 1 <= r):
		yy = yy + 1
		bb = bb + 1
		rr = rr + 1
	else:
		print(yy + bb + rr)
		break


(y, b, r) = map(int, input().strip().split())
for i in range(y, 0, -1):
	if b - i >= 1 and r - i >= 2:
		ans = 3 * i + 3
		break
print(ans)


(y, b, r) = [int(i) for i in input().split()]
m = min(y, b, r)
res = 0
if r == m:
	res = 3 * r - 3
elif b == m:
	res = 3 * b
elif r > b or r - y >= 2:
	res = 3 * y + 3
else:
	res = 3 * (y - 1) + 3
print(res)


(y, b, r) = list(map(int, input().split()))
for i in range(101, -1, -1):
	if i <= y and i + 1 <= b and (i + 2 <= r):
		print(3 * i + 3)
		exit(0)
print(0)


(y, b, r) = map(int, input().split())
L = [y, b - 1, r - 2].index(min([y, b - 1, r - 2]))
if L == 0:
	print(3 * y + 3)
elif L == 1:
	print(3 * b)
else:
	print(3 * r - 3)


(y, b, r) = map(int, input().split())
k = 0
for i in range(1000):
	if i <= y and i + 1 <= b and (i + 2 <= r):
		k = i
print(3 * k + 3)


import math
import sys
DEBUG = False

def inp():
	return sys.stdin.readline().rstrip()

def dprint(*value, sep=' ', end='\n'):
	if DEBUG:
		print(*value, sep=sep, end=end)

def main():
	(Y, B, R) = [int(e) for e in inp().split()]
	best = 0
	for r in range(3, 101):
		b = r - 1
		y = b - 1
		if y <= Y and b <= B and (r <= R):
			best = y + b + r
	print(best)
main()


(y, b, r) = map(int, input().split())
while True:
	if y + 1 <= b and y + 2 <= r:
		print(3 * y + 3)
		exit()
	y -= 1


(y, b, r) = map(int, input().split())
if y < b - 1:
	y = y
else:
	y = b - 1
if y < r - 2:
	y = y
else:
	y = r - 2
print(3 * y + 3)


(y, b, r) = list(map(int, input().split()))
minNum = min(y, b, r)
if y == minNum:
	if b == minNum:
		if r == minNum:
			y = y - 2
		else:
			y = y - 1
	elif r == minNum:
		y = y - 2
	elif r == minNum + 1:
		y = y - 1
elif b == minNum:
	if r == minNum:
		y = b - 2
	else:
		y = b - 1
else:
	y = r - 2
print(3 * y + 3)


(y, b, r) = [int(x) for x in input().split()]
y += 1
r -= 1
m = min(y, b, r)
print(3 * m)


R = lambda : map(int, input().split())
(y, b, r) = R()
t = min(y + 2, b + 1, r)
if t == y + 2:
	print(3 * y + 3)
elif t == b + 1:
	print(3 * b)
else:
	print(3 * r - 3)


(y, b, r) = map(int, input().split())
m = 0
for i in range(y + 1):
	for j in range(b + 1):
		for k in range(r + 1):
			if k == j + 1 == i + 2 and k + j + i > m:
				m = k + j + i
print(m)


a = list(map(int, input().split()))
a = a[::-1]
mi = min(a)
x = a.index(mi)
if x == 0:
	print(mi + mi - 1 + mi - 2)
elif x == 1:
	print(mi + 1 + mi + mi - 1)
elif x == 2:
	if a[0] >= mi + 2:
		print(mi + 2 + mi + 1 + mi)
	elif a[0] == mi + 1:
		print(mi + 1 + mi + mi - 1)


import math
(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
if r - 1 <= b and r - 2 <= y:
	print(3 * r - 3)
elif b - 1 <= y and b + 1 <= r:
	print(3 * b)
else:
	print(3 * y + 3)


a = input().split()
y = int(a[0])
b = int(a[1]) - 1
r = int(a[2]) - 2
x = min(y, b, r)
print(3 * x + 3)


def answer():
	a = [int(x) for x in input().split()]
	i = 0
	while i <= a[0] and i + 1 <= a[1] and (i + 2 <= a[2]):
		i += 1
	return i * 3
print(answer())


ybr = list(map(int, input().split()))
minimum = min(ybr[0], ybr[1] - 1, ybr[2] - 2)
print(minimum * 3 + 3)


import re

def numOfOrnaments():
	roughBeginning = re.findall('\\d+', input(''))
	beginning = []
	for element in roughBeginning:
		beginning.append(int(element))
	yellow = beginning[0]
	blue = beginning[1]
	red = beginning[2]
	aggregateArray = [yellow, blue - 1, red - 2]
	baseNumber = 0
	for index in range(0, len(aggregateArray)):
		if aggregateArray[baseNumber] > aggregateArray[index]:
			baseNumber = index
	if 0 == baseNumber:
		print(3 * yellow + 3)
	elif 1 == baseNumber:
		print(3 * blue)
	elif 2 == baseNumber:
		print(3 * red - 3)
numOfOrnaments()


ybr = list(map(int, input().strip().split()))
print(6 + 3 * min(ybr[0] - 1, ybr[1] - 2, ybr[2] - 3))


s = list(map(int, input().split(' ')))
y = s[0]
b = s[1]
r = s[2]
total = 0
l = min(s)
if y == l:
	if b == y and r == y:
		total = 3 * l - 3
	elif b == y and r != y:
		total = 3 * l
	elif b != y and r == y + 1:
		total = 3 * l
	elif b != y and r != y:
		total = 3 * l + 3
	elif b != y and r == y:
		total = 3 * l - 3
elif b == l:
	if b == y and b == r:
		total = 3 * l - 3
	elif b == y and b != r:
		total = 3 * l
	elif b != y and b == r:
		total = 3 * l - 3
	elif b != y and r >= b + 1:
		total = 3 * l
elif r == l:
	total = 3 * l - 3
print(total)


(a, b, c) = map(int, input().split())
while not a + 2 == b + 1 == c:
	if c - 2 < a:
		a = c - 2
	else:
		c = a + 2
	if c - 1 < b:
		b = c - 1
	else:
		c = b + 1
print(a + b + c)


arr = list(map(int, input().split()))
y = arr[0]
b = arr[1]
r = arr[2]
x = 1
a = 2
z = 3
while x < y and z < r and (a < b):
	x = x + 1
	a = a + 1
	z = z + 1
s = x + a + z
print(s)


(y, b, r) = map(int, input().split())
m = min(y, b, r)
if m == r:
	ans = r + (r - 1) + (r - 2)
elif m == b and m + 1 > r:
	ans = r + (r - 1) + (r - 1)
elif m == b and m + 1 <= r:
	ans = b + (b - 1) + (b + 1)
elif m == y and m + 2 > r:
	ans = r + (r - 1) + (r - 2)
elif m == y and m + 2 <= r:
	ans = y + (y + 1) + (y + 2)
print(ans)


(a, b, c) = map(int, input().split())
x = min(a, b - 1, c - 2)
print(3 * x + 3)


l = list(map(int, input().split()))
print(min(l[0] * 3 + 3, l[1] * 3, l[2] * 3 - 3))


def ornaments(y, b, r):
	l = min(y, b - 1, r - 2)
	print(3 * l + 3)
(y, b, r) = map(int, input().split())
ornaments(y, b, r)


(y, b, r) = [int(i) for i in input().split()]
x = [y, b, r]
if y < b < r:
	print(3 * y + 3)
elif y == r == b:
	print(3 * r - 3)
elif min(x) == r:
	print(3 * r - 3)
elif min(x) == b and b != r:
	print(3 * b)
elif min(x) == y and y != r and (y != b):
	if b > r:
		if r - y <= 2:
			print(3 * r - 3)
		else:
			print(3 * y + 3)
	elif b == r:
		if r - y == 1:
			print(3 * r - 3)
		elif r - y > 1:
			print(3 * y + 3)


(y, b, r) = list(map(int, input().split()))
(ye, bl, re) = (r - 2, r - 1, r)
while re > r or ye > y or bl > b:
	(re, ye, bl) = (re - 1, ye - 1, bl - 1)
print(re + ye + bl)


(a, b, c) = map(int, input().split())
if c - b >= 1:
	if b - a >= 1:
		print(3 * a + 3)
	else:
		print(3 * b)
elif b - a >= 1:
	if c - a >= 2:
		print(3 * a + 3)
	else:
		print(3 * c - 3)
else:
	print(3 * c - 3)


(y, b, r) = map(int, input().split(' '))
while b >= r:
	b = b - 1
while y >= b:
	y = y - 1
while b - 1 > y:
	b = b - 1
while r - 1 > b:
	r = r - 1
print(y + b + r)


n = list(map(int, input().split()))
y = n[0]
b = n[1]
r = n[2]
x = 1
Y = 2
z = 3
while z < r and Y < b and (x < y):
	x = x + 1
	Y = Y + 1
	z = z + 1
s = x + Y + z
print(s)


(a, b, c) = map(int, input().rstrip().split())
d = c - 2 if c - 2 <= a else a
e = b - 1 if b - 1 <= a else a
print(3 * min(d, e) + 3)


(y, b, r) = list(map(int, input().split()))
if y <= b - 1 and y <= r - 2:
	print(y * 3 + 3)
elif b < y + 1 and b <= r - 1:
	print((b - 1) * 3 + 3)
else:
	print((r - 2) * 3 + 3)


(y, b, r) = map(int, input().split())

def solve(y, b, r):
	y = min([y, b, r])
	while y:
		if b >= y + 1 and r >= y + 2:
			return 3 * (y + 1)
		y -= 1
print(solve(y, b, r))


(a, b, c) = map(int, input().split())
for i in range(c, 1, -1):
	if i - 1 <= b and i - 2 <= a:
		print(3 * i - 3, '\n')
		break


(y, b, r) = map(int, input().split())
miner = min(y, b, r)
if r == miner:
	print(r + r - 1 + r - 2)
elif b == miner:
	if b + 1 > r:
		b = b - 1
	print(b - 1 + b + b + 1)
else:
	if y + 1 > b or y + 1 > r or y + 2 > r:
		y -= 1
	print(y + y + 1 + y + 2)


l = input().split()
y = int(l[0])
bl = int(l[1])
r = int(l[2])
m = int(max(l))
a = 0
b = a + 1
c = b + 1
for i in range(m + 1):
	a += 1
	b += 1
	c += 1
	if a <= y and b <= bl and (c <= r):
		v = a + b + c
	else:
		break
		v = 0
print(v)


(y, b, r) = map(int, input().split())
my_y = y
my_b = b
my_r = r
if y + 1 <= b:
	my_b = y + 1
else:
	my_y = my_b - 1
if my_b + 1 <= r:
	my_r = my_b + 1
else:
	my_b = my_r - 1
	my_y = my_b - 1
print(my_y + my_b + my_r)


(y, b, r) = [int(i) for i in input().split()]
if r >= y and b > y:
	if r == y + 1 or r == y:
		y = r - 2
		b = y + 1
		print(r + b + y)
	elif r > y + 1:
		r = y + 2
		b = y + 1
		print(y + r + b)
elif y >= b and r >= b:
	if b == r:
		y = r - 2
		b = y + 1
		r = y + 2
		print(r + b + y)
	else:
		y = b - 1
		r = b + 1
		print(y + b + r)
elif y > r and b > r:
	y = r - 2
	b = r - 1
	print(r + b + y)


def main():
	(y, b, r) = map(int, input().split())
	b -= 1
	r -= 2
	print(min(y, b, r) * 3 + 3)
main()


gi = lambda : list(map(int, input().split()))
(y, b, r) = l = gi()
ans = 0
if b < 2 or r < 3:
	print(0)
	exit()
else:
	ans = 6
	y -= 1
	b -= 2
	r -= 3
while r and b and y:
	ans += 3
	y -= 1
	r -= 1
	b -= 1
print(ans)


(y, b, r) = map(int, input().split())
y1 = 1
b1 = 2
r1 = 3
while y1 < y and b1 < b and (r1 < r):
	y1 = y1 + 1
	b1 = b1 + 1
	r1 = r1 + 1
s = y1 + b1 + r1
print(s)


(y, bl, r) = [int(x) for x in input().split()]
a = y
b = bl
c = r
h = 'True'
while h:
	b = a + 1
	c = b + 1
	if b <= bl and c <= r and (a <= y):
		print(a + b + c)
		break
	else:
		a = a - 1


def go():
	(y, b, r) = [int(i) for i in input().split(' ')]
	x = min(y, b, r)
	if x == r:
		return r + r - 1 + r - 2
	elif x == b:
		return b + 1 + b + b - 1
	elif r >= y + 2:
		return y + y + 1 + y + 2
	else:
		return y - 1 + y + y + 1
print(go())


(y, b, r) = map(int, input().split())
b = min(y + 1, b, r - 1)
if b < 0:
	print(0)
else:
	print(3 * b)


from math import *
(y, b, r) = map(int, input().split())
print(min(y + 1, b, r - 1) * 3)


(a, b, c) = map(int, input().split())
c1 = 0
while a > 0:
	if a + 1 <= b and a + 2 <= c:
		c1 = 3 * a + 3
		print(c1)
		break
	else:
		a -= 1


(y, b, r) = [int(s) for s in input().split(' ')]
print(3 * (min(r, b + 1, y + 2) - 1))


tNum = input().split()
nums = []
for n in tNum:
	nums.append(int(n))
if nums[0] >= nums[2] - 2 and nums[1] >= nums[2] - 1:
	print(nums[2] + nums[2] - 1 + nums[2] - 2)
elif nums[0] >= nums[1] - 1 and nums[2] >= nums[1] + 1:
	print(nums[1] + nums[1] - 1 + nums[1] + 1)
else:
	print(nums[0] + nums[0] + 1 + nums[0] + 2)


x = list(map(int, input().split()))
y = x[0]
b = x[1]
r = x[2]
X = 1
Y = 2
Z = 3
while Z < r and Y < b and (X < y):
	X = X + 1
	Y = Y + 1
	Z = Z + 1
print(X + Y + Z)


from operator import itemgetter
(y, b, r) = map(int, input().split())
print(min(min(y + 2, b + 1), r) * 3 - 3)


(y, b, r) = [int(x) for x in input().split()]
while y >= 1 and b >= 2 and (r >= 3):
	for k in range(1, y + 1):
		y = bool(k + 1 <= b and k + 2 <= r)
		if y == True:
			result = k + k + 1 + k + 2
	break
print(result)


x = list(map(int, input().split()))
print(min(x[0], x[1] - 1, x[2] - 2) * 3 + 3)


(y, b, r) = map(int, input().split())
a = []
a.append(y)
a.append(y + 1)
a.append(y + 2)
while a[1] > b:
	a[0] -= 1
	a[1] -= 1
	a[2] -= 1
while a[2] > r:
	a[0] -= 1
	a[1] -= 1
	a[2] -= 1
print(sum(a))


import sys
input = sys.stdin.readline
print = sys.stdout.write
(y, b, r) = map(int, input().split())
print(str(3 * min(y + 1, b, r - 1)))


import math, sys
from fractions import *

def mp():
	return list(map(int, input().split()))

def main():
	(a, b, c) = mp()
	ans = 6
	for i in range(1, a + 1):
		if i + 1 <= b and i + 2 <= c:
			ans = max(ans, 3 * i + 3)
	print(ans)
deb = 0
if deb:
	file = open('input.txt', 'w')
else:
	input = sys.stdin.readline
main()


(y, b, r) = map(int, input().split())
a = [(y + 2, 3, 'y'), (b + 1, 2, 'b'), (r, 1, 'r')]
a.sort()
if a[0][2] == 'y':
	print(sum((y, y + 1, y + 2)))
elif a[0][2] == 'b':
	print(sum((b - 1, b, b + 1)))
else:
	print(sum((r - 2, r - 1, r)))


(y, b, r) = map(int, input().split())
bb = b - 1
rr = r - 2
mn = min([y, bb, rr])
if y == mn:
	print(3 * y + 3)
elif bb == mn:
	print(3 * b)
elif rr == mn:
	print(3 * r - 3)


a = list(map(int, input().split()))
y = a[0] + 1
b = a[1]
r = a[2] - 1
c = 3 * min(y, b, r)
print(c)


(a, b, c) = [int(s) for s in input().split()]
print(min(a, b - 1, c - 2) * 3 + 3)


(y, b, r) = map(int, input().split())
if y <= b and y <= r:
	while y > 0:
		d1 = b - y
		d2 = r - y
		if d1 >= 1 and d2 >= 2:
			print(3 * y + 3)
			break
		else:
			y -= 1
elif b <= y and b < r:
	y = b - 1
	print(3 * y + 3)
elif r <= y and r <= b:
	y = r - 2
	print(3 * y + 3)


from sys import stdin
arr = [int(ch) for ch in stdin.readline().split()]
(actual_y, b, r) = arr
for y in range(actual_y, 0, -1):
	if y + 1 <= b and y + 2 <= r:
		print(3 * y + 3)
		break


(a, b, c) = [int(i) for i in input().strip().split()]
if a >= b:
	a = b - 1
else:
	b = a + 1
if c >= b + 1:
	c = b + 1
else:
	b = c - 1
	a = b - 1
print(a + b + c)


l = [int(i) for i in input().split()]
l[0] += 2
l[1] += 1
n = min(l)
print(n * 3 - 3)


(y, b, r) = tuple(map(int, input().split()))
t = min(y, b - 1, r - 2)
if t == y:
	print(y + y + 1 + y + 2)
elif t == b - 1:
	print(b - 1 + b + b + 1)
else:
	print(r + r - 1 + r - 2)


(y, b, r) = [int(i) for i in input().split()]
m = min([y, b, r])
(y1, b1, r1) = [m, m + 1, m + 2]
while y < y1 or b < b1 or r < r1:
	m = m - 1
	(y1, b1, r1) = [m, m + 1, m + 2]
print(y1 + b1 + r1)


(a, b, c) = map(int, input().split())
(a, b, c) = (c, b, a)
res = 6
if a - 1 <= b and a - 2 <= c:
	res = max(res, a + a - 1 + a - 2)
if b + 1 <= a and b - 1 <= c:
	res = max(res, b + 1 + b + b - 1)
if c + 1 <= b and c + 2 <= a:
	res = max(res, c + c + 1 + c + 2)
print(res)


from sys import stdin, stdout
import cProfile, math
from collections import Counter
from bisect import bisect_left, bisect, bisect_right
import itertools
from copy import deepcopy
from fractions import Fraction
import sys, threading
import operator as op
from functools import reduce
sys.setrecursionlimit(10 ** 6)
threading.stack_size(2 ** 27)
printHeap = str()
memory_constrained = False
P = 10 ** 9 + 7
import sys
sys.setrecursionlimit(10000000)

class Operation:

	def __init__(self, name, function, function_on_equal, neutral_value=0):
		self.name = name
		self.f = function
		self.f_on_equal = function_on_equal

def add_multiple(x, count):
	return x * count

def min_multiple(x, count):
	return x

def max_multiple(x, count):
	return x
sum_operation = Operation('sum', sum, add_multiple, 0)
min_operation = Operation('min', min, min_multiple, 1000000000.0)
max_operation = Operation('max', max, max_multiple, -1000000000.0)

class SegmentTree:

	def __init__(self, array, operations=[sum_operation, min_operation, max_operation]):
		self.array = array
		if type(operations) != list:
			raise TypeError('operations must be a list')
		self.operations = {}
		for op in operations:
			self.operations[op.name] = op
		self.root = SegmentTreeNode(0, len(array) - 1, self)

	def query(self, start, end, operation_name):
		if self.operations.get(operation_name) == None:
			raise Exception('This operation is not available')
		return self.root._query(start, end, self.operations[operation_name])

	def summary(self):
		return self.root.values

	def update(self, position, value):
		self.root._update(position, value)

	def update_range(self, start, end, value):
		self.root._update_range(start, end, value)

	def __repr__(self):
		return self.root.__repr__()

class SegmentTreeNode:

	def __init__(self, start, end, segment_tree):
		self.range = (start, end)
		self.parent_tree = segment_tree
		self.range_value = None
		self.values = {}
		self.left = None
		self.right = None
		if start == end:
			self._sync()
			return
		self.left = SegmentTreeNode(start, start + (end - start) // 2, segment_tree)
		self.right = SegmentTreeNode(start + (end - start) // 2 + 1, end, segment_tree)
		self._sync()

	def _query(self, start, end, operation):
		if end < self.range[0] or start > self.range[1]:
			return None
		if start <= self.range[0] and self.range[1] <= end:
			return self.values[operation.name]
		self._push()
		left_res = self.left._query(start, end, operation) if self.left else None
		right_res = self.right._query(start, end, operation) if self.right else None
		if left_res is None:
			return right_res
		if right_res is None:
			return left_res
		return operation.f([left_res, right_res])

	def _update(self, position, value):
		if position < self.range[0] or position > self.range[1]:
			return
		if position == self.range[0] and self.range[1] == position:
			self.parent_tree.array[position] = value
			self._sync()
			return
		self._push()
		self.left._update(position, value)
		self.right._update(position, value)
		self._sync()

	def _update_range(self, start, end, value):
		if end < self.range[0] or start > self.range[1]:
			return
		if start <= self.range[0] and self.range[1] <= end:
			self.range_value = value
			self._sync()
			return
		self._push()
		self.left._update_range(start, end, value)
		self.right._update_range(start, end, value)
		self._sync()

	def _sync(self):
		if self.range[0] == self.range[1]:
			for op in self.parent_tree.operations.values():
				current_value = self.parent_tree.array[self.range[0]]
				if self.range_value is not None:
					current_value = self.range_value
				self.values[op.name] = op.f([current_value])
		else:
			for op in self.parent_tree.operations.values():
				result = op.f([self.left.values[op.name], self.right.values[op.name]])
				if self.range_value is not None:
					bound_length = self.range[1] - self.range[0] + 1
					result = op.f_on_equal(self.range_value, bound_length)
				self.values[op.name] = result

	def _push(self):
		if self.range_value is None:
			return
		if self.left:
			self.left.range_value = self.range_value
			self.right.range_value = self.range_value
			self.left._sync()
			self.right._sync()
			self.range_value = None

	def __repr__(self):
		ans = '({}, {}): {}\n'.format(self.range[0], self.range[1], self.values)
		if self.left:
			ans += self.left.__repr__()
		if self.right:
			ans += self.right.__repr__()
		return ans

def display(string_to_print):
	stdout.write(str(string_to_print) + '\n')

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer / denom

def primeFactors(n):
	factors = dict()
	for i in range(2, math.ceil(math.sqrt(n)) + 1):
		while n % i == 0:
			if i in factors:
				factors[i] += 1
			else:
				factors[i] = 1
			n = n // i
	if n > 2:
		factors[n] = 1
	return factors

def isprime(n):
	if n < 4:
		return True
	if n % 2 == 0:
		return False
	if n % 3 == 0:
		return False
	i = 5
	w = 2
	while i * i <= n:
		if n % i == 0:
			return False
		i += w
		w = 6 - w
	return True

def test_print(*args):
	if testingMode:
		print(args)

def display_list(list1, sep=' '):
	stdout.write(sep.join(map(str, list1)) + '\n')

def get_int():
	return int(stdin.readline().strip())

def get_tuple():
	return map(int, stdin.readline().split())

def get_list():
	return list(map(int, stdin.readline().split()))
memory = dict()

def clear_cache():
	global memory
	memory = dict()

def cached_fn(fn, *args):
	global memory
	if args in memory:
		return memory[args]
	else:
		result = fn(*args)
		memory[args] = result
		return result
TestCases = False
testingMode = False
optimiseForReccursion = False

def main():
	(y, b, r) = get_tuple()
	b -= 1
	r -= 2
	print(min(y, b, r) * 3 + 3)
if TestCases:
	for _ in range(get_int()):
		cProfile.run('main()') if testingMode else main()
else:
	(cProfile.run('main()') if testingMode else main()) if not optimiseForReccursion else threading.Thread(target=main).start()


(y, b, r) = map(int, input().split())
a = 0
c = 1
d = 2
while a + c + d < y + b + r and a < y and (c < b) and (d < r):
	a = a + 1
	c = c + 1
	d = d + 1
print(a + c + d)


arr = [int(x) for x in input().split()]
min_num = min(arr[0], arr[1])
min_num = min(min_num, arr[2])
min_index = arr.index(min_num)
if min_index > 0:
	min_num -= min_index
	arr[0] = min_num
i = 0
while i < 2:
	if arr[i] + 1 == arr[i + 1]:
		i += 1
	elif arr[i] + 1 < arr[i + 1]:
		arr[i + 1] -= 1
	elif arr[i] + 1 > arr[i + 1]:
		for x in range(0, i + 1):
			arr[x] -= 1
print(sum(arr))


def my_fun(x, y, z):
	if z - 1 <= y and y - 1 <= x:
		print(3 * (z - 1))
	elif not z - 1 <= y and y - 1 <= x:
		z = z - 1
		my_fun(x, y, z)
	elif z - 1 <= y and (not y - 1 <= x):
		y = y - 1
		my_fun(x, y, z)
	else:
		z = z - 1
		y = y - 1
		my_fun(x, y, z)
aux = input().split(' ')
i = 0
while i < 3:
	aux[i] = int(aux[i])
	i += 1
my_fun(aux[0], aux[1], aux[2])


(y, b, r) = map(int, input().split())
a = min(y, b - 1, r - 2)
answer = 3 * a + 3
print(answer)


arry = [int(y) for y in input().split()]
mn = min(arry[0], arry[1])
mnindex = arry.index(mn)
if arry[0] == arry[1]:
	mn = arry[1]
	mnindex = 1
if mnindex == 1 and mn < arry[-1] - 1:
	print(mn + mn - 1 + mn + 1)
elif mnindex == 0 and mn < arry[-1] - 2:
	print(mn + mn + 1 + mn + 2)
else:
	print(arry[-1] + arry[-1] - 1 + arry[-1] - 2)


from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 10 ** 9 + 7

def factors(n):
	return sorted(list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input())

def li2():
	return [i for i in input().rstrip('\n').split(' ')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
(y, b, r) = li()
b -= 1
r -= 2
print(3 * min(y, b, r) + 3)


(y, b, r) = [int(w) for w in input().split()]
print(3 * min(y + 1, b, r - 1))


a = 0
b = 0
c = 0
(a, b, c) = map(int, input().split())
least = 99999999999
least = min(a, least)
least = min(b - 1, least)
least = min(c - 2, least)
print(least * 3 + 3)


while True:
	try:
		(y, b, r) = map(int, input().strip().split())
		ans = min(3 * y + 3, 3 * b, 3 * r - 3)
		print(ans)
	except EOFError:
		break


a = input().split(' ')
a = list(map(int, a))
y = a[0]
b = a[1]
r = a[2]
a = []
for i in range(1, y + 1):
	for j in range(1, b + 1):
		for k in range(1, r + 1):
			if i + 1 == j and j + 1 == k:
				s = i + j + k
				a.append(s)
print(max(a))


(y, b, r) = list(map(int, input().split()))
max_y = min(b - 1, r - 2, y)
print(3 * max_y + 3)


def sol(y, b, r):
	m = min(y + 2, b + 1, r)
	return m * 3 - 3
(y, b, r) = map(int, input().split())
d = sol(y, b, r)
print(d)


x = [int(x) for x in input().split()]
if min(x[0], x[1], x[2]) == x[0]:
	y = x[0]
	b = x[0] + 1
	r = x[0] + 2
	while b > x[1] or r > x[2]:
		y = y - 1
		b = b - 1
		r = r - 1
elif min(x[0], x[1], x[2]) == x[1]:
	y = x[1] - 1
	b = x[1]
	r = x[1] + 1
	while b > x[1] or r > x[2]:
		y = y - 1
		b = b - 1
		r = r - 1
else:
	y = x[2] - 2
	b = x[2] - 1
	r = x[2]
	while b > x[1] or r > x[2]:
		y = y - 1
		b = b - 1
		r = r - 1
print(y + b + r)


(y, b, r) = map(int, input().split(' '))
an = []
if y + 1 <= b and y + 2 <= r:
	an.append(y * 3 + 3)
if b - 1 <= y and b + 1 <= r:
	an.append(3 * b)
if r - 2 <= y and r - 1 <= b:
	an.append(3 * r - 3)
if an == []:
	print('-1')
else:
	print(min(an))


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
(a, b, c) = get_ints()
mn = min(a, b - 1, c - 2)
print(3 * mn + 3)


(y, b, r) = map(int, input().split())
A = []
if y + 1 <= b and y + 2 <= r:
	A.append(3 * y + 3)
elif b - 1 <= y and b + 1 <= r:
	A.append(3 * b)
elif r - 2 <= y and r - 1 <= b:
	A.append(3 * r - 3)
print(max(A))


(y, b, r) = [int(i) for i in input().split()]
a = y + 2
c = b + 1
d = r
if d < c and d <= a:
	print((r - 1) * 3)
elif c <= a and c <= d:
	print(b * 3)
else:
	print((y + 1) * 3)


(x, y, z) = [*map(int, input().split())]
print((min(x, y - 1, z - 2) + 1) * 3)


(y, b, r) = map(int, input().split())
if b >= r:
	b = r - 1
if y >= b:
	y = b - 1
mn = min(y, b, r)
print(mn + (mn + 1) + (mn + 2))


(y, b, r) = map(int, input().split())
b1 = b - 1
r1 = r - 2
if y <= b1 and y <= r1:
	max = 3 * y + 3
elif b1 <= y and b1 <= r1:
	max = 3 * b
elif r1 <= b1 and r1 <= y:
	max = 3 * r - 3
print(max)


def function(l):
	(y, b, r) = l
	x = min(l)
	if y == b and x != r:
		print(3 * (y - 1) + 3)
	elif b == r and x != y:
		print(3 * (b - 1))
	elif x == y:
		if y + 2 > r:
			print(3 * r - 3)
		else:
			print(3 * y + 3)
	elif x == b:
		print(3 * b)
	else:
		print(3 * r - 3)
l = []
l = list(map(int, input().split()))
function(l)


def main():
	(x, y, z) = list(map(int, input().split()))
	print(min(3 * (x + 1), min(3 * y, 3 * (z - 1))))
main()


import collections
import math
import itertools
try:
	(x, y, z) = map(int, input().split())
	t = max(x, y, z)
	for i in range(1, t):
		if x / i == 1.0 or y / (i + 1) == 1.0 or z / (i + 2) == 1.0:
			print(i + i + 1 + i + 2)
			break
		else:
			pass
except:
	pass


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
(y, b, r) = invr()
mi = min(y, b, r)
ma = max(y, b, r)
if mi == y and mi != r and (mi != b):
	b = y + 1
	if b + 1 > r:
		b = r - 1
		y = b - 1
	else:
		r = b + 1
elif mi == b and mi != r:
	y = b - 1
	r = b + 1
elif mi == r:
	b = r - 1
	y = b - 1
print(y + r + b)


(a, b, c) = [int(x) for x in input().split()]
for i in range(a, 0, -1):
	if i + 1 <= b:
		temp = i + 1
		if i + 2 <= c:
			temp2 = i + 2
			print(i + temp + temp2)
			break


ligne = input().split(' ')
a = int(ligne[0])
b = int(ligne[1])
c = int(ligne[2])
if c == min(a, b, c):
	print(c + c - 1 + c - 2)
elif b == min(a, b, c):
	print(b + 1 + b + b - 1)
elif c - a < 2:
	print(a - 1 + a + a + 1)
else:
	print(a + a + 1 + a + 2)


(y, b, r) = [int(i) for i in input().split()]
res = 0
ct = 0
while ct < 1:
	if y + 1 <= b and y + 2 <= r:
		ct = 1
		res = y + y + 1 + y + 2
	else:
		y -= 1
print(res)


(y, b, r) = map(int, input().split())
a = min(y, b, r)
if a == y:
	if b > a and r > a + 1:
		print(3 * a + 3)
	elif b == a and r > y:
		print(3 * y)
	elif r == a:
		print(3 * y - 3)
	elif r == y + 1:
		print(3 * r - 3)
elif a == b:
	if r > b:
		print(3 * a)
	else:
		print(3 * a - 3)
else:
	print(3 * a - 3)


(y, b, r) = map(int, input().split())
b -= 1
r -= 2
m = min(y, b, r)
if m == y:
	print(y * 3 + 3)
elif m == b:
	print(b * 3 + 3)
else:
	print(r * 3 + 3)


def maxOrnaments(y, b, r):
	return min(y, b - 1, r - 2) * 3 + 3
(y, b, r) = map(int, input().split())
print(maxOrnaments(y, b, r))


def main():
	a = list(map(int, input().split()))
	ans = 0
	for i in range(1, a[0] + 1):
		if i + 1 <= a[1] and i + 2 <= a[2]:
			ans = max(ans, i * 3 + 3)
	print(ans)
main()


a = list(map(int, input().split()))
x = 0
for i in range(a[0] + 1):
	if a[1] >= i + 1 and a[2] >= i + 2:
		x = i * 3 + 3
print(x)


def main():
	(y, b, r) = map(int, input().split())
	(y, cur_b, cur_r) = (y, y + 1, y + 2)
	if b - cur_b < 0:
		y -= cur_b - b
		cur_b = b
		cur_r = y + 2
	if r - cur_r < 0:
		y -= cur_r - r
		cur_r = r
		cur_b = y + 1
	print(y + cur_b + cur_r)
main()


(y, b, r) = list(map(int, input().split()))
if b > y + 1:
	b = y + 1
else:
	y = b - 1
if r > b + 1:
	r = b + 1
else:
	b = r - 1
	y = b - 1
print(y + b + r)


def ans(arr):
	(y, b, r) = (arr[0], arr[1], arr[2])
	return min(y + 2, min(b + 1, r)) * 3 - 3
ybr = list(map(int, input().strip().split()))
print(ans(ybr))


l = list(map(int, input().split()))
if l[0] == l[1] and l[1] == l[2]:
	s = 3 * (l[0] - 2) + 3
else:
	m = l.index(min(l))
	if m == 2:
		s = 3 * l[2] - 3
	elif m == 1:
		if l[2] >= l[1] + 1:
			s = 3 * l[1]
		else:
			s = 3 * (l[1] - 1)
	elif l[1] >= l[0] + 1 and l[2] >= l[0] + 2:
		s = 3 * l[0] + 3
	elif l[1] >= l[0] + 1 and (l[2] == l[0] + 1 or l[2] == l[0]):
		if l[2] == l[0] + 1:
			s = 3 * (l[0] - 1) + 3
		elif l[2] == l[0]:
			s = 3 * (l[0] - 2) + 3
	elif l[2] >= l[0] + 2 and l[1] == l[0]:
		s = 3 * (l[0] - 1) + 3
	else:
		s = 3 * (l[0] - 2) + 3
print(s)


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(y, b, r) = I()
for i in range(100, 1, -1):
	if r >= i and b >= i - 1 and (y >= i - 2):
		print(3 * i - 3)
		break


import sys
input = sys.stdin.readline
mii = lambda : map(int, input().split())
(a, b, c) = mii()
b -= 1
c -= 2
print(min(a, b, c) * 3 + 3)


(y, b, r) = map(int, input().split())
for i in range(y, 1, -1):
	if b - i > 0 and r - (i + 1) > 0:
		print(sum([i, i + 1, i + 2]))
		exit(0)
print(6)


(a, b, c) = map(int, input().split())
print(3 * min(a + 1, min(b, c - 1)))


import sys
(y, b, r) = list(map(int, sys.stdin.readline().split()))
ba = b - 1
ra = r - 2
m = min(y, ba, ra)
print(3 * m + 3)


(y, b, r) = list(map(int, input().strip().split()))
a = 0
if b >= y + 1 and r >= y + 2:
	a = max(a, sum([y, y + 1, y + 2]))
if b - 1 <= y and b + 1 <= r:
	a = max(a, sum([b - 1, b, b + 1]))
if r - 1 <= b and r - 2 <= y:
	a = max(a, sum([r - 2, r - 1, r]))
print(a)


def A():
	ybr = input().split()
	(y, b, r) = (int(ybr[0]), int(ybr[1]), int(ybr[2]))
	a = min(y, b - 1, r - 2)
	print(3 * a + 3)
A()


a = list(map(int, input().split()))
ans = 0
for i in range(1, a[0] + 1):
	for j in range(2, a[1] + 1):
		for k in range(3, a[2] + 1):
			if i + 1 == j and j + 1 == k:
				ans = max(ans, i + j + k)
print(ans)


(x, y, z) = input().split()
print(3 * min(int(x) + 1, min(int(y), int(z) - 1)))


(y, b, r) = list(map(int, input().split()))
ans = [0]
for i in range(1, y + 1):
	if r >= i + 2 and b >= i + 1:
		ans.append(3 * i + 3)
print(max(ans))


(y, b, r) = [int(x) for x in input().split(' ')]
n = min(y, b - 1, r - 2)
print(3 * n + 3)


(y, b, r) = map(int, input().split())
l = 1
m = 2
n = 3
while l != y and m != b and (n != r):
	l = l + 1
	m = m + 1
	n = n + 1
s = l + m + n
print(s)


(y, b, r) = map(int, input().split())
mn = min([y, b, r])
if r == min([y, b, r]):
	while not b + 1 >= r <= y + 2:
		r -= 1
	print(r + r - 1 + r - 2)
elif b == min([y, b, r]):
	while not r >= b + 1 <= y + 2:
		b -= 1
	print(3 * b)
elif y == min([y, b, r]):
	while not r >= y + 2 <= b + 1:
		y -= 1
	print(3 * y + 3)


(y, b, r) = map(int, input().split())
(x, a, z) = (1, 2, 3)
ans = x + a + z
while x < y and a < b and (z < r):
	x += 1
	a += 1
	z += 1
	ans += 3
print(ans)


import sys
(y, b, r) = map(int, sys.stdin.readline().split(' '))
z = min(y, b - 1, r - 2)
print(3 * z + 3)


(y, b, r) = [int(i) for i in input().split()]
n = min(y, b, r)
if r == n:
	print(3 * r - 3)
elif b == n:
	print(3 * b)
elif y == n:
	if r > b:
		print(3 * y + 3)
	elif r >= y + 2:
		print(3 * y + 3)
	else:
		print(3 * y)


(y, b, r) = map(int, input().split())
y1 = b1 = r1 = 0
if y >= b:
	y = b - 1
else:
	b = y + 1
if b >= r:
	b = r - 1
else:
	r = b + 1
if y >= b:
	y = b - 1
else:
	b = y + 1
print(y + b + r)


(y, b, r) = map(int, input().split())
o = 0
for i in range(1, y + 1):
	if i + 1 <= b and i + 2 <= r:
		o = max(o, i + i + i + 3)
print(o)


z = list(map(int, input().split()))
minimal = min(z)
x = z.index(minimal)
if z[0] == z[1] and z[1] == z[2]:
	print(z[0] + z[1] - 1 + z[2] - 2)
elif x == 2:
	print(z[2] * 3 - 3)
elif x == 1:
	if z[0] >= minimal and z[2] > minimal:
		print(z[1] * 3)
	else:
		print(z[2] + z[2] - 1 + z[2] - 2)
elif x == 0:
	if z[0] < z[1] and z[1] < z[2]:
		print(z[0] * 3 + 3)
	elif z[0] < z[1] and z[0] + 1 == z[2]:
		print(z[2] + z[2] - 1 + z[2] - 2)
	elif z[0] < z[1] and z[0] + 1 < z[2]:
		print(z[0] * 3 + 1 + 2)
	elif z[0] == z[2]:
		print(z[2] * 3 - 3)
	elif z[1] == z[0]:
		print(z[0] * 3)


s = input().split(' ')
y = int(s[0])
b = int(s[1])
r = int(s[2])
if r <= b:
	if b <= y:
		print(r + r + r - 3)
	if b > y:
		if r <= y:
			print(r + r + r - 3)
		elif r > y + 1:
			print(y + y + y + 3)
		else:
			print(r + r + r - 3)
elif r > b:
	if b > y:
		print(y + y + y + 3)
	if b <= y:
		print(b + b + b)


def pickOrnaments(y, b, r):
	while y > 0:
		if y + 1 > b or y + 2 > r:
			y -= 1
		else:
			return 3 * (y + 1)
inp = list(map(int, input().split(' ')))
y = inp[0]
b = inp[1]
r = inp[2]
print(pickOrnaments(y, b, r))


(y, b, r) = list(map(int, input().split()))
for i in range(y, -1, -1):
	if i + 1 in range(1, b + 1) and i + 2 in range(1, r + 1):
		print(3 * (i + 1))
		break


n = input().split(' ')
y = int(n[0])
b = int(n[1])
r = int(n[2])
while r >= 3 and b >= 2 and (y >= 1):
	if r == b + 1 and b == y + 1:
		break
	else:
		if r != b + 1:
			while r > b + 1:
				r = r - 1
			while b >= r:
				b = b - 1
		if b != y + 1:
			while b > y + 1:
				b = b - 1
			while y >= b:
				y = y - 1
print(y + b + r)


aa = input().split()
a = int(aa[0])
b = int(aa[1])
c = int(aa[2])
for i in range(1, a + 1):
	if i + 1 <= b and i + 2 <= c:
		ans = i + 1
print(ans * 3)


line = input().split(' ')
y = int(line[0])
b = int(line[1])
r = int(line[2])
for i in range(r, 0, -1):
	if i - 2 <= y and i - 1 <= b:
		print(i * 3 - 3)
		break


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
d = []
if a + 1 <= b and a + 2 <= c:
	d.append(3 * a + 3)
if b - 1 <= a and b + 1 <= c:
	d.append(3 * b)
if c - 1 <= b and c - 2 <= a:
	d.append(3 * c - 3)
print(max(d))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
(a, b, c) = get_int_list()
a = a + 2
b = b + 1
m = min(a, b, c)
print(m * 3 - 3)


(a, b, c) = (int(x) for x in input().split())
ans = -1
for i in range(1, a + 1):
	if i + 1 <= b and i + 2 <= c:
		ans = i * 3 + 3
for i in range(1, b + 1):
	if i - 1 <= a and i + 1 <= c:
		ans = max(ans, i + i - 1 + i + 1)
for i in range(1, c + 1):
	if i - 1 <= b and i - 2 <= a:
		ans = max(ans, i + i - 1 + i - 2)
print(ans)


def line(y, b, r):
	while r >= 3 and b >= 2 and (y >= 1):
		if r == b + 1 and b == y + 1:
			break
		else:
			if r != b + 1:
				while r > b + 1:
					r = r - 1
				while b >= r:
					b = b - 1
			if b != y + 1:
				while b > y + 1:
					b = b - 1
				while y >= b:
					y = y - 1
	print(r + y + b)
t = input()
t = t.split(' ')
y = int(t[0])
b = int(t[1])
r = int(t[2])
line(y, b, r)


(a, b, c) = map(int, input().split())
array = []
for i in range(1, a + 1):
	for j in range(1, b + 1):
		for k in range(1, c + 1):
			if j == i + 1 and k == j + 1:
				res = i + j + k
				array.append(res)
			else:
				count = 0
print(max(array))


(y, b, r) = map(int, input().split())
rr = r
bb = b
yy = y
if b >= rr:
	bb = rr - 1
else:
	rr = bb + 1
if yy >= bb:
	yy = bb - 1
else:
	bb = yy + 1
	rr = bb + 1
ans = bb + rr + yy
print(ans)


from sys import stdin, stdout
from math import *
from heapq import *
from collections import *

def main():
	(y, b, r) = [int(x) for x in stdin.readline().split()]
	res = min([y * 3 + 3, b * 3, r * 3 - 3])
	stdout.write(str(res))
	return 0
main()


(y, b, r) = [int(x) for x in input().split()]
a = [y, b, r]
if min(a) == a[0] and r - y >= 2 and (b - y >= 1):
	print(y + y + 1 + y + 2)
elif min(a) == a[0] and r - y < 2 and (b - y >= 1) and (r == y):
	print(y - 2 + y - 1 + y)
elif min(a) == a[0] and r - y < 2 and (b - y >= 1) and (r > y):
	print(y - 1 + y + y + 1)
elif min(a) == a[0] and r - y < 2 and (b - y < 1) and (r - b >= 2):
	print(y - 1 + y + y + 1)
elif min(a) == a[0] and r - y < 2 and (b - y < 1) and (r - b < 2):
	print(y - 2 + y - 1 + y)
elif min(a) == a[1] and r - b >= 1:
	print(b - 1 + b + b + 1)
elif min(a) == a[1] and r - b < 1:
	print(b - 2 + b - 1 + b)
elif min(a) == a[2]:
	print(r - 2 + r - 1 + r)


(a, b, c) = map(int, input().split())
(x, y, z) = (c, c - 1, c - 2)
while y > b or z > a:
	x -= 1
	y -= 1
	z -= 1
print(x + y + z)


(y, b, r) = map(int, input().split())
lst = []
lst = [y, b, r]
lst.sort()
if lst[0] == r:
	print(r - 2 + r - 1 + r)
elif lst[0] == b:
	print(b - 1 + b + b + 1)
elif lst[0] == y:
	if r - y == 1:
		print(r - 2 + r - 1 + r)
	elif r - y >= 2:
		print(y + y + 1 + y + 2)


elk = list(map(int, input().split()))
rez = 0
y = elk[0]
b = elk[1]
r = elk[2]
if b >= r:
	while r - b != 1:
		b -= 1
else:
	while r - b != 1:
		r -= 1
if y >= b:
	while b - y != 1:
		y -= 1
else:
	while b - y != 1:
		b -= 1
	while r - b != 1:
		r -= 1
rez += y + b + r
print(rez)


(a, b, c) = [int(i) for i in input().split()]
v = [c - 2, c - 1, c]
if max(c - 2 - a, c - 1 - b) > 0:
	print(3 * c - 3 - max(c - 2 - a, c - 1 - b) * 3)
else:
	print(3 * c - 3)


(a, b, c) = [int(x) for x in input().split()]
rr = min(c, b + 1)
bb = min(rr - 1, a + 1)
yy = min(bb - 1, a)
print(yy * 3 + 3)


(y, b, r) = map(int, input().split())
m = min(y, b, r)
ans = 6
for i in range(m - 2, m + 3):
	if y >= i and b >= i + 1 and (r >= i + 2):
		ans = max(ans, 3 * i + 3)
print(ans)


(a, b, c) = map(int, input().split())
for i in range(a, -1, -1):
	if i + 1 <= b and i + 2 <= c:
		print(i + i + 1 + i + 2)
		exit()


(y, b, r) = map(int, input().split())
mi = min(y, b, r)
if r == mi:
	print(mi * 3 - 3)
elif b == mi:
	print(mi * 3)
elif r >= y + 2:
	print(mi * 3 + 3)
else:
	print(mi * 3)


(y, b, r) = map(int, input().split())
while y > 0:
	if y + 1 <= b:
		if y + 2 <= r:
			print(3 * (y + 1))
			break
	y -= 1


a = input()
a = a.split()
x = int(a[0])
y = int(a[1])
z = int(a[2])
m = x
n = y - 1
o = z - 2
print(min(m, n, o) * 3 + 3)


(y, b, r) = map(int, input().split())
x = 1
while x < y and x + 1 < b and (x + 2 < r):
	x += 1
print(3 * x + 3)


temp = [int(x) for x in input().split()]
y = temp[0]
b = temp[1]
r = temp[2]
if y >= b:
	y = b - 1
else:
	b = y + 1
if b >= r:
	b = r - 1
	y = r - 2
else:
	r = b + 1
print(y + b + r)


import math
(y, b, r) = [int(s) for s in input().split(' ')]
ans = 0
for i in range(1, y + 1):
	if i + 1 > b:
		break
	if i + 2 > r:
		break
	ans = 3 * i + 3
print(ans)


import sys
import math

def main():
	(y, b, r) = map(int, input().split())
	res = 0
	for a in range(0, y + 1):
		if b >= a + 1 and r >= a + 2:
			res = max(res, a + a + 1 + a + 2)
	print(res)
main()


(a, b, c) = map(int, input().split())
ans = c
if b < ans - 1:
	ans = b + 1
if a < ans - 2:
	ans = a + 2
print(3 * ans - 3)


t = 1
for test in range(t):
	(y, b, r) = map(int, input().split())
	y = min(y, r - 2, b - 1)
	print(y + 2 + y + 1 + y)


l = list(map(int, input().split()))
mini = min(l)
y = 0
if l[0] == mini:
	y = mini
elif l[1] == mini:
	y = mini - 1
elif l[2] == mini:
	y = mini - 2
for i in range(mini, -1, -1):
	if i + 1 <= l[1] and i + 2 <= l[2]:
		print(3 * i + 3)
		break


(y, b, r) = map(int, input().split())
for c in range(y, -1, -1):
	if c + 1 <= b and c + 2 <= r:
		print(3 * (c + 1))
		exit(0)


x = list(map(int, input().split()))
y = min(x)
s = 0
if x[0] == y:
	if y == x[1] and y == x[2]:
		s += y * 3 - 3
	elif y == x[1]:
		s += y * 3
	elif y == x[2]:
		s += y * 3 - 3
	elif y + 1 == x[2]:
		s += y * 3
	else:
		s += y * 3 + 3
elif x[1] == y:
	if y == x[2]:
		s += y * 3 - 3
	else:
		s += y * 3
else:
	s += y * 3 - 3
print(s)


(y, b, r) = [int(i) for i in input().strip().split(' ')]
yy = min(y, b - 1, r - 2)
bb = yy + 1
rr = bb + 1
print(rr + bb + yy)


L = list(map(int, input().split()))
(Y, B, R) = (L[0], L[1], L[2])
ans = 1
while 1:
	if ans <= Y and ans + 1 <= B and (ans + 2 <= R):
		ans += 1
	else:
		ans -= 1
		break
print(3 * ans + 3)


(a, b, c) = tuple(map(int, input().split(' ')))
if a > b - 1:
	a = b - 1
if b > c - 1:
	b = c - 1
	a = min(a, b - 1)
print(3 * a + 3)


(a, b, c) = list(map(int, input().split()))
use = min(a, b - 1, c - 2)
print(3 * use + 3)


nums = list(map(int, input().split()))
for i in range(3):
	nums[i] -= i
print((min(nums) + 1) * 3)


(y, b, r) = map(int, input().split())
res = r
if b < res - 1:
	res = b + 1
if y < res - 2:
	res = y + 2
print(res + res - 1 + res - 2)


(y, b, r) = map(int, input().split())
d = y
e = b - 1
f = r - 2
t = [d, e, f]
print(3 * min(t) + 3)


aa = [int(x) for x in input().split()]
y = aa[0]
b = aa[1]
r = aa[2]
max = 0
if y + 1 <= b and y + 2 <= r:
	max = y + y + 1 + y + 2
elif b - 1 <= y and b + 1 <= r:
	max = b - 1 + b + b + 1
else:
	max = r + r - 1 + r - 2
print(max)


l = list(map(int, input().split()))
l[1] = l[1] - 1
l[2] = l[2] - 2
if l[0] <= l[1] and l[0] <= l[2]:
	k = 3 * l[0] + 3
elif l[1] <= l[0] and l[1] <= l[2]:
	k = 3 * l[1] + 3
elif l[2] <= l[0] and l[2] <= l[1]:
	k = 3 * l[2] + 3
print(k)


(j, c, k) = map(int, input().split())
i = 0
while i <= j and i + 1 <= c and (i + 2 <= k):
	i += 1
print(3 * i)


a = list(map(int, input().split()))
a[1] -= 1
a[2] -= 2
k = min(a)
print(3 * k + 3)


(y, b, r) = list(map(int, input().split()))
b_y = b - 1
r_y = r - 2
print((min(y, b_y, r_y) + 1) * 3)


x = list(map(int, input().split()))
y = x[0]
b = x[1]
r = x[2]
m = 1
n = 2
o = 3
while m < y and n < b and (o < r):
	m = m + 1
	n = n + 1
	o = o + 1
print(m + n + o)


(y, b, r) = map(int, input().split(' '))
a = min(y, b, r)
i = 0
if a == y and y != b:
	if a + 1 <= b and a + 2 <= r:
		print(3 * a + 3)
	else:
		while a >= 0:
			a = a - 1
			if a + 1 and a + 2 <= r:
				print(3 * a + 3)
				break
elif a == b and b != r:
	if a + 1 <= r and a - 1 <= y:
		print(3 * b)
	else:
		while a >= 0:
			a = a - 1
			if a + 1 <= r and a - 1 <= y:
				print(3 * b)
				break
elif a == r:
	if a - 1 <= b and a - 2 <= y:
		print(3 * a - 3)
	else:
		while a >= a:
			a = a - 1
			if a - 1 <= b and a - 2 <= y:
				print(3 * a - 3)
				break


l = [int(x) for x in input().split()]
m = min(l)
result = [m, m + 1, m + 2]
while result[0] > l[0] or result[1] > l[1] or result[2] > l[2]:
	result = [result[i] - 1 for i in range(3)]
print(sum(result))


def solve():
	(a, b, c) = list(map(int, input().split()))
	print(min(a, b - 1, c - 2) * 3 + 3)
solve()


(a, b, c) = map(int, input().split(' '))
(a1, b1, c1) = (1, 2, 3)
sum1 = 0
k = True
while k:
	if a1 <= a and b1 <= b and (c1 <= c):
		sum1 = a1 + b1 + c1
		a1 += 1
		b1 += 1
		c1 += 1
	else:
		k = False
print(sum1)


(n, m, k) = map(int, input().split())
for i in range(1, n + 1):
	for j in range(1, m + 1):
		for p in range(1, k + 1):
			if j == i + 1 and p == j + 1:
				x = j + i + p
print(x)


(y, b, r) = [int(a) for a in input().split()]
if y > b:
	if y > r:
		if b >= r:
			print(3 * r - 3)
		else:
			print(3 * b)
	else:
		print(3 * b)
elif b > y:
	if b > r:
		if y > r:
			print(3 * r - 3)
		elif r - y > 1:
			print(3 * y + 3)
		else:
			print(3 * r - 3)
	elif r - y > 1:
		print(3 * y + 3)
	else:
		print(3 * r - 3)
elif b > r:
	print(3 * r - 3)
elif r - y > 1:
	print(3 * b)
else:
	print(3 * r - 3)


l = list(map(int, input().split()))
y = l[0]
b = l[1]
r = l[2]
while True:
	if r - 1 > b:
		r -= 1
	else:
		b = r - 1
		if b - 1 > y:
			b -= 1
			r -= 1
		else:
			y = b - 1
			break
print(r + y + b)


(y, b, r) = map(int, input().split())
arr = [p + q + s for p in range(y + 1) for q in range(b + 1) for s in range(r + 1) if q == p + 1 and s == q + 1]
print(max(arr))


s = list(map(int, input().split()))
z = [s[2] - 2, s[2] - 1, s[2]]
while s[1] < z[1] or s[0] < z[0]:
	z[0] = z[0] - 1
	z[1] = z[1] - 1
	z[2] = z[2] - 1
print(sum(z))


(a, b, c) = map(int, input().split())
k = True
i = 1
while k == True:
	if i <= a and i + 1 <= b and (i + 2 <= c):
		i += 1
	else:
		k = False
print((i - 1) * 3 + 3)


from sys import stdin, stdout
(y, b, r) = tuple(stdin.readline().split())
(y, b, r) = (int(y) + 2, int(b) + 1, int(r))
stdout.write(str(3 * (min(y, b, r) - 1)))


(y, b, r) = map(int, input().split())
y1 = r - 2
y2 = b - 1
b1 = y + 1
b2 = r - 1
r1 = b + 1
r2 = y + 2
Y = [y, y1, y2]
B = [b, b1, b2]
R = [r, r1, r2]
Y.sort()
B.sort()
R.sort()
print(Y[0] + B[0] + R[0])


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
c = 0
if y == 1:
	c = 6
elif b == 2:
	c = 6
elif r == 3:
	c = 6
if c == 0:
	if y < r - 2:
		r = y + 2
	if b < r - 1:
		r = b + 1
	c = r + (r - 1) + (r - 2)
print(c)


ls = list(map(int, input().split()))
for i in range(len(ls)):
	ls[i] -= i
m = min(ls)
Sum = 0
for i in range(len(ls)):
	Sum += m + i
print(Sum)


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
cnt = min(y, b - 1, r - 2)
tot = 3 * cnt + 3
print(tot)


(y, b, r) = [int(i) for i in input().split()]
base = min(y, b - 1, r - 2)
print(3 * base + 3)


(y, b, r) = (int(x) for x in input().split())
while r >= 0:
	if r - 1 <= b and r - 2 <= y:
		print(3 * r - 3)
		break
	r -= 1


import sys

def main():
	(y, b, r) = map(int, sys.stdin.read().strip().split())
	if b >= r:
		b = r - 1
	if y >= b:
		y = b - 1
	return y * 3 + 3
print(main())


string = input()
stringList = string.split(' ')
list = list(map(int, stringList))
a = list[0]
b = list[1]
c = list[2]
for i in range(a, -1, -1):
	if i + 1 <= b and i + 2 <= c:
		print(i + i + 1 + i + 2)
		break


(y, b, r) = list(map(int, input().split()))
if r == min(y, r, b):
	print(3 * r - 3)
elif b == min(y, r, b):
	while b + 1 > r:
		b = b - 1
	print(3 * b)
else:
	while y + 2 > r or y + 1 > b:
		y = y - 1
	print(3 * y + 3)


(a, b, c) = (int(i) for i in input().split())
print(3 * min(a + 1, b, c - 1))


(y, b, r) = map(int, input().split())
ans = 6
y -= 1
b -= 2
r -= 3
while y > 0 and b > 0 and (r > 0):
	ans += 3
	y -= 1
	b -= 1
	r -= 1
print(ans)


(y, b, r) = map(int, input().split(' '))
c = []
for i in range(1, min(r, y, b) + 1):
	if i + 1 <= b and i + 2 <= r:
		c.append(3 * (i + 1))
print(max(c))


(y, b, r) = map(int, input().split())
mx = 6
for i in range(1, y + 1):
	if i + 1 <= b and i + 2 <= r:
		mx = 3 * i + 3
print(mx)


a = list(map(int, input().split()))
y = 0
b = 0
r = 0
if a[1] >= a[2] - 1:
	r = a[2]
	b = a[2] - 1
else:
	b = a[1]
	r = a[1] + 1
if a[0] >= b - 1:
	y = b - 1
else:
	b = a[0] + 1
	r = b + 1
	y = a[0]
print(y + b + r)


(y, b, r) = [int(v) for v in input().split()]
options = [(y, y + 1, y + 2), (b - 1, b, b + 1), (r - 2, r - 1, r)]
ans = 6
for (yy, bb, rr) in options:
	if 0 <= yy <= y and 0 <= bb <= b and (0 <= rr <= r):
		ans = max(ans, yy + bb + rr)
print(ans)


(x, y, z) = map(int, input().split())
(x1, y1, z1) = (z - 2, z - 1, z)
while True:
	if x >= x1 and y >= y1 and (z >= z1):
		print(x1 + y1 + z1)
		break
	else:
		x1 -= 1
		y1 -= 1
		z1 -= 1


(y, b, r) = list(map(int, input().split()))
if b - y > 1:
	b = y + 1
elif b - y < 1:
	y = b - 1
if r - b > 1:
	r = b + 1
elif r - b < 1:
	b = r - 1
	y = b - 1
print(y + b + r)


(y, b, r) = map(int, input().split())
ans = 6
for i in range(1, 100):
	if y > i and b > i + 1 and (r > i + 2):
		ans += 3
	else:
		break
print(ans)


(n, z, k) = map(int, input().split())
x = 0
for i in range(1, n + 1):
	for j in range(1, z + 1):
		for r in range(1, k + 1):
			if j == i + 1 and r == j + 1:
				x = j + i + r
print(x)


inp = input().split()
inp = [int(x) for x in inp]
val = 0
if min(inp) == inp[2]:
	val = 3 * inp[2] - 3
elif min(inp) == inp[1]:
	val = 3 * inp[1]
elif inp[2] >= inp[0] + 2:
	val = 3 * inp[0] + 3
else:
	val = 3 * inp[0]
print(val)


(y, b, r) = map(int, input().split())
mn = min(r, b, y)
if r == mn:
	c = r + r - 1 + r - 2
	print(c)
elif b == mn:
	c = b - 1 + b + b + 1
	print(c)
else:
	if r < y + 2:
		y -= y + 2 - r
	c = y + y + 1 + y + 2
	print(c)


import sys
(y, b, r) = map(int, sys.stdin.readline().split())
if b >= y + 1:
	b = y + 1
else:
	y = b - 1
if r >= b + 1:
	r = b + 1
else:
	b = r - 1
	y = b - 1
print(y + b + r)


(a, b, c) = map(int, input().split())
l = [a + 1, b, c - 1]
l.sort()
print(3 * l[0])


def pd(y, b, r, yy, bb, rr):
	if y >= yy and b >= bb and (r >= rr):
		return True
	return False
(y, b, r) = map(int, input().split())
ans = 0
if pd(y, b, r, y, y + 1, y + 2) == True:
	ans = max(ans, y + y + 1 + y + 2)
if pd(y, b, r, b - 1, b, b + 1) == True:
	ans = max(ans, 3 * b)
if pd(y, b, r, r - 2, r - 1, r) == True:
	ans = max(ans, 3 * r - 3)
print(ans)


(Y, B, R) = map(int, input().split())
B -= 1
R -= 2
print(3 * min(Y, B, R) + 3)


def main():
	(y, b, r) = map(int, input().split())
	while y > 0:
		if y + 1 <= b and y + 2 <= r:
			print(3 * y + 3)
			break
		y -= 1
main()


import queue

def main():
	(y, b, r) = [int(x) for x in input().split()]
	s = 0
	if min(y, b, r) == r:
		s = 3 * r - 3
	elif min(y, b, r) == b:
		s = 3 * b
	elif r > y + 1:
		s = 3 * y + 3
	else:
		s = 3 * y
	print(s)
main()


(y, b, r) = [int(x) for x in input().split()]
ans = 0
for i in range(1, y + 1):
	if b >= i + 1 and r >= i + 2:
		ans = i + i + 1 + i + 2
print(ans)


(a, b, c) = map(int, input().split())
ret = 0
s = min(a, b, c)
for i in range(1, 101):
	if i <= a and i + 1 <= b and (i + 2 <= c):
		ret = i + i + i + 3
print(ret)


(y, b, r) = map(int, input().split(' '))
while y + 2 > r or y + 1 > b:
	y -= 1
print(y + y + 1 + y + 2)


s = input()

def solution(line):
	list1 = line.split()
	n1 = int(list1[0])
	n2 = int(list1[1])
	n3 = int(list1[2])
	n4 = min(n1, n2, n3)
	if n4 == n1:
		while n2 < n1 + 1 or n3 < n1 + 2:
			n1 = n1 - 1
		return 3 * n1 + 3
	elif n4 == n2:
		while n1 < n2 - 1 or n3 < n2 + 1:
			n2 = n2 - 1
		return 3 * n2
	elif n4 == n3:
		while n1 < n3 - 2 or n2 < n3 - 1:
			n3 = n3 - 1
		return 3 * n3 - 3
print(solution(s))


vs = list(map(int, input().split()))
mv = min(vs[0], vs[1] - 1, vs[2] - 2)
print(3 * mv + 3)


(a, b, c) = [int(x) for x in input().split()]
base = min(a, b - 1, c - 2)
print(3 * base + 3)


(y, b, r) = input().split(' ')
y = int(y)
b = int(b)
r = int(r)
i = 1
j = 2
k = 3
while i <= y and j <= b and (k <= r):
	i = i + 1
	j = j + 1
	k = k + 1
sum = i + j + k - 3
print(sum)


(y, b, r) = [int(i) for i in input().split()]
p = y + 2
q = b + 1
s = r
if s <= p and s <= q:
	print(3 * (r - 1))
elif q <= s and q <= p:
	print(3 * b)
else:
	print(3 * (y + 1))


(y, b, r) = map(int, input().split())
veci = []
if y + 1 <= b and y + 2 <= r:
	veci.append(3 * y + 3)
if b - 1 <= y and b + 1 <= r:
	veci.append(3 * b)
if r - 2 <= y and r - 1 <= b:
	veci.append(3 * r - 3)
print(max(veci))


x = input().split()
y = int(x[0])
b = int(x[1])
r = int(x[2])
ans = 0
minimum = min(y, b, r)
poss = []
if minimum <= r and b >= r - 1 and (y >= r - 2):
	ans = r + r - 1 + r - 2
	poss.append(ans)
elif minimum <= b and r >= b + 1 and (y >= b - 1):
	ans = b + b - 1 + b + 1
	poss.append(ans)
elif minimum <= y and b >= y + 1 and (r >= y + 2):
	ans = y + y + 1 + y + 2
	poss.append(ans)
print(max(poss))


(a, b, c) = map(int, input().split())
m1 = 0
if a >= b - 1 and c >= b + 1:
	m1 = 3 * b
m2 = 0
if b >= a + 1 and c >= a + 2:
	m2 = 3 * a + 3
m3 = 0
if a >= c - 2 and b >= c - 1:
	m3 = 3 * c - 3
print(max(m1, m2, m3))


x = input().split(' ')
y = int(x[0])
b = int(x[1])
r = int(x[2])

def balls(y, b, r):
	if y + 1 <= b:
		if y + 2 <= r:
			r1 = y + 2
			b1 = y + 1
			y1 = y
		else:
			r1 = r
			b1 = r - 1
			y1 = r - 2
	elif b + 1 <= r:
		r1 = b + 1
		b1 = b
		y1 = b - 1
	else:
		r1 = r
		b1 = r - 1
		y1 = r - 2
	numberOfBalls = y1 + b1 + r1
	return numberOfBalls
print(balls(y, b, r))


import math
(y, b, r) = [int(x) for x in input().split()]
ans = min(y, min(b, r))
if ans == r:
	ans = 3 * (r - 1)
elif ans == b:
	ans = 3 * b
elif ans == y:
	if r == y + 1:
		ans = 3 * y
	else:
		ans = 3 * (y + 1)
print(ans)


(y, b, r) = map(int, input().split())
ya = y
ba = y + 1
ra = y + 2
m = min(y, b, r)
if m == b:
	ya = b - 1
	ba = b
	ra = b + 1
elif m == r:
	ya = r - 2
	ba = r - 1
	ra = r
if ra > r or ba > b or ya > y:
	ya -= 1
	ba -= 1
	ra -= 1
print(ya + ba + ra)


(y, b, r) = input().split(' ')
y = int(y)
b = int(b)
r = int(r)
ans = 0
if b >= r - 1 and y >= r - 2:
	ans = r + r - 1 + r - 2
elif r >= b + 1 and y >= b - 1:
	ans = b - 1 + b + b + 1
elif b >= y + 1 and r >= y + 2:
	ans = y + y + 1 + y + 2
print(ans)


(a, b, c) = [int(i) for i in input().split()]
tmp = [-1, 0, 1]
while tmp[0] <= a and tmp[1] <= b and (tmp[2] <= c):
	tmp = [i + 1 for i in tmp]
print(sum(tmp) - 3)


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
if b > y and r > y + 1:
	x = y + 1
	z = x + 1
	print(x + y + z)
elif r < b and b < y or (r < b and y < b) or (b > y and r <= y + 1) or (y == b and r == b) or (y > b and b == r) or (y == r and b > y) or (y == b and r < b) or (y < b and b == r):
	x = r - 1
	z = x - 1
	print(x + z + r)
elif b < r and b < y or (r > b and y == b) or (y == r and b < y):
	x = b - 1
	z = b + 1
	print(x + z + b)


a = list(map(int, input().split()))
print(3 * min(a[0] + 1, a[1], a[2] - 1))


def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())
(a, b, c) = mi()
b -= 1
c -= 2
m = min(a, b)
m = min(m, c)
m = min(m, a)
print(3 * m + 3)


(x, y, z) = list(map(int, input().split(' ')))
ans = min(x, y - 1)
ans = min(ans, z - 2)
ans = ans * 3 + 3
print('{}'.format(ans))


from sys import stdin, stdout
from math import sin, tan, cos, pi, atan2, sqrt, acos, atan, factorial
from random import randint
(a, b, c) = map(int, stdin.readline().split())
ans = 0
for i in range(1, a + 1):
	if i + 1 <= b and i + 2 <= c:
		ans = i * 3 + 3
stdout.write(str(ans))


(y, b, r) = map(int, input().split())
i = 1
while i <= 100:
	if i + 1 <= y and i + 2 <= b and (i + 3 <= r):
		i += 1
	else:
		break
print(i + i + 1 + i + 2)


(y, b, r) = map(int, input().split())
if y >= b:
	y = b - 1
else:
	y = y
if r < b:
	b = r - 1
else:
	b = b
if y < r:
	if r == y + 1:
		y = r - 2
else:
	y = r - 2
b = y + 1
r = b + 1
while b == y + 1 and r == b + 1:
	print(y + b + r)
	break


arr = list(map(int, input().split()))
k = arr[1]
while True:
	if k - 1 <= arr[0] and k + 1 <= arr[2]:
		print(k * 3)
		break
	else:
		k -= 1


(y, b, r) = map(int, input().split())
ans = 0
f = 0
if b > y and r > y + 1:
	ans = max(ans, 3 * y + 3)
	f = 1
if y >= b - 1 and r > b:
	ans = max(ans, 3 * b)
	f = 1
if b >= r - 1 and y >= r - 2:
	ans = max(ans, 3 * r - 3)
print(ans)


a = map(int, input().split())
b = min(map(lambda z: z[1] + 1 - z[0], enumerate(a)))
print(3 * b)


z = input
(a, b, c) = list(map(int, z().split()))
for i in range(a, 0, -1):
	for j in range(b, 0, -1):
		for k in range(c, 0, -1):
			if i < j and j < k:
				print(i + i + i + 3)
				exit(0)


(y, b, r) = map(int, input().split())
m = min(y, b - 1, r - 2)
total = 3 * m + 3
print(total)


e = list(map(int, input().split()))
s = min(e)
q = 0
for i in range(0, 3):
	if e[i] == s:
		q += i
if q == 0:
	if e[2] == s + 1:
		print(s - 1 + s + s + 1)
	else:
		print(s + s + 1 + s + 2)
elif q == 1:
	print(s - 1 + s + s + 1)
else:
	print(s - 2 + s - 1 + s)


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
while c >= 3:
	if b >= c - 1 and a >= c - 2:
		print(c + c - 1 + c - 2)
		break
	c = c - 1


(l, m, n) = map(int, input().split())
y = b = r = 0
if l <= m and l <= n:
	y = l
	b = l + 1
	r = l + 2
elif m <= l and m <= n:
	y = m - 1
	b = m
	r = m + 1
else:
	y = n - 2
	b = n - 1
	r = n
while 1:
	if y <= l and b <= m and (r <= n):
		print(3 * b)
		break
	else:
		y -= 1
		b -= 1
		r -= 1


def solve(y, b, r):
	maxi = 0
	for i in range(1, y + 1):
		if i + 1 <= b and i + 2 <= r:
			maxi = max(i, maxi)
	return maxi * 3 + 3

def main():
	(y, b, r) = list(map(int, input().split()))
	print(solve(y, b, r))
main()


TN = 1

def solution():
	(y, b, r) = map(int, input().split())
	print(3 * min(y, b - 1, r - 2) + 3)
while TN != 0:
	solution()
	TN -= 1


def cal(a1, b1):
	if a1 > b1:
		a1 = b1 - 1
	elif a1 < b1:
		b1 = a1 + 1
	else:
		a1 -= 1
	return (a1, b1)
(a, b, c) = map(int, input().split())
(a1, b1) = cal(a, b)
if b1 > c:
	d = b1 - c + 1
	print(a1 - d + b1 - d + c)
elif b1 < c:
	print(a1 + b1 + b1 + 1)
else:
	print(a1 + b1 + c - 2)


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
x = 0
while True:
	if y + 1 <= b and y + 2 <= r:
		x = y * 3 + 3
		print(x)
		break
	else:
		y -= 1


print(3 + 3 * min(map(lambda item: int(item[1]) - item[0], enumerate(input().split()))))


from math import *
from cmath import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
from types import CodeType, new_class
(n, m, k) = map(int, input().split())
print(min(n, m - 1, k - 2) * 3 + 3)


a = input().split()
z = []
for i in a:
	z.append(int(i))
z[1] -= 1
z[2] -= 2
print(min(z) * 3 + 3)


(y, b, r) = map(int, input().split())
l = 0
m = l + 1
n = m + 1
while l != y and m != b and (n != r):
	l += 1
	m += 1
	n += 1
summ = l + m + n
print(summ)


print(min((c - i for (i, c) in enumerate(map(int, input().split()), -1))) * 3)


(a, b, c) = map(int, input().split())

def abc(a, b, c):
	while True:
		if b >= a + 1 and c >= a + 2:
			return 3 * a + 3
		else:
			a -= 1
print(abc(a, b, c))


(y, b, r) = map(int, input().strip().split())
for i in range(y):
	if b >= y + 1:
		break
	else:
		y -= 1
b = y + 1
for j in range(b):
	if r >= b + 1:
		break
	else:
		b -= 1
r = b + 1
y = r - 2
summa = r + b + y
print(summa)


(q, w, e) = map(int, input().split())
print(min(q * 3 + 3, w * 3, e * 3 - 3))


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
a = min(y, b, r)
if r == a:
	print(3 * r - 3)
elif b == a:
	print(3 * b)
elif y == a:
	if r > b:
		print(3 * y + 3)
	elif r >= y + 2:
		print(3 * y + 3)
	else:
		print(3 * y)


y_b_r = list(map(int, input().rstrip().split()))
(y, b, r) = (y_b_r[0], y_b_r[1], y_b_r[2])
if r - 1 <= b:
	if r - 2 <= y:
		print(r + (r - 1) + (r - 2))
	elif r - 2 > y:
		print(y + 2 + (y + 1) + y)
elif r - 1 > b:
	if b - 1 <= y:
		print(b + 1 + b + (b - 1))
	elif b - 1 > y:
		print(y + 2 + (y + 1) + y)


n = 3
f = 100
x = list(map(int, input().split()))
for i in range(n):
	l = x[i] - i
	if l < f:
		f = l
s = f * 3 + 3
print(s)


import sys
(y, b, r) = list(map(int, input().split()))
for i in range(1, r + 1):
	(ys, bs, rs) = (i, i + 1, i + 2)
	if ys > y or bs > b or rs > r:
		break
	sol = ys + bs + rs
print(sol)
sys.stdout.flush()


(y, b, r) = list(map(int, input().split()))
val = 0
if r <= b and r <= y:
	val = r + (r - 1) + (r - 2)
elif b <= r and b <= y:
	if r > b:
		val = b + b + 1 + b - 1
	else:
		val = b - 1 + b + b - 2
elif r == y + 1:
	val = y - 1 + y + y + 1
else:
	val = y + y + 1 + y + 2
print(val)


from sys import stdin
(y, b, r) = map(int, stdin.readline().strip().split())
for i in range(110, 2, -1):
	if r >= i and b >= i - 1 and (y >= i - 2):
		print(i + i + i - 3)
		break


(y, b, r) = map(int, input().split())
sum = 0
while True:
	if b >= y + 1 and r >= y + 2:
		sum = y + y + 1 + y + 2
		break
	else:
		y = y - 1
print(sum)


(y, b, r) = map(int, input().split())
arr = [y, b, r]

def findMinPosition(arr):
	minP = 0
	for i in range(1, 2):
		if arr[minP] > arr[i]:
			minP = i
	return minP
minP = findMinPosition(arr)
output = 0
if minP == 0:
	n = arr[0]
	while n > 0:
		if n + 1 <= arr[1] and n + 2 <= arr[2]:
			output = 3 * n + 3
			break
		n -= 1
elif minP == 1:
	n = arr[1]
	while n > 0:
		if n - 1 <= arr[0] and n + 1 <= arr[2]:
			output = 3 * n
			break
		n -= 1
else:
	n = arr[2]
	while n > 0:
		if n - 1 <= arr[1] and n - 2 <= arr[0]:
			output = 3 * n - 3
			break
		n -= 1
print(output)


(y, b, r) = input().split()
(y, b, r) = (int(y), int(b), int(r))
if y == b == r:
	print(y + y - 1 + y - 2)
elif min(y, b, r) == y:
	if b - y >= 1 and r - y >= 2:
		print(y + y + 1 + y + 2)
	elif b - y >= 1 and r - y == 1:
		print(y - 1 + y + 1 + y)
	elif y == b and r - y >= 2:
		print(y - 1 + y + y + 1)
	elif y == r and b - r >= 1:
		print(y - 2 + y - 1 + y)
elif min(y, b, r) == b:
	if b != r:
		print(b - 1 + b + b + 1)
	elif b == r:
		print(b + b - 1 + b - 2)
elif min(y, b, r) == r:
	print(r + r - 1 + r - 2)


def main():
	(y, b, r) = map(int, input().split())
	mn = min(r - 2, b - 1, y)
	if mn < 0:
		print(0)
	else:
		print(mn * 3 + 3)
main()


(Ornament_Yellow, Ornament_Blue, Ornament_Red) = input().split()
Ornament_Yellow = int(Ornament_Yellow)
Ornament_Blue = int(Ornament_Blue)
Ornament_Red = int(Ornament_Red)
ans_Yellow = Ornament_Yellow
ans_Blue = Ornament_Blue
ans_Red = Ornament_Red
if Ornament_Blue >= Ornament_Red:
	ans_Blue = Ornament_Red - 1
else:
	ans_Red = Ornament_Blue + 1
if Ornament_Yellow >= ans_Blue:
	ans_Yellow = ans_Blue - 1
else:
	ans_Blue = Ornament_Yellow + 1
	ans_Red = ans_Blue + 1
answer = ans_Blue + ans_Red + ans_Yellow
print(answer)


s = 0
(a, b, c) = map(int, input().split())
for i in range(1, 99):
	if a >= i and b >= i + 1 and (c >= i + 2):
		s = i + i + 1 + i + 2
	else:
		break
print(s)


(a, b, c) = map(int, input().split())
x = min(a, b, c)
if x == c:
	print(c * 3 - 3)
elif x == b and a >= b - 1:
	print(b * 3)
elif x == a:
	if b >= a + 1 and c >= a + 2:
		print(a * 3 + 3)
	else:
		print(c * 3 - 3)


strings = input()
number = []
number = strings.split(' ')
for i in range(len(number)):
	number[i] = int(number[i]) - i
index = number.index(min(number))
if index == 0:
	print(number[index] * 3 + 3)
elif index == 1:
	print((number[index] + 1) * 3)
elif index == 2:
	print((number[index] + 2) * 3 - 3)


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
if r - b <= 1:
	b = r - 1
	if b - y <= 1:
		print(3 * (r - 1))
	else:
		print(3 * (y + 1))
else:
	r = b + 1
	if b - y <= 1:
		print(3 * (r - 1))
	else:
		print(3 * (y + 1))


import math
(a, b, c) = map(int, input().strip().split())
x = min(a, b - 1, c - 2)
e = x + x + 1 + x + 2
print(e)


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
potY = 1
potB = 2
potR = 3
while potY < y and potB < b and (potR < r):
	potY += 1
	potB += 1
	potR += 1
print(potY + potB + potR)


(x, y, z) = map(int, input().split())
if x + 1 <= y and x + 2 <= z:
	print(x + x + 1 + x + 2)
elif y - 1 <= x and y + 1 <= z:
	print(3 * y)
else:
	print(z - 1 + z - 2 + z)


(y, b, r) = [int(i) for i in input().split()]
min = y
if b <= min:
	min = b
if r <= min:
	min = r
if min == b and min == r:
	min = r
if min == b and min != r:
	print(3 * b)
elif min == r:
	print(3 * r - 3)
elif b - r != 0 and r > b:
	print(3 * y + 3)
elif b - r != 0 and b > r:
	if r - y != 1:
		print(3 * y + 3)
	elif r - y == 1:
		print(3 * r - 3)
elif b - r == 0 and r - y != 1:
	print(3 * y + 3)
elif b - r == 0 and r - y == 1:
	print(3 * r - 3)


a = input().split()
y = int(a[0])
b = int(a[1])
r = int(a[2])
d = y
e = b - 1
f = r - 2
g = min(d, e, f)
print(g * 3 + 3)


class Tree:

	def solve(self, y, b, r):
		ans = 0
		if b >= y + 1 and r >= y + 2:
			ans = 3 * y + 3
		if y >= b - 1 and r >= b + 1:
			ans = max(ans, 3 * b)
		if y >= r - 2 and b >= r - 1:
			ans = max(ans, 3 * r - 3)
		print(ans)
(y, b, r) = map(int, input().split())
A = Tree()
A.solve(y, b, r)


(y, b, r) = map(int, input().split())
l = []
s = 0
pick = y
while 1:
	if b >= pick + 1 and r >= pick + 2:
		s = 3 * pick + 3
		break
	else:
		pick -= 1
print(s)


import math
(yellow, blue, red) = input().split(' ')
yellow = int(yellow)
blue = int(blue)
red = int(red)
y = 1
b = 2
r = 3
while y < yellow and b < blue and (r < red):
	y += 1
	b += 1
	r += 1
total = y + b + r
print(total, end='')


(y, b, r) = input().split()
Y = int(y)
B = int(b)
R = int(r)
small = min(Y, B - 1, R - 2)
cnt = 3 * small + 3
print(cnt)


s = input()
s = s.split(' ')
for i in range(3):
	s[i] = int(s[i])
mini = s[0]
minindex = 0
result = 0
for i in range(1, 3):
	if s[i] <= mini:
		mini = s[i]
		minindex = i
if minindex == 0:
	if s[2] > s[0] + 1:
		result = 3 * s[0] + 3
	else:
		result = 3 * (s[0] - 1) + 3
elif minindex == 1:
	result = 3 * s[1]
elif minindex == 2:
	result = 3 * s[2] - 3
print(result)


a = list(map(int, input().split()))
for i in range(3):
	a[i] -= i
print(min(a) * 3 + 3)


(a, b, c) = map(int, input().split())

def check(aa, bb, cc):
	if aa <= a and bb <= b and (cc <= c):
		return 1
	else:
		return 0
for x in range(100, -1, -1):
	if check(x, x + 1, x + 2):
		print(x * 3 + 3)
		break


(y, b, r) = [int(item) for item in input().split()]
m = -1
for i in range(y + 1):
	j = i + 1
	k = j + 1
	if j <= b and k <= r:
		m = max(m, i + j + k)
print(m)


(y, b, r) = map(int, input().split())
ans = 0
for i in range(1, y + 1):
	if i + 1 <= b and i + 2 <= r:
		ans = max(ans, i + i + 1 + i + 2)
	else:
		break
print(ans)


vr = ''
q = 0
it = 0
s = input()
s = s + ' '
while it < 3:
	while s[q] != ' ':
		vr = vr + s[q]
		q = q + 1
	else:
		q = q + 1
		it = it + 1
		if it == 1:
			a = int(vr)
		elif it == 2:
			b = int(vr)
		else:
			c = int(vr)
		vr = ''
a = a + 1
c = c - 1
v = min(a, b, c) * 3
print(v)


(y, b, r) = list(map(int, input().split()))
max = 0
if y + 1 <= b and y + 2 <= r and (y + y + 1 + y + 2 > max):
	max = y + y + 1 + y + 2
if b - 1 <= y and b + 1 <= r and (b - 1 + b + b + 1 > max):
	max = b - 1 + b + b + 1
if r - 2 <= y and r - 1 <= b and (r - 2 + r - 1 + r > max):
	max = r - 2 + r - 1 + r
print('{:d}'.format(max))


def solve(y, b, r):
	ans = 0
	(tempy, tempb, tempr) = (1, 2, 3)
	while tempy < tempb < tempr and (tempy <= y and tempb <= b and (tempr <= r)):
		tempy += 1
		tempb = tempy + 1
		tempr = tempb + 1
	print(tempy + tempb + tempr - 3)

def main():
	(y, b, r) = map(int, input().split())
	solve(y, b, r)
main()


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
rv = 3
bv = 2
yv = 1
while rv < r and bv < b and (yv < y):
	rv = rv + 1
	bv = bv + 1
	yv = yv + 1
print(rv + bv + yv)


class Solution(object):

	def solve(self):
		(y, b, r) = map(int, input().strip().split(' '))
		for _y in range(y, 0, -1):
			if _y + 1 <= b and _y + 2 <= r:
				return _y * 3 + 3
sol = Solution()
print(sol.solve())


(y, b, r) = map(int, input().split())
xr = r
xb = xr - 1
xy = xb - 1
if xb > b:
	xr = xr - (xb - b)
	xy = xy - (xb - b)
	xb = b
if xy > y:
	xr = xr - (xy - y)
	xb = xb - (xy - y)
	xy = y
print(xy + xb + xr)


(y, b, r) = [int(i) for i in input().split()]
x = 0
while x < y and x + 1 < b and (x + 2 < r):
	x += 1
print(x * 3 + 3)


(y, b, r) = map(int, input().split())
z = 0
while r >= 3:
	if b >= r - 1 and y >= r - 2:
		b = r - 1
		y = b - 1
		z = 1
		x = r + y + b
		print(x)
		break
	else:
		r = r - 1
if z == 0:
	print(6)


(y, b, r) = map(int, input().split())
ok = False
while ok == False:
	if r > b + 1:
		r -= 1
	if b >= r:
		b -= 1
	if b > y + 1:
		b -= 1
	if y >= b:
		y -= 1
	if y + 1 == b and b + 1 == r:
		ok = True
print(3 * y + 3)


import sys
inf = float('inf')
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
(y, b, r) = get_ints()
mini = min(y, b, r)
(yi, bi, ri) = (0, 1, 2)
for i in range(mini):
	yi += 1
	ri += 1
	bi += 1
	if yi == y or ri == r or bi == b:
		break
print(yi + ri + bi)


(y, b, r) = [int(i) for i in input().split()]
potential = 0
if y + 1 <= b and y + 2 <= r:
	potential = max(potential, 3 * (y + 1))
if b - 1 <= y and b + 1 <= r:
	potential = max(potential, 3 * b)
if r - 2 <= y and r - 1 <= b:
	potential = max(potential, 3 * (r - 1))
print(potential)


(i, j, k) = map(int, input().split())
res = 0
if j > i and k > i + 1:
	res = max(res, i * 3 + 3)
if i > j - 2 and k > j:
	res = max(res, j * 3)
if i > k - 3 and j > k - 2:
	res = max(res, k * 3 - 3)
print(res)


from sys import stdin
(y, b, r) = map(int, stdin.readline().rstrip().split(' '))
m = 6
for i in range(2, 99):
	if y >= i and b >= i + 1 and (r >= i + 2):
		m = 3 * i + 3
print(m)


l = list(map(int, input().split()))
m = min(l)
if l[-1] == m:
	print((m - 1) * 3)
elif l[-2] == m:
	print(m * 3)
elif l[-1] >= l[0] + 2:
	print((m + 1) * 3)
else:
	print((l[-1] - 1) * 3)


def main():
	list_of_obj = [int(i) for i in input().split()]
	yellow = list_of_obj[0]
	blue = list_of_obj[1]
	red = list_of_obj[2]
	for i in range(red, 0, -1):
		if yellow >= i - 2 and blue >= i - 1:
			print(3 * i - 3)
			break
main()


(y, b, r) = map(int, input().split())
a = min(y, b, r)
if a <= y and a + 1 <= b and (a + 2 <= r):
	print(a * 3 + 3)
	exit()
if a - 1 <= y and a <= b and (a + 1 <= r):
	print((a - 1) * 3 + 3)
	exit()
if a - 2 <= y and a - 1 <= b and (a <= r):
	print((a - 2) * 3 + 3)
	exit()


[y, b, r] = [int(x) for x in input().split(' ')]
maxY = 1
maxB = 2
maxR = 3
for i in range(1, y + 1):
	if b - i >= 1 and r - i >= 2:
		(maxY, maxB, maxR) = (i, i + 1, i + 2)
	else:
		break
print(sum([maxY, maxB, maxR]))


a = list(map(int, input().split()))
b = max(a)
j = []
for i in range(b):
	k = [i, i + 1, i + 2]
	if a[0] >= k[0] and a[1] >= k[1] and (a[2] >= k[2]):
		j.append(k)
print(sum(j[-1]))


import sys
l = list(reversed([int(e) for e in input().strip().split()]))
sol = 0
while True:
	idx = l.index(max(l))
	if idx == 0 and l[1] >= l[0] - 1 and (l[2] >= l[0] - 2):
		sol = 3 * l[0] - 3
		break
	elif idx == 1 and l[0] >= l[1] + 1 and (l[2] >= l[1] - 1):
		sol = 3 * l[1]
		break
	elif idx == 2 and l[0] >= l[2] + 2 and (l[1] >= l[2] + 1):
		sol = 3 * l[2] + 3
		break
	else:
		l[idx] -= 1
print(sol)
sys.stdout.flush()


a = input().split(' ')
y = int(a[0])
b = int(a[1])
r = int(a[2])
for i in range(2):
	if y >= b:
		y = b - 1
	if r > b:
		r = b + 1
	if b >= r:
		b = r - 1
	if b > y:
		b = y + 1
print(y + b + r)


(y, b, r) = [int(c) for c in input().split()]
x = min(y, b, r)
if x == y:
	while 1:
		if b >= y + 1 and r >= y + 2:
			b = y + 1
			r = y + 2
			break
		else:
			y = y - 1
elif x == b:
	while 1:
		if r >= b + 1:
			y = b - 1
			r = b + 1
			break
		else:
			b = b - 1
elif x == r:
	b = r - 1
	y = b - 1
print(y + b + r)


(y, b, r) = map(int, input().split())
res = 6
y -= 1
b -= 2
r -= 3
while y * b * r:
	res += 3
	y -= 1
	b -= 1
	r -= 1
print(res)


import math
import os
import random
import re
import sys

def ProblemA(a, b, c):
	if b >= a + 1 and c >= a + 2:
		return 3 * a + 3
	elif a >= b - 1 and c >= b + 1:
		return 3 * b
	elif a >= c - 2 and b >= c - 1:
		return 3 * c - 3
l = list(map(int, input().rstrip().split()))
a = l[0]
b = l[1]
c = l[2]
print(ProblemA(a, b, c))


l = list(map(int, input().split()))
if l[1] >= l[2] - 1 and l[0] >= l[2] - 2:
	print(3 * (l[2] - 1))
else:
	mini = min(l)
	if mini == l[2]:
		print(3 * (mini - 1))
	elif mini == l[1]:
		print(3 * mini)
	else:
		print(3 * (mini + 1))


l = list(map(int, input().split()))
i = l.index(min(l))
for j in range(len(l)):
	if l[j] == l[i]:
		i = j
if i == 0:
	if l[i] + 1 <= l[i + 1] and l[i] + 2 <= l[i + 2]:
		print(3 * l[i] + 3)
	elif l[i] + 2 > l[i + 2]:
		print(3 * l[i + 2] - 3)
elif i == 1:
	if l[i] - 1 <= l[i - 1] and l[i] + 1 <= l[i + 1]:
		print(3 * l[i])
elif l[i] - 2 <= l[i - 2] and l[i] - 1 <= l[i - 1]:
	print(3 * l[i] - 3)


(y, b, r) = (int(s) for s in input().split())
m = min(y, b, r)
ans = 0
if m == r:
	ans = 3 * r - 3
elif m == b:
	if b < r:
		ans = 3 * b
elif y == r - 1:
	ans = 3 * r - 3
else:
	ans = 3 * y + 3
print(ans)


(y, b, r) = tuple(map(int, input().split()))
if min(r, min(b, y)) == r:
	print(3 * r - 3)
elif min(r, min(b, y)) == b:
	print(3 * b)
else:
	while y + 2 > r:
		y -= 1
	print(3 * y + 3)


(y, b, r) = map(int, input().split())
d = b - 1
f = r - 2
g = min(y, d, f)
l = [g, g + 1, g + 2]
k = sum(l)
print(k)


(y, b, r) = map(int, input().split())
b = b - 1
t = min(b, y)
r = r - 2
re = min(t, r)
print(re + re + 1 + re + 2)


(y, b, r) = map(int, input().split())
l = 1
m = 2
n = 3
sum = 0
if y >= b and y >= r:
	k = y
elif b >= r:
	k = b
else:
	k = r
for i in range(k):
	if y > l and b > m and (r > n):
		l = l + 1
		m = m + 1
		n = n + 1
print(l + m + n)


def read_int():
	return int(input().strip())

def read_int_list():
	return list(map(int, input().strip().split()))

def read_string():
	return input().strip()

def read_string_list(delim=' '):
	return input().strip().split(delim)
import sys
import math
[y, b, r] = read_int_list()
least = 1
for i in range(1, y + 1):
	if i + 1 <= b and i + 2 <= r:
		least = i
print(3 * least + 3)


(a, b, c) = map(int, input().split())
(x, y, z) = (1, 2, 3)
while a > x and b > y and (c > z):
	x += 1
	y += 1
	z += 1
print(x + y + z)


R = lambda : map(int, input().split())
(y, b, r) = R()
mi = min(y, b, r)
if mi == y:
	if mi == r:
		print(r - 2 + r - 1 + r)
	elif mi == b:
		print(b - 1 + b + b + 1)
	elif mi + 2 > r:
		print(r - 2 + r - 1 + r)
	else:
		print(y + y + 1 + y + 2)
elif mi == b:
	if mi == r:
		print(r - 2 + r - 1 + r)
	else:
		print(mi - 1 + mi + mi + 1)
elif mi == r:
	print(mi - 2 + mi - 1 + mi)


arr = list(map(int, input().split()))
arr2 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
arr2[0][0] = arr[0]
arr2[0][1] = arr[0] + 1
arr2[0][2] = arr[0] + 2
arr2[1][0] = arr[1] - 1
arr2[1][1] = arr[1]
arr2[1][2] = arr[1] + 1
arr2[2][0] = arr[2] - 2
arr2[2][1] = arr[2] - 1
arr2[2][2] = arr[2]
if arr2[0][0] <= arr[0] and arr2[0][1] <= arr[1] and (arr2[0][2] <= arr[2]):
	print(arr2[0][0] + arr2[0][1] + arr2[0][2])
elif arr2[1][0] <= arr[0] and arr2[1][1] <= arr[1] and (arr2[1][2] <= arr[2]):
	print(arr2[1][0] + arr2[1][1] + arr2[1][2])
elif arr2[2][0] <= arr[0] and arr2[2][1] <= arr[1] and (arr2[2][2] <= arr[2]):
	print(arr2[2][0] + arr2[2][1] + arr2[2][2])


list1 = input().split()
f = 0
(y, b, r) = (int(list1[0]), int(list1[1]), int(list1[2]))
A = min(y, b - 1, r - 2)
if A == y:
	f = y * 3 + 3
elif A == b - 1:
	f = b * 3
elif A == r - 2:
	f = r * 3 - 3
print(f)


(y, b, r) = map(int, input().split())
maxi = -2 ** 31 - 1
while y > 0:
	if b - y > 0 and r - y - 1 > 0:
		maxi = max(maxi, y * 3 + 3)
		break
	else:
		y = y - 1
print(maxi)


N = list(map(int, input().split()))
if N[2] - N[1] == 0:
	N[1] -= 1
if N[2] - N[0] == 0:
	N[0] -= 2
if N[2] - N[0] == 1:
	N[0] -= 1
if N[1] - N[0] == 0:
	N[0] -= 1
minimum = 101
minindex = -1
for i in range(3):
	if N[i] < minimum:
		minimum = N[i]
		minindex = i
if minindex == 0:
	print((minimum + 1) * 3)
if minindex == 1:
	print(minimum * 3)
if minindex == 2:
	print((minimum - 1) * 3)


orns = input().split(' ')
for i in range(len(orns)):
	orns[i] = int(orns[i])
m = orns[0]
while m + 1 > orns[1] or m + 2 > orns[2]:
	m -= 1
print(m + m + 1 + m + 2)


def retarray():
	return list(map(int, input().split()))
(y, b, r) = retarray()
f = True
while f:
	if y + 1 <= b and y + 2 <= r:
		f = False
	y -= 1
print(3 * (y + 1) + 3)


(yellow, blue, red) = input().split(' ')
yellow = int(yellow)
blue = int(blue)
red = int(red)
if red - 1 <= blue and red - 2 <= yellow:
	decoration = red - 2 + red - 1 + red
elif red - 1 > blue and blue - 1 < yellow:
	decoration = blue - 1 + blue + blue + 1
else:
	decoration = yellow + yellow + 1 + yellow + 2
print(decoration)


(y, b, r) = map(int, input().split())
xx = r - 1
yy = r - 2
if y >= yy and b >= xx:
	print(xx + yy + r)
	exit()
if y < yy and b >= xx:
	print(y + y + 1 + y + 2)
	exit()
if b < xx and y >= yy:
	print(3 * b)
	exit()
if b < xx and y < yy:
	if b <= y:
		print(3 * b)
		exit()
	else:
		print(3 * y + 3)
		exit()


def out(x):
	print(x)
	exit(0)
n = input().split(' ')
for i in range(len(n)):
	n[i] = int(n[i])
(yellow, blue, red) = (n[0], n[1], n[2])
n.sort()
if yellow < blue < red:
	output = 3 * yellow + 3
	out(output)
if yellow < blue and red > yellow + 1:
	output = 3 * yellow + 3
	out(output)
if n[0] == yellow and red == yellow:
	output = 3 * yellow - 3
	out(output)
elif n[0] == yellow and blue == yellow:
	output = 3 * yellow
	out(output)
elif n[0] == yellow and red == yellow + 1:
	output = 3 * yellow
	out(output)
elif n[0] == blue and red == blue:
	output = red * 3 - 3
	out(output)
elif n[0] == blue and red > blue:
	output = 3 * blue
	out(output)
elif n[0] == red:
	output = red * 3 - 3
	out(output)


from sys import stdin, stdout
(y, b, r) = [int(x) for x in stdin.readline().split()]
ans = 0
if r - 1 <= b and r - 2 <= y:
	ans = r
elif b + 1 <= r and b - 1 <= y:
	ans = b + 1
else:
	ans = y + 2
ans = 3 * ans - 3
stdout.write(str(ans))


a = [int(x) for x in input().split()]
for i in range(a[0] + 1):
	if i + 1 >= a[1] or i + 2 >= a[2]:
		break
sum = i + i + 1 + i + 2
print(sum)


(y, b, r) = map(int, input().split())
for i in range(1, y + 1):
	for j in range(1, b + 1):
		for k in range(1, r + 1):
			if k == j + 1 and j == i + 1:
				red = k
				blue = j
				yellow = i
print(red + blue + yellow)


def f(a, b, c):
	if a + 1 <= b and a + 2 <= c:
		return 3 * a + 3
	else:
		return f(a - 1, b, c)
(a, b, c) = map(int, input().split())
print(f(a, b, c))


l = list(map(int, input().split()))
l[1] -= 1
l[2] -= 2
a = min(l)
b = a + (a + 1) + (a + 2)
print(b)


import sys
(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
for i in range(1, y + 1):
	if i + 1 <= b and i + 2 <= r:
		y1 = i + i + 1 + i + 2
print(y1)


(a, b, c) = map(int, input().split())
idx = [0, 1, 2]
l = [a, b - 1, c - 2]
d = [y for (x, y) in sorted(zip(l, idx))]
ans = l[d[0]] * 3 + 3
print(ans)


a = list(map(int, input().split()))
if min(a) == a[2] and max(a) == a[0]:
	print(3 * a[2] - 3)
elif min(a) == a[1] and max(a) == a[0]:
	print(3 * a[1])
elif min(a) == a[0] and max(a) == a[1]:
	if a[2] - a[0] == 2 or a[2] - a[0] > 2:
		print(3 * a[0] + 3)
	else:
		print(3 * a[2] - 3)
elif min(a) == a[2] and max(a) == a[1]:
	print(3 * a[2] - 3)
elif min(a) == a[1] and max(a) == a[2]:
	print(3 * a[1])
elif min(a) == a[0] and max(a) == a[2]:
	if a[2] - a[0] == 2 or a[2] - a[0] > 2:
		print(3 * a[0] + 3)
	else:
		print(3 * a[2] - 3)
elif a[0] == a[1] and a[1] == a[2]:
	print(3 * a[2] - 3)
elif a[0] == a[1] and a[1] > a[2]:
	print(3 * a[2] - 3)
elif a[0] == a[1] and a[1] < a[2]:
	print(3 * a[1])
elif a[1] == a[2] and a[0] < a[2]:
	print(3 * a[0] + 3)
elif a[1] == a[2] and a[0] > a[2]:
	print(3 * a[2] - 3)
elif a[0] == a[2] and a[1] > a[2]:
	print(3 * a[2] - 3)
elif a[0] == a[2] and a[1] < a[2]:
	print(3 * a[1])


(y, b, r) = map(int, input().split())
a = [y + 2, b + 1, r]
if len(set(a)) == 1:
	pass
elif min(a) == a[2]:
	(y, b) = (r - 2, r - 1)
elif min(a) == a[1]:
	(y, r) = (b - 1, b + 1)
else:
	(b, r) = (y + 1, y + 2)
print(y + b + r)


def max(l):
	y = l[0]
	b = y + 1
	r = b + 1
	if b <= l[1]:
		if r <= l[2]:
			print(y + b + r)
			return
		else:
			l[0] = l[0] - 1
			max(l)
	else:
		l[0] = l[0] - 1
		max(l)
l = [int(i) for i in input().split()]
max(l)


a = [int(x) for x in input().split()]
y = a[0]
b = a[1]
r = a[2]
miny = y
minb = b - 1
minr = r - 2
mn = min(miny, minb, minr)
ans = mn * 3 + 3
print(ans)


l = list(map(int, input().split()))
while 1:
	if l[1] - l[0] != 1:
		if l[0] >= l[1]:
			l[0] -= 1
		elif l[0] < l[1]:
			l[1] -= 1
	if l[2] - l[1] != 1:
		if l[1] >= l[2]:
			l[1] -= 1
		elif l[1] < l[2]:
			l[2] -= 1
	if l[1] - l[0] == 1:
		if l[2] - l[1] == 1:
			break
print(sum(l))


(a, b, c) = map(int, input().split())
m = min(a, b, c)
a = min(a, m)
b = min(b, m + 1)
c = min(c, m + 2)
for i in range(2):
	if a > b - 1:
		a = b - 1
	elif a < b - 1:
		b = a + 1
	if b > c - 1:
		b = c - 1
	if b < c - 1:
		c = b + 1
print(a + b + c)


(y, b, r) = map(int, input().split())
smallest = None
for i in [y, b, r]:
	if smallest == None:
		smallest = i
	elif smallest > i:
		smallest = i
if smallest == b != r:
	add = 3 * b
	print(add)
elif smallest == r or smallest == y == b == r:
	add = 3 * r - 3
	print(add)
elif y + 1 == r and smallest == y:
	add = 3 * r - 3
	print(add)
elif smallest == y != b:
	add = 3 * y + 3
	print(add)
quit()


(y, b, r) = map(int, input().split())
d1 = b - y
d2 = r - b
if d1 >= 1 and d2 >= 1 or (d1 >= 1 and d2 < 1 and (y < r - 2)):
	s = 3 * y + 3
elif d1 < 1 and d2 >= 1:
	s = 3 * b
elif d1 >= 1 and d2 < 1 and (y >= r - 2) or (d1 < 1 and d2 < 1):
	s = 3 * r - 3
print(s)


import math as mt
import itertools as it
import functools as ft
import random as rnd
stdin = lambda type_='int', sep=' ': list(map(eval(type_), input().split(sep)))
joint = lambda sep=' ', *args: sep.join((str(i) if type(i) != list else sep.join(map(str, i)) for i in args))
(y, b, r) = stdin()
(i, j, k) = (y, y + 1, y + 2)
if i <= y and j <= b and (k <= r):
	print(i + j + k)
	exit(0)
(i, j, k) = (b - 1, b, b + 1)
if i <= y and j <= b and (k <= r):
	print(i + j + k)
	exit(0)
(i, j, k) = (r - 2, r - 1, r)
if i <= y and j <= b and (k <= r):
	print(i + j + k)
	exit(0)


def read_input():
	ornaments = input()
	ornaments = [int(ornament) for ornament in ornaments.strip().split()]
	return ornaments

def find_max_ornaments(yellow, blue, red):
	min_yellow = min([yellow, blue - 1, red - 2])
	return min_yellow * 3 + 3
ornaments = read_input()
max_ornaments = find_max_ornaments(*ornaments)
print(max_ornaments)


ls = list(map(int, input('').split(' ')))
result = 0
ls.reverse()
mini = min(ls)
addr = ls.index(mini)
if addr == 0:
	print(mini * 3 - 3)
elif addr == 1:
	flag = 1
	while flag == 1:
		if ls[0] >= mini + 1:
			flag = 0
		else:
			mini -= 1
	print(mini * 3)
else:
	flag = 1
	while flag == 1:
		if ls[0] >= mini + 2 and ls[1] >= mini + 1:
			flag = 0
		else:
			mini -= 1
	print(mini * 3 + 3)


import sys

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def input():
	return sys.stdin.readline().strip()
(y, b, r) = get_ints()
for i in range(r, 0, -1):
	if r - 1 <= b and r - 2 <= y:
		break
	else:
		r = r - 1
print(3 * r - 3)


ornS = [int(i) for i in input().split()]
min_ = min(ornS)
ans = 0
if min_ == ornS[2]:
	print(ornS[2] * 3 - 3)
elif min_ == ornS[0]:
	ans = 0
	k = ornS[0]
	while True:
		if ornS[0] + 2 <= ornS[2] and ornS[0] + 1 <= ornS[1]:
			ans = ornS[0] * 3 + 3
			break
		ornS[0] -= 1
	print(ans)
elif min_ == ornS[1]:
	ans = 0
	k = ornS[1]
	while True:
		if ornS[1] + 1 <= ornS[2] and ornS[1] - 1 <= ornS[0]:
			ans = ornS[1] * 3
			break
		ornS[1] -= 1
	print(ans)


(y, b, r) = [int(i) for i in input().split()]
oy = ob = or1 = 0
a = [y, b, r]
mm = a.index(min(a))
if mm == 2:
	or1 = r
	ob = r - 1
	oy = r - 2
elif mm == 1:
	if r >= b + 1:
		or1 = b + 1
		ob = b
		oy = b - 1
	else:
		or1 = b
		ob = b - 1
		oy = b - 2
elif b >= y + 1:
	if r >= y + 2:
		or1 = y + 2
		ob = y + 1
		oy = y
	elif r == y + 1:
		or1 = y + 1
		ob = y
		oy = y - 1
	else:
		or1 = y
		ob = y - 1
		oy = y - 2
elif r >= y + 1:
	or1 = y + 1
	ob = y
	oy = y - 1
else:
	or1 = y
	ob = y - 1
	oy = y - 2
print(oy + ob + or1)


A = list(map(int, input().split()))
y = A[0]
b = A[1]
r = A[2]
s = 1
t = 2
u = 3
while u < r and t < b and (s < y):
	s = s + 1
	t = t + 1
	u = u + 1
print(s + t + u)


import sys
ybr = list(map(int, sys.stdin.readline().strip().split()))
print(3 * min([ybr[0], ybr[1] - 1, ybr[2] - 2]) + 3)


(y, b, r) = [int(s) for s in input().split()]
if r == b - 1 and b == y - 1:
	print(y + b + r)
elif b < r - 1:
	r = b + 1
	if y < b - 1:
		b = y + 1
		r = b + 1
		print(y + b + r)
	else:
		y = b - 1
		print(y + b + r)
else:
	b = r - 1
	if y < b - 1:
		print(3 * y + 3)
	else:
		y = b - 1
		print(y + b + r)


def main():
	[y, b, r] = [int(_) for _ in input().split()]
	y = min(y, b - 1, r - 2)
	print(3 * (y + 1))
main()


def chrismas_tree():
	lights = input().split()
	lights = [int(i) for i in lights]
	min_index = 0
	minimum = lights[0]
	for i in range(1, len(lights)):
		if lights[i] < minimum:
			minimum = i
			min_index = i
	if min_index == 0:
		while True:
			if lights[1] > lights[0] and lights[2] > lights[0] + 1:
				print(lights[0] + (lights[0] + 1) + (lights[0] + 2))
				return
			else:
				lights[0] -= 1
	elif min_index == 1:
		while True:
			if lights[0] >= lights[1] - 1 and lights[2] > lights[1]:
				print(lights[1] - 1 + lights[1] + (lights[1] + 1))
				return
			else:
				lights[1] -= 1
	else:
		while True:
			if lights[2] - 2 <= lights[0] and lights[2] - 1 <= lights[1]:
				print(lights[2] + (lights[2] - 1) + (lights[2] - 2))
				return
			else:
				lights[2] -= 1
chrismas_tree()


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	(a, b, c) = LI()
	ans = 0
	for i in range(1000):
		if a >= i and b >= i + 1 and (c >= i + 2):
			ans = i * 3 + 3
		else:
			return ans
print(main())


(y, b, r) = list(map(int, input().split()))
m = r
if m - 1 <= b and m - 2 <= y:
	print(m + m - 1 + m - 2)
elif m - 1 > b:
	m -= m - 1 - b
	if m - 1 <= b and m - 2 <= y:
		print(m + m - 1 + m - 2)
	elif m - 2 > y:
		m -= m - 2 - y
		if m - 1 <= b and m - 2 <= y:
			print(m + m - 1 + m - 2)
elif m - 2 > y:
	m -= m - 2 - y
	if m - 1 <= b and m - 2 <= y:
		print(m + m - 1 + m - 2)


(y, b, r) = map(int, input().split())
maxx = 0
cur = 0
for i in range(1, 101):
	if y >= i and b >= i + 1 and (r >= i + 2):
		cur = 3 * i + 3
		if cur > maxx:
			maxx = cur
print(maxx)


flag = 0
(y, b, r) = map(int, input().split())
for ir in range(r, 2, -1):
	for ib in range(b, 1, -1):
		for iy in range(y, 0, -1):
			if ir == ib + 1 and ib == iy + 1:
				print(ir + ib + iy)
				flag = 1
				break
		if flag == 1:
			break
	if flag == 1:
		break


(y, b, r) = map(int, input().split())
ans = 6
for i in range(2, y + 1):
	x = i + 1
	z = x + 1
	if x > b or z > r:
		break
	ans = max(ans, i + x + z)
print(ans)


(a, b, c) = map(int, input().split())
a = min(a, b - 1, c - 2)
b = min(b, a + 1, c - 1)
c = min(c, a + 2, b + 1)
print(a + b + c)


__author__ = 'Dilshod'
(y, b, r) = map(int, input().split())
for i in range(y, 0, -1):
	if i + 1 <= b and i + 2 <= r:
		print(i * 3 + 3)
		break


(y, b, r) = map(int, input().split())
if b > r or b == r:
	b = r - 1
if y > b or y == b:
	y = b - 1
if b > y + 1:
	b = y + 1
if r > b + 1:
	r = b + 1
total = y + b + r
print(total)


(yellow, blue, red) = map(int, input().split())
flag = True
while flag == True:
	if blue >= yellow + 1 and red >= yellow + 2:
		print(yellow + yellow + 1 + yellow + 2)
		break
	else:
		yellow = yellow - 1


def mi():
	return list(map(int, input().split()))
(y, b, r) = mi()
if b >= r:
	b = r - 1
else:
	r = b + 1
if y >= b:
	y = b - 1
else:
	b = y + 1
	r = b + 1
print(y + r + b)


s = input().split()
(y, b, r) = (int(s[0]), int(s[1]), int(s[2]))
x = min(y + 2, b + 1, r)
if x == r:
	print(r * 3 - 3)
elif x == b + 1:
	print(b * 3)
elif x == y + 2:
	print(y * 3 + 3)


(y, b, r) = list(map(int, input().strip().split()))
if min(y, b, r) == y:
	for j in range(y, 0, -1):
		if b >= j + 1 and r >= j + 2:
			print(j * 3 + 3)
			break
elif min(y, b, r) == b:
	for j in range(b, 0, -1):
		if y >= j - 1 and r >= j + 1:
			print(j * 3)
			break
elif min(y, b, r) == r:
	for j in range(r, 0, -1):
		if y >= j - 2 and b >= j - 1:
			print(j * 3 - 3)
			break


import time
start_time = time.time()
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
from collections import defaultdict
import math
from fractions import Fraction as frac
from random import random
cin = stdin.readline

def cout(x):
	stdout.write(str(x) + '\n')

def var(type=int):
	return type(stdin.readline())

def readline(type=int):
	return map(type, stdin.readline().split())

def readlist(type=int):
	return list(map(type, stdin.readline().split()))

def sorted_indexes(arr):
	return sorted(range(len(arr)), key=arr.__getitem__)

def printr(arr):
	[stdout.write(str(x) + ' ') for x in arr]
	cout('')

def find_lt(a, x):
	i = bisect_left(a, x)
	if i:
		return a[i - 1]
	raise ValueError

def find_gt(a, x):
	i = bisect_right(a, x)
	if i != len(a):
		return a[i]
	raise ValueError

def primes(n):
	pmx = []
	f = 1
	for k in range(2, n):
		f = f * (k - 1)
		if (f + 1) % k == 0:
			pmx.append(k)
	return pmx

def binary_search(arr, x):
	i = bisect_left(arr, x)
	if i == len(arr) or arr[i] != x:
		return -1
	return i
MOD1 = 1000000007
MOD2 = 998244353
(y, b, r) = readline(int)
ans = 0
for k in range(y + 1):
	if k > y or k + 1 > b or k + 2 > r:
		break
	else:
		ans = k
print(3 * ans + 3)


import sys
inf = float('inf')
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline()

def int1():
	return int(input())
import string
import math
from itertools import combinations

def main():
	a = get_array()
	b = a[0]
	y = a[1]
	r = a[2]
	z = 0
	while z == 0:
		if b + 1 <= y and b + 2 <= r:
			x = b + 1
			x1 = b + 2
			z = 1
			break
		else:
			b = b - 1
	print(b + x + x1)
main()


(o1, o2, o3) = map(int, input().split())
(a, b, c) = (1, 2, 3)
while a <= o1 and b <= o2 and (c <= o3):
	(a, b, c) = (a + 1, b + 1, c + 1)
print(a + b + c - 3)


(y, b, r) = input().split()
y = int(y)
b = int(b)
r = int(r)
ans = min(y, b - 1, r - 2)
print(ans + ans + 1 + ans + 2)


(y, b, r) = list(map(int, input().split()))
s = 0
for i in range(1, 100):
	if i <= y and i + 1 <= b and (i + 2 <= r):
		s = 3 * i + 3
print(s)


a = list(map(int, input().split()))
b = a[0]
c = a[1]
d = a[2]
sjmallest = 0
if a[0] > a[1]:
	if a[1] > a[2]:
		smallest = a[2]
	else:
		smallest = a[1]
elif a[0] > a[2]:
	smallest = a[2]
else:
	smallest = a[0]
if b == smallest:
	for h in range(b):
		if c >= b + 1 and d >= b + 2:
			a[1] = b + 1
			a[2] = b + 2
			print(a[0] + a[1] + a[2])
			break
		b = b - 1
		a[0] = a[0] - 1
elif c == smallest:
	for h in range(c):
		if b >= c - 1 and d >= c + 1:
			a[0] = c - 1
			a[2] = c + 1
			print(a[0] + a[1] + a[2])
			break
		c = c - 1
		a[1] = a[1] - 1
else:
	for h in range(d):
		if b >= d - 2 and c >= d - 1:
			a[0] = d - 2
			a[1] = d - 1
			print(a[0] + a[1] + a[2])
			break
		d = d - 1
		a[2] = a[2] - 1


x = input().split()
for i in range(3):
	x[i] = int(x[i])
	x[i] += 2 - i
print(min(x) * 3 - 3)


(a, b, c) = list(map(int, input().split()))
print(min(3 * a + 3, 3 * b, 3 * c - 3))


(y, b, r) = map(int, input().split())
while r - 1 != b:
	if b > r - 1:
		b -= 1
	else:
		r -= 1
while b - 1 != y:
	if y > b - 1:
		y -= 1
	else:
		b -= 1
		r -= 1
print(y + b + r)


(y, b, r) = map(int, input().split())
s = 0
i = 1
while i <= y and i + 1 <= b and (i + 2 <= r):
	s = 3 * i + 3
	i += 1
print(s)


def input_ints():
	return list(map(int, input().split()))

def main():
	(y, b, r) = input_ints()
	print(3 * min([y + 1, b, r - 1]))
main()


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	a = LI()
	a[0] += 1
	a[2] -= 1
	t = min(a)
	return t * 3
print(main())


n = list(map(int, input().split()))
y = n[0]
b = n[1]
r = n[2]
for i in range(y, 0, -1):
	if i + 1 <= b and i + 2 <= r:
		print(i + (i + 1) + (i + 2))
		break
	else:
		continue


(y, b, r) = map(int, input().split())
Y = 0
B = Y + 1
R = B + 1
i = 0
while Y != y and B != b and (R != r):
	Y = Y + 1
	B = B + 1
	R = R + 1
s = Y + B + R
print(s)


(y, b, r) = [int(x) for x in input().split()]
start = y
while start >= 1:
	if start + 1 <= b and start + 2 <= r:
		break
	start -= 1
print(start + start + 1 + start + 2)


S = input().split(' ')
y = 0
b = 1
r = 2
for i in range(3):
	S[i] = int(S[i])
while y < S[0] and b < S[1] and (r < S[2]):
	y += 1
	b += 1
	r += 1
print(y + b + r)


(y, b, r) = map(int, input().split())

def func(y, b, r):
	while y > 0:
		if b >= y + 1 and r >= y + 2:
			return 3 * (y + 1)
		else:
			y -= 1
print(func(y, b, r))


(y, b, r) = map(int, input().split())
if min(y, b, r) == r:
	x = 3 * (r - 1)
elif min(y, b, r) == b:
	x = 3 * b
elif min(y, b, r) == y:
	if y + 1 == r:
		y -= 1
		x = 3 * (y + 1)
	else:
		x = 3 * (y + 1)
print(x)


def r(a, b):
	ans = a // b
	if a % b != 0:
		ans += 1
	return ans
(y, b, r) = map(int, input().split())
ans = min(y, b - 1, r - 2)
print(3 * ans + 3)


(y, b, r) = map(int, input().split())
m = min(y, b, r)
if m == y:
	if r - y >= 2 and b - y >= 1:
		print(y + (y + 1) + (y + 2))
	elif r - y >= 1:
		print(y - 1 + y + (y + 1))
	else:
		print(y - 2 + (y - 1) + y)
elif m == b:
	if r - b == 0:
		print(b - 1 + (b - 2) + b)
	else:
		print(b + (b + 1) + (b - 1))
else:
	print(r + (r - 1) + (r - 2))


(a, b, c) = [int(x) for x in input().split()]
aa = a * 3 + 3
bb = b * 3
cc = c * 3 - 3
print(min(aa, min(bb, cc)))


l = list(map(int, input().split()))

def count_ornament(y, b, r):
	if y >= r - 2 and b >= r - 1:
		return 3 * (r - 1)
	else:
		return count_ornament(y, b, r - 1)
print(count_ornament(l[0], l[1], l[2]))


a = [int(x) for x in input().split()]
f = a[0] + 1 + a[0] + 2 + a[0]
g = a[1] - 1 + a[1] + 1 + a[1]
h = a[2] - 1 + a[2] - 2 + a[2]
v = min(f, g, h)
print(v)


(a, b, c) = map(int, input().split())
ans = [min(a, b - 1, c - 2), min(a + 1, b, c - 1), min(a + 2, b + 1, c)]
print(ans[0] + ans[1] + ans[2])


input_string = input()
(y, b, r) = input_string.split()
y = int(y)
b = int(b)
r = int(r)
list_a = [y, b - 1, r - 2]

def n_min():
	for i in range(len(list_a)):
		a = list_a[i]
		b = min(list_a)
		if list_a[i] == min(list_a):
			return i

def fin(n):
	if n == 0:
		a = y + (y + 1) + (y + 2)
		print(a)
	elif n == 1:
		a = b - 1 + b + (b + 1)
		print(a)
	elif n == 2:
		a = r - 2 + (r - 1) + r
		print(a)
fin(n_min())


(y, b, r) = map(int, input().split())
mini = min(y, b, r)
ans = (0, 0, 0)
if y == mini:
	while y + 1 > b or y + 2 > r:
		y -= 1
	ans = (y, y + 1, y + 2)
elif b == mini:
	while b + 1 > r:
		b -= 1
	ans = (b - 1, b, b + 1)
else:
	ans = (r - 2, r - 1, r)
print(sum(ans))


(x, y, z) = [int(_) for _ in input().split()]
while x + 1 != y or y + 1 != z:
	if x < y - 1:
		y = x + 1
	elif x > y - 1:
		x = y - 1
	if y < z - 1:
		z = y + 1
	elif y > z - 1:
		y = z - 1
print(x + y + z)


print(min([int(x) - i for (i, x) in enumerate(input().split())]) * 3 + 3)


(y, b, r) = map(int, input().split())
y = y + 2
b = b + 1
r = r + 0
min = min(y, b, r)
sum = min * 3 - 3
print(sum)


(n, m, k) = map(int, input().split())
print(min(n, m - 1, k - 2) * 3 + 3)


[a, b, c] = [int(x) for x in input().split()]
ornaments = min(a - 1, b - 2, c - 3) * 3 + 6
print(ornaments)


num = input()
a = []

def get_the_data(count, num, arr):
	for i in range(0, len(num)):
		if num[i] == ' ':
			arr.append(int(num[count:i]))
			count = i + 1
		elif i == len(num) - 1:
			arr.append(int(num[count:len(num)]))
	return arr
arr = get_the_data(0, num, a)
result = False
while result is False:
	if arr[0] + 1 <= arr[1] and arr[0] + 2 <= arr[2]:
		print(arr[0] + arr[0] + arr[0] + 3)
		break
	else:
		arr[0] -= 1


(y, b, r) = map(int, input().rstrip().split())
modified = [y + 2, b + 1, r]
modified.sort()
total = 3 * modified[0] - 3
print(total)


l = [int(e) for e in input().split()]
lst = []
for e in range(1, l[0] + 1):
	if e + 1 <= l[1] and e + 2 <= l[2]:
		lst.append((e, e + 1, e + 2))
print(sum(lst[-1]))


R = lambda : map(int, input().split())
(y, b, r) = R()
print(3 * min(y + 1, b, r - 1))


def new_years(y, b, r):
	if r < b + 1:
		b = r - 1
	if b < y + 1:
		y = b - 1
	return 3 * y + 3
x = list(map(int, input().rstrip().split()))
print(new_years(x[0], x[1], x[2]))


entrada = input()
entrada = [int(x) for x in entrada.split()]
(y, b, r) = (entrada[0], entrada[1], entrada[2])
y = y + 2
b = b + 1
delta = min(y, b, r)
print(3 * delta - 3)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
(a, b, c) = get_int_list()
if b >= c:
	b = c - 1
else:
	c = b + 1
if a >= b:
	a = b - 1
else:
	b = a + 1
	if c > b + 1:
		c = b + 1
print(a + b + c)


(y, b, r) = list(map(int, input().split()))
s = 0
while s != 1:
	if r - 1 <= b and r - 2 <= y:
		s = 1
	else:
		r -= 1
print(r - 2 + r - 1 + r)


nn = input()
nn = nn.split()
y = int(nn[0])
b = int(nn[1])
r = int(nn[2])
m = None
for i in range(1, y + 1):
	for j in range(1, b + 1):
		for k in range(1, r + 1):
			if k == j + 1 and j == i + 1:
				if m == None or m < i + j + k:
					m = i + j + k
print(m)


(a, b, c) = map(int, input().split())
r = 0
g = 0
x = 0
m = 0
for i in range(1, a + 1):
	if i <= a and i + 1 <= b and (i + 2 <= c):
		r = i
		g = i + 1
		x = i + 2
		if r + g + x > m:
			m = r + g + x
print(r + g + x)


read = lambda : map(int, input().split())
(x, y, z) = read()
m = min(x, y - 1, z - 2)
print(3 * m + 3)


(y, b, r) = list(map(int, input().split()))
if b >= r:
	b = r - 1
if y >= b:
	y = b - 1
while True:
	while r != b + 1:
		r -= 1
	while b != y + 1:
		b -= 1
	if r == b + 1 and b == y + 1:
		break
print(r + b + y)


(y, b, r) = [int(i) for i in input().split()]
if b + 1 > r:
	b = r - 1
elif b + 1 < r:
	r = b + 1
if y + 1 > b:
	y = b - 1
elif y + 1 < b:
	b = y + 1
if r > b + 1:
	r = b + 1
elif r < b + 1:
	b = r - 1
print(y + b + r)


(y, b, r) = map(int, input().split(' '))
(Y, B, R) = (1, 2, 3)
while Y < y and B < b and (R < r):
	Y += 1
	B += 1
	R += 1
print(Y + B + R)


(y, b, r) = [int(i) for i in input().split()]
minimum = min(y, b, r)
ay = 0
ab = 0
ar = 0
if minimum == y:
	ay = y
elif minimum == b:
	ab = b
else:
	ar = r
if ay:
	while 1:
		if b >= ay + 1 and r >= ay + 2:
			print(ay + ay + 1 + ay + 2)
			break
		else:
			ay -= 1
elif ab:
	while 1:
		if y >= ab - 1 and r >= ab + 1:
			print(ab - 1 + ab + ab + 1)
			break
		else:
			ab -= 1
else:
	while 1:
		if y >= ar - 2 and b >= ar - 1:
			print(ar + ar - 1 + ar - 2)
			break
		else:
			ar -= 1


def main():
	(a, b, c) = map(int, input().split())
	ans = 0
	if b >= a + 1 and c >= a + 2:
		ans = max(ans, a * 3 + 3)
	if a >= b - 1 and c >= b + 1:
		ans = max(ans, b * 3)
	if a >= c - 2 and b >= c - 1:
		ans = max(ans, c * 3 - 3)
	print(ans)
main()


(y, b, r) = list(map(int, input().strip().split()))
mini = min(y, b, r)
if mini == r:
	print(3 * r - 3)
elif mini == b:
	print(3 * b)
elif r - y > 1:
	print(3 * y + 3)
else:
	print(3 * y)


__author__ = 'Sudip'
a = list(map(int, input().split()))
b = [0] * 3
b[0] = a[0]
b[1] = a[1] - 1
b[2] = a[2] - 2
p = b.index(min(b))
print(a[p] * 3 + 3 - 3 * p)


(y, b, r) = list(map(int, input().split()))
for i in range(1, r + 1):
	(ys, bs, rs) = (i, i + 1, i + 2)
	if ys > y or bs > b or rs > r:
		break
	sol = ys + bs + rs
print(sol)