output_description: Print the integer Takahashi will get minus the integer Nakahashi will get,
  after repeating the following operation K times. If the absolute value of the
  answer exceeds 10^{18}, print `Unfair` instead.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      A B C K
attempt: import sys
  
  
  ## io ##
  def IS():
      return sys.stdin.readline().rstrip()
  
  
  def II():
      return int(IS())
  
  
  def MII():
      return list(map(int, IS().split()))
  
  
  def MIIZ():
      return list(map(lambda x: x - 1, MII()))
  
  
  ## dp ##
  def DD2(d1, d2, init=0):
      return [[init] * d2 for _ in range(d1)]
  
  
  def DD3(d1, d2, d3, init=0):
      return [DD2(d2, d3, init) for _ in range(d1)]
  
  
  ## math ##
  def to_bin(x: int) -> str:
      return format(x, "b")  # rev => int(res, 2)
  
  
  def to_oct(x: int) -> str:
      return format(x, "o")  # rev => int(res, 8)
  
  
  def to_hex(x: int) -> str:
      return format(x, "x")  # rev => int(res, 16)
  
  
  MOD = 10**9 + 7
  
  
  def divc(x, y) -> int:
      return -(-x // y)
  
  
  def divf(x, y) -> int:
      return x // y
  
  
  def gcd(x, y):
      while y:
          x, y = y, x % y
      return x
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def enumerate_divs(n):
      """Return a tuple list of divisor of n"""
      return [(i, n // i) for i in range(1, int(n**0.5) + 1) if n % i == 0]
  
  
  def get_primes(MAX_NUM=10**3):
      """Return a list of prime numbers n or less"""
      is_prime = [True] * (MAX_NUM + 1)
      is_prime[0] = is_prime[1] = False
      for i in range(2, int(MAX_NUM**0.5) + 1):
          if not is_prime[i]:
              continue
          for j in range(i * 2, MAX_NUM + 1, i):
              is_prime[j] = False
      return [i for i in range(MAX_NUM + 1) if is_prime[i]]
  
  
  ## libs ##
  from itertools import accumulate as acc
  from collections import deque, Counter
  from heapq import heapify, heappop, heappush
  from bisect import bisect_left
  
  # ======================================================#
  
  
  def main():
      a, b, c, k = MII()
      if k % 2 == 1:
          print(b - a)
      else:
          print(a - b)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  Takahashi, Nakahashi and Hikuhashi have integers A, B and C, respectively.
  After repeating the following operation K times, find the integer Takahashi
  will get minus the integer Nakahashi will get:
  
    * Each of them simultaneously calculate the sum of the integers that the other two people have, then replace his own integer with the result.
  
  However, if the absolute value of the answer exceeds 10^{18}, print `Unfair`
  instead.
samples: [{"input": "1 2 3 1", "output": "1\n    \n\nAfter one operation, Takahashi, Nakahashi and Hikuhashi have 5, 4 and 3,\nrespectively. We should print 5-4=1.\n\n* * *"}, {"input": "2 3 2 0", "output": "-1\n    \n\n* * *"}, {"input": "1000000000 1000000000 1000000000 1000000000000000000", "output": "0"}]