Problem:
 Score : 100 points    Problem Statement Three poles stand evenly spaced along a line. Their heights are a , b and c meters, from left to right.
We will call the arrangement of the poles beautiful if the tops of the poles lie on the same line, that is, b-a = c-b .  Determine whether the arrangement of the poles is beautiful.      Constraints  1 \leq a,b,c \leq 100  a , b and c are integers.         Input Input is given from Standard Input in the following format:  a  b  c       Output Print YES if the arrangement of the poles is beautiful; print NO otherwise.        Sample Input 1 2 4 6      Sample Output 1 YES  Since 4-2 = 6-4 , this arrangement of poles is beautiful.       Sample Input 2 2 5 6      Sample Output 2 NO  Since 5-2 \neq 6-5 , this arrangement of poles is not beautiful.       Sample Input 3 3 2 1      Sample Output 3 YES  Since 1-2 = 2-3 , this arrangement of poles is beautiful.

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

d1 = b - a
d2 = c - b

if (d1 == d2):
    print("YES")

else:
    print("NO")

Solution (Python):


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

if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
def actual(a, b, c):
    if (b - a) == (c - b):
        return 'YES'

    return 'NO'

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

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

if b-a == c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
def main():
    A, B, C = map(int, input().split())
    if B - A == C - B:
        print('YES')
    else:
        print('NO')
main()

Solution (Python):
import sys
a,b,c = map(int,input().split())
if a < 0 or b < 0 or c < 0 or a > 100 or b > 100 or c > 100:
    sys.exit()

diff_a_b = b - a
diff_b_c = c - b

if diff_a_b == diff_b_c:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c = map(int,list(input().split()))
if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b - a  == c - b:
    print('YES')
else:
    print('NO')

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

if (b - a) == (c - b):
    print('YES')
else:
    print('NO')

Solution (Python):
import sys

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

if b - a == c - b:
    print('YES')
    sys.exit()

print('NO')

Solution (Python):
a,b,c = map(int,input().split())
if b-a==c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c=map(int,input().split());print(['NO','YES'][b-a==c-b])

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if b - a == c - b else 'NO')

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if b-a==c-b else 'NO')

Solution (Python):
a,b,c = [int(i) for i in input().split()]

if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
a , b , c = map(int,input().split())
if b - a == c - b:
  print("YES")
else: 
  print("NO")

Solution (Python):
a,b,c = [int(i) for i in input().split()]
if b - a == c - b:
  print("YES")
else:
  print("NO")

Solution (Python):
a, b, c = map(int, input().split())
 
if b - a == c - b:
  print('YES')
else:
  print('NO')

Solution (Python):
a,b,c=map(int,input().split());print("YES") if b-a==c-b else print("NO")

Solution (Python):
a,b,c=map(int,input().split())
print("YES") if b-a==c-b else print("NO")

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

if b-a == c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
def main(a, b, c):
    A = int(a) - int(b)
    B = int(b) - int(c)
    if A == B:
        print("YES")
    else:
        print("NO")

[a, b, c] = input().split()
main(a, b, c)

Solution (Python):

from collections import Counter

a,b,c = map(int,input().split())
if(b-a ==  c-b):
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c=map(int,input().split())
if b-a==c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c=map(int,input().split())
if b-a==c-b:
  print('YES')
else:
  print('NO')

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if b - a == c - b else 'NO')

Solution (Python):
a=input()

b=a.split(' ')

c=[]

for i in range(3):
  c.append(int(b[i]))

if c[1]-c[0]==c[2]-c[1]:
  print('YES')
else:
  print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b :
  print("YES")
else :
  print("NO")

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if a-b == b-c else 'NO')

Solution (Python):
a, b, c = map(int, input().split()) 
if (b - a) == (c - b):
  print('YES')
else:
  print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c=map(int,input().split());print('YNEOS'[b-a!=c-b::2])

Solution (Python):
a,b,c = map(int,input().split())
if b * 2 == a + c: print('YES')
else: print('NO')

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

k = b - a
l = c - b

if k == l:
  print('YES')
else:
  print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if (b - a) == (c - b):
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c = map(int,input().split())
if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c = map(int, input().split())
print('YES' if b-a==c-b else 'NO')

Solution (Python):
a, b, c = map(int, input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

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

A = [a,b,c]
A.sort()
if A[2] - A[1] == A[1] - A[0]:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c = map(int, input().split())
print('YES' if b-a==c-b else 'NO')

Solution (Python):
a,b,c = map(int,input().split())
ba = b-a
cb = c-b
if ba == cb:
    print("YES")
else:
    print("NO")

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

if (b-a)==(c-b):
  print('YES')
else:
  print('NO')

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if b-a == c-b else 'NO')

Solution (Python):
a, b, c = list(map(int, input().split()))
if b-a == c-b:
  print("YES")
else:
  print("NO")

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

if b-a==c-b:
  print("YES")
else:
  print("NO")

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

if (b-a) == (c-b):
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c=map(int,input().split())
if b-a==c-b:
    print('YES')
else:
    print('NO')

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

if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c = map(int,input().split())
if b-a == c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a, b, c = list(map(int, input().split()))

if b - a == c - b:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c = map(int, input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c=map(int,input().split())
if((b-a)==(c-b)):
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c = list(map(int,input().strip().split()))
if b-a == c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a, b, c = map(int, input().split())
print('YES') if b-a == c-b else print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c=map(int,input().split())
if b-a==c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c=map(int,input().split())
if (b-a)==(c-b):
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
left = b - a
right = c - b
if left == right:
    print('YES')
else:
    print('NO')

Solution (Python):
def resolve():
    a, b, c = map(int, input().split())
    print("YES" if b-a == c-b else "NO")
resolve()

Solution (Python):
a, b, c = list(map(int, input().split()))
if b - a == c - b:
    print("YES")
else:
    print("NO")

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
  print('YES')
else:
  print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if 1 <= a <= 100 and 1 <= b <= 100 and 1 <= c <= 100:
  if b - a == c - b:
    print('YES')
  elif a - b == b - c:
    print('YES')
  else:
    print('NO')

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

if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b-a == c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c=map(int, input().split())
print("YES" if b-a == c-b else "NO")

Solution (Python):
a,b,c=map(int,input().split())
print("YES" if b-a==c-b else "NO")

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


if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c=map(int,input().split())
if b-a==c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c=map(int,input().split())
if (b-a)==(c-b):
  print('YES')
else:
  print('NO')

Solution (Python):
a,b,c=map(int,input().split())
if b-a==c-b:
  print('YES')
else:
  print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b-a == c-b:
  print('YES')
else:
  print('NO')

Solution (Python):


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

if b-a == c-b:
  print('YES')
else:
  print("NO")

Solution (Python):
def resolve():
    a, b, c = map(int, input().split())

    ans = str()
    if b-a == c-b:
        ans = "YES"
    else:
        ans = "NO"
    
    print(ans)
resolve()

Solution (Python):


import sys






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b, c  = mi()
    print('YES') if b - a == c - b else print('NO')


if __name__ == "__main__":
    main()

Solution (Python):

a,b,c,=map(int,input().split())
if (b-a)==(c-b):print('YES')
else:print('NO')

Solution (Python):
def main():
    a, b, c = map(int, input().split())
    cond = b * 2 == a + c
    print('YES' if cond else 'NO')


if __name__ == '__main__':
    main()

Solution (Python):
a,b,c=map(int,input().split())
x=b-a
y=c-b
if x==y:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c =map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

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

print('YES') if b - a == c - b else print('NO')

Solution (Python):
a, b, c = map(int, input().split())
print("YES" if b - a == c - b else "NO")

Solution (Python):
n = input().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])
if b - a == c - b:
  print('YES')
else:
  print('NO')

Solution (Python):

import sys

import fractions
import copy
import bisect
import math
import numpy as np
import itertools
from itertools import combinations_with_replacement


from operator import itemgetter
from sys import stdin

from operator import mul
from functools import reduce
from collections import Counter





j=0
k=0
n=3
r=1
a=[0]






"1行1つの整数を入力を取得し、整数と取得する"




"12 21 332 とか入力する時に使う"
"1行に複数の整数の入力を取得し、整数として扱う"

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

for i in number_list:
    print(number_list[i-1])

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

'''
x=[]
y=[]
for i in range(N):
    x1, y1=[int(i) for i in input().split()]
    x.append(x1)
    y.append(y1)
print(x)
print(y)
"複数行に2数値を入力する形式 x座標とy座標を入力するイメージ"
'''

'''
mixlist=[]
for i in range(N):
    a,b=input().split()
    mixlist.append((int(a),b))
print(mixlist)
"複数行にintとstrを複合して入力するやつ，今回はリスト一つで処理している"
'''

'''



"正方行列にstr型の値を入力"
'''




'''
入力
1 2
4 5
7 8
出力結果
[[1, 2], [4, 5], [7, 8]]
'''
"列数に関して自由度の高いint型の値を入力するタイプの行列"


'''
table = [[int(i) for i in input().split()] for m in range(m)]

print(type(N))
print(N)
print(type(M))
print(M)

print(type(table))
print(table)
'''











'''
入力
1234
出力
1
[[1, 2, 3, 4]]
'''




'''
word_list= input().split(" ")
print(word_list[0])
"連続文字列の入力"
"qw er ty とかの入力に使う"
"入力すると空白で区切ったところでlistの番号が与えられる"
'''



'''
A, B, C=stdin.readline().rstrip().split()
print(A)
"リストではなく独立したstr型を入れるなら以下のやり方でOK"
'''




"aという変数に入っているものを大文字にして出力"

















'''
コンビネーションの組み合わせの中身を出力する形式
for i in itertools.combinations(brray, 2)
combinationsをpermutationsにすれば順列になる
今回なら(abc133B)
入力
1 2
5 5
-2 8
出力
[[1, 2], [5, 5], [-2, 8]]
もちろん一次元リストでも使えるし
何よりiもリストのように使えるので便利
'''


'''
def cmb(n,r):
    
    r= min(n-r,r)
    
    if r == 0: return 1
    over = reduce(mul, range(n, n-r, -1))
    
    
    

    under = reduce(mul, range(1, r+1))
    
    
    
    

    return over // under
    
    
    
    
a = cmb(n, r)

'''

'''
import itertools
from itertools import combinations_with_replacement

combinationについて
以下の違いを意識しよう
combinations() p, r 長さrのタプル列、ソートされた順で重複なし

combinations_with_replacement() p, r 長さrのタプル列、ソートされた順で重複あり


使用例 　　　　　　　　　　　                  出力　　
combinations('ABCD', 2)　　　　　　　　　　　　AB AC AD BC BD CD

combinations_with_replacement('ABCD', 2)　　 AA AB AC AD BB BC BD CC CD DD
'''



'''




for i in a.most_common(n):print(i)





 


'''









'''
bisect.bisect_left(a, x, lo=0, h=len(a))
引数
a: ソート済みリスト
x: 挿入したい値
lo: 探索範囲の下限
hi: 探索範囲の上限
(lo, hiはスライスと同様の指定方法)
bisect_leftはソートされたリストaに対して順序を保ったままxを挿入できる箇所を探索します。leftが示す通り、aにすでにxが存在している場合は、挿入箇所は既存のxよりも左側になります。また、lo, hiを指定することで探索範囲を絞り込むことも可能です。デフォルトはaの全体が探索対象です。
'''

'''
素数の判定
'''


def is_prime(n):
    if n == 1: return False

    for k in range(2, int(np.sqrt(n)) + 1):
        
        if n % k == 0:
            return False
            
    return True


'''
npのmaxとmaximumの違い
xs = np.array([1, -2, 3])
np.max(xs, 0)
この出力は3となります．[1, -2, 3]と0の4つの数字のうち，最も大きい値を出力します．

一方で，[max(1, 0), max(-2, 0), max(3, 0)]を出力したい時があります．
その時は，numpyのmaximum関数を用います．

xs = np.array([1, -2, 3])
np.maximum(xs, 0)  

'''

def factorial(x, mod=10**9+7):
    
    
    
    tmp = 1
    for i in range(1, x+1):
        tmp = (tmp * i) % mod
    return tmp
    '''
    Basically, when you do a**d % n, you actually have to calculate a**d, which could be quite large.
    But there are ways of computing a**d % n without having to compute a**d itself, and that is what pow does.
    '''











'''
ascii_letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
digits = '0123456789'
hexdigits = '0123456789abcdefABCDEF'
letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv...\xaf\xb0...
lowercase = 'abcdefghijklmnopqrstuvwxyz'
octdigits = '01234567'
printable = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTU...
punctuation = '!"
uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
whitespace = '\t\n\x0b\x0c\r '
'''
'''
引数endに任意の文字列を指定すると、その文字列が改行の代わりに最後に挿入される。例えば連続するprint()の出力を改行なしで単純に連結したい場合は空文字列''を指定すればよい。

print('abc', end='---')
print('xyz')


print('abc', end='')
print('xyz')

source: print_basic.py
なお、デフォルトで改行されるのは引数endのデフォルト値が改行文字'\n'に設定されているから。
'''

def main():
    n=3
    steps=0
    state=0
    w=1
    j=0
    k=0
    
    
    
    a,b,c=map(int, input().split(" "))
    if 2*b==a+c:
        print("YES")
    else:
        print("NO")
    
    
    
    
    
    
    


    for i in range(1,n+1,2):
     pass
     

    l = ['aaa', 'bbb', 'ccc']
    x=l.index('aaa')
    
    
    
    

    
        
    
    

    
    
    
    
    DP = np.zeros(w+1, dtype=int)
    exdp=np.zeros((3,4)) 
    
    
    
        
        
    
    
        
        
    


    
    



    '''
    入力
    1234
    出力
    [1, 2, 3, 4]
    '''
    pin_l=["x" for i in range(10)]
    

    ls = ["a", "b", "c", "d", "e"]


    
    

    
    

    
    
    
    
    
    '''
    lsというリストの場合に、1つ飛びの値を取得したい場合には
    ls[::2]
    のようにします。こうすると、
    ["a", "c", "d"]と出力される
    '''

if __name__ == "__main__":
    main()

Solution (Python):
a,b,c = map(int,input().split());print("YES" if b-a==c-b else "NO")

Solution (Python):
a, b, c = map(int, input().split())
print("YES" if b - a == c - b else "NO")

Solution (Python):
a,b,c=map(int,input().split())
if (b-a)==(c-b):
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c=map(int,input().split())
if (b-a)==(c-b):
    print('YES')
else:
    print('NO')

Solution (Python):

import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**6)
INF = float('inf')
MOD = 10 ** 9 + 7
def rs(): return sys.stdin.readline().rstrip()
def ri(): return int(rs())
def rf(): return float(rs())
def rs_(): return [_ for _ in rs().split()]
def ri_(): return [int(_) for _ in rs().split()]
def rf_(): return [float(_) for _ in rs().split()]
def divisors(n, sortedresult=True):
    div = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            div.append(i)
            if i != n // i:
                div.append(n//i)
    if sortedresult:
        div.sort()
    return div

a, b, c = ri_()
print('YES' if b - a == c - b else 'NO')

Solution (Python):
a,b,c=map(int,input().split())
if b-a==c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c = map(int, input().split())
if a + c == 2*b:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b, c = map(int, readline().split())
print('YES' if b - a == c - b else 'NO')

Solution (Python):
a,b,c = map(int,input().split())
if b - a == c - b:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c=map(int,input().split())
print('YNEOS'[b-a!=c-b::2])

Solution (Python):
a,b,c=map(int,input().split())
print('YNEOS'[c-b!=b-a::2])

Solution (Python):
def main():
    a,b,c = map(int, input().split())
    if b - a == c - b:
        print('YES')
    else:
        print('NO')
main()

Solution (Python):
a, b, c = map(int, input().split())
if c-b == b-a:
  print("YES")
else:
  print("NO")

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
x, y, z = map(int, input().split())
if y - x == z - y:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c = map(int,input().split())
print("YES" if b-a == c-b else "NO")

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if b - a == c - b else 'NO')

Solution (Python):
a, b, c = map(int, input().split())
if b-a == c-b:
  print('YES')
else:
  print('NO')

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

if b - a == c - b:
    print('YES')
else:
    print('NO')

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

if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7

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

if (b - a == c - b):
    print ('YES')
else:
    print ('NO')

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

if b - a == c - b:
  print("YES")
else:
  print("NO")

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

a,b,c = inpl()
print('YES' if b-a == c-b else 'NO')

Solution (Python):
a,b,c = map(int,input().split())
if b-a==c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from fractions import gcd
from math import factorial, sqrt, ceil
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

def is_prime(n):
    if n == 1:
        return False
    for i in range(2,int(n**0.5)+1):
        if n % i == 0:
            return False
    return True




def warshall_floyd(d, n):
    
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k] + d[k][j])
    return d



def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)






def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



a, b, c = map(int, input().split())
if b - a == c - b:
    print("YES")
else:
    print("NO")

Solution (Python):
a, b, c = map(int, input().split())
if b-a==c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
def resolve():
  a, b, c = map(int, input().split())
  if b - a == c - b:
    print('YES')
  else:
    print('NO')
  return

if __name__ == "__main__":
  resolve()

Solution (Python):
a, b, c = map(int, input().split())
print("YES" if b - a == c - b else "NO")

Solution (Python):
import math
import string
import collections
from collections import Counter


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
a, b, c = map(int, input().split())
if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


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

    if b - a == c - b:
        print("YES")
    else:
        print("NO")


if __name__ == '__main__':
    resolve()

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

if b-a == c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
    print("YES")
else:
    print("NO")

Solution (Python):
import sys
from collections import Counter
from collections import deque
import math
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

a,b,c=mp()
if b-a==c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c = map(int,input().split())
print('YES' if b-a == c-b else 'NO')

Solution (Python):
a,b,c = map(int, input().split())
print("YES" if b-a == c-b else "NO")

Solution (Python):
def main():
    a, b, c = map(int, input().split())
    print("YES" if b - a == c - b else "NO")


if __name__ == '__main__':
    main()

Solution (Python):
a, b, c = list(map(int, input().split()))
if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c = map(int,input().split())
if 2*b == a + c:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c = map(int,input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

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

print("YES" if b-a == c-b else "NO")

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if b - a == c - b else 'NO')

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

def main():
    a,b,c=map(int,input().split())
    YESNO(b-a==c-b)

if __name__ == '__main__':
    main()

Solution (Python):
a, b, c = map(int, input().split())
print("YES" if b-a==c-b else "NO")

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

if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
def main():
  num = list(map(int,input().split()))
  if num[1]*2==num[0]+num[2]:
    print('YES')
  else:
      print('NO')
main()

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

if (b-a) == (c-b):
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
  print('YES')
else:
  print('NO')

Solution (Python):
a,b,c=map(int,input().split())
print("YES" if b-a==c-b else "NO")

Solution (Python):
a,b,c = map(int, input().split())
if b-a == c-b:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c=map(int,input().split())
if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
print('YES' if b-a == c-b else 'NO')

Solution (Python):
a, b, c = map(int, input().split())
print("YES") if (b - a) == (c - b) else print("NO")

Solution (Python):
a,b,c = map(int,input().split())
if b-a == c-b:
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b - a  == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):
a,b,c=map(int,input().split())
if b-a == c-b:
  print('YES')
else:print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if (b-a) == (c-b):
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
    print("YES")
else:
    print("NO")

Solution (Python):
a, b, c = map(int, input().split())
if b-a == c-b:
    print('YES')
else:
    print('NO')

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

if b-a == c-b:
  print("YES")
else:
  print("NO")

Solution (Python):
a,b,c=map(int,input().split())
if ((b-a)==(c-b)):
    print ("YES")
else:
    print("NO")

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

if b - a == c - b:
    print("YES")
else:
    print("NO")

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

if b - a == c - b:
    print("YES")
else:
    print("NO")

Solution (Python):
a,b,c =map(int, input().split())
if b*2 == a+c :
    print("YES")
else:
    print("NO")

Solution (Python):
def main():
    a, b, c = map(int, input().split())
    if b - a == c - b:
        ans = 'YES'
    else:
        ans = 'NO'
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
a, b, c = map(int, input().split())
if (b-a) == (c-b):
    print('YES')
else:
    print('NO')

Solution (Python):
a, b, c = map(int, input().split())
if b - a == c - b:
    print('YES')
else:
    print('NO')

Solution (Python):






import sys
input = sys.stdin.readline

import math
from collections import deque
from fractions import gcd
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


def lcm(a, b):
    return a * b // gcd (a, b)





a,b,c = inputIL()

if b-a == c-b:
  print("YES")
else:
  print("NO")