Problem:
 Score : 100 points    Problem Statement Given an integer N not less than 3 , find the sum of the interior angles of a regular polygon with N sides.  Print the answer in degrees, but do not print units.      Constraints  3 \leq N \leq 100         Input Input is given from Standard Input in the following format:  N       Output Print an integer representing the sum of the interior angles of a regular polygon with N sides.        Sample Input 1 3      Sample Output 1 180  The sum of the interior angles of a regular triangle is 180 degrees.       Sample Input 2 100      Sample Output 2 17640

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print((int(input())-2) * 180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
print((n - 2) * 180)

Solution (Python):
N=int(input())
print((N-2)*180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())


print(180*(I()-2))

Solution (Python):
n = int(input())

print(180*(n-2))

Solution (Python):
N = int(input())
ans = 180 * (N - 2)
print(ans)

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
ans = 180 * (N-2)
print(ans)

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
print((N-2)*180)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
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()))

n = inp()
print(180*(n-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  


print(180*(I()-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
N = int(input())
ans = (N-2)*180
print(ans)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):

import sys
def input():
    return sys.stdin.readline()[:-1]

def main():
    N = int(input())

    print(180*(N - 2))

if __name__ == '__main__':
    main()

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
print(180 * (int(input()) -2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
N = int (input ())
print (180 * (N-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
def main():
    n = int(input())

    print(180 * n - 360)


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
ans = 180*n - 360
print(ans)

Solution (Python):
n = int(input())
print((n - 2) * 180)

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
print((n - 2) * 180)

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N = I()

    ans = (N - 2) * 180
    print(ans)

if __name__ == '__main__':
    resolve()

Solution (Python):
'''
Created on 2020/08/20

@author: harurun
'''
def main():
  import sys
  pin=sys.stdin.readline
  pout=sys.stdout.write
  perr=sys.stderr.write
  
  N=int(pin())
  print((N-2)*180)
  return 

main()

Solution (Python):

n=int(input())
ans=180*(n-2)
print(ans)

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
a = int(input())
print(int(a * 180 - 360))

Solution (Python):
import sys, math
from functools import lru_cache
sys.setrecursionlimit(500000)
MOD = 10**9+7

def input():
    return sys.stdin.readline()[:-1]

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

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

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]

def main():
    N = ii()
    print((N-2)*180)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):




import sys;      from decimal import Decimal
import math;     from collections import Counter
import bisect;   from itertools import combinations


MOD = 10 ** 6 + 7
INF = 10 ** 9
PI = 3.14159265358979323846

def read_str():      return sys.stdin.readline().strip()
def read_int():      return int(sys.stdin.readline().strip())
def read_ints():     return map(int, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)

def Main():
    n = int(input())
    print((n - 2) * 180)

if __name__ ==  '__main__':
    Main()

Solution (Python):
print((int(input())-2)*180)

Solution (Python):




import sys;      from decimal import Decimal
import math;     from collections import Counter
import bisect;   from itertools import combinations


MOD = 10 ** 6 + 7
INF = 10 ** 9
PI = 3.14159265358979323846

def read_str():      return sys.stdin.readline().strip()
def read_int():      return int(sys.stdin.readline().strip())
def read_ints():     return map(int, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def lcm(a: int, b: int) -> int: return (a * b) // math.gcd(a, b)

def Main():
    n = read_int()
    print((n - 2) * 180)

if __name__ ==  '__main__':
    Main()

Solution (Python):
n = int(input())
 
print(180*n-360)

Solution (Python):
N=int(input())
print(180*(N-2))

Solution (Python):
N=int(input())
print(180*(N-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    N = int(readline())
    print(180*(N-2))

if __name__ == '__main__':
    main()

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n = int(input())
print((n - 2) * 180)

Solution (Python):
import math
import sys
import collections
import bisect
readline = sys.stdin.readline


def main():
    print((int(readline().rstrip()) - 2) * 180)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
ans = (n - 2) * 180
print(ans)

Solution (Python):
print(180 * (int(input()) - 2))

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    N = int(input())
    ans = (N - 2) * 180
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
N=int(input())
print((N*180)-360)

Solution (Python):
N = int(input())

print(180*(N-2))

Solution (Python):
N = int(input())
print((N-2)*180)

Solution (Python):
n = int(input())

print((n-2)*180)

Solution (Python):
print(180 * (int(input()) - 2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
N = int(input())

print(180 * (N - 2))

Solution (Python):
N = int(input())
print(N*180-360)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())
ans = (n - 2) * 180
print(ans)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n = int(input())
print(180 * n - 360)

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
n = int(input())
print(180 * (n-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
N = int(input())
print(180 * (N - 2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n = int(input())
ans = (n - 2) * 180
print(ans)

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
n = int(input())
print(int((180-(360/n))*n))

Solution (Python):
n = int(input())
print(180 * (n-2))

Solution (Python):

n = int(input())
print((n-2)*180)

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n=int(input())
n-=2
print(n*180)

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
import sys
input = sys.stdin.readline

def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))

def main():
    mod=10**9+7
    N=I()
    print((N-2)*180)

main()

Solution (Python):
n = int(input())
print(180 * (n - 2))

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
n=int(input())

print((n-2)*180)

Solution (Python):
n = int(input())

print((n - 2)*180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
N = int(input())
print((N-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10**9 + 7


N = INT()

print(180*(N-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
print(180 * (int(input()) - 2))

Solution (Python):
n = int(input())

print(180*(n-2))

Solution (Python):
def main():
    N = int(input())
    print(180*(N-2))

if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())

print((n-2)*180)

Solution (Python):
print(int(input())*180-360)

Solution (Python):
N = int(input())

a = 180 * (N - 2)

print(a)

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())
print(180*(I()-2))

Solution (Python):
n = int(input())
print(n*180-360)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
print(180 * (n-2))

Solution (Python):
from statistics import median


from fractions import gcd
from itertools import combinations 
from collections import deque
from collections import defaultdict
import bisect










import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
n = I()
print((180 * (n-2)))

Solution (Python):
n = int(input())
print((n-2)* 180)

Solution (Python):
import sys

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


def resolve():
    n = int(input())
    print(180 * (n - 2))


if __name__ == '__main__':
    resolve()

Solution (Python):
n=int(input())
ans=(n-2)*180
print(ans)

Solution (Python):
N = int(input())

print(180 * (N-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n=int(input())
print((n-2)*180)

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

n = int(input())

print(180*(n-2))

Solution (Python):
N = int(input())
print(180 + 180*(N-3))

Solution (Python):
import sys
import math
import bisect

def main():
    print(180 * (int(input()) - 2))
    
if __name__ == "__main__":
    main()

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n = int(readline())
print((n-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
print(180 * (n - 2))

Solution (Python):
N = (int)(input())
print((N-2)*180)

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):

import sys


def solve(N: int):
    print(int((180 - 360 / N) * N))
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    solve(N)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
N=int(input())
print((N-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
ans = 180 * (n-2)

print(ans)

Solution (Python):



N = int(input())


ans = 180 * (N - 2)


print(ans)

Solution (Python):

n = int(input())
print((n-2)*180)

Solution (Python):
n = int(input())

print((n-2) * 180)

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
N = int(input())
print(180 * (N - 2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
n = int(input())
ans = (n-2) * 180
print(ans)

Solution (Python):
N = int(input())

print ((N - 2) * 180)

Solution (Python):


import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))

def resolve():
    N=int(input())
    print(180*(N-2))
    
    


resolve()

Solution (Python):
N=int(input())
print((N-2)*180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

def resolve():

    n=int(input())

    print(180*(n-2))

resolve()

Solution (Python):
N=int(input())

ans=180*N-360
print(ans)

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())

print((n-2)*180)

Solution (Python):
n = int(input())
print(180 * (n-2))

Solution (Python):
N=int(input())
print(180*(N-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
def main():
    N = int(input())
    print(180*(N-2))


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
print(180 * (n - 2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
ans = (N-2)*180
print(ans)

Solution (Python):
n = int(input())
print(180 * (n - 2))

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
n = int(input())

print(180*(n-2))

Solution (Python):
N=int(input())
print((N-2)*180)

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
N = int(input())
print((N-2) * 180)

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
import sys

stdin = sys.stdin
inf = 1 << 60
mod = 1000000007

ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

n = ni()

print(180 * (n - 2))

Solution (Python):
def resolve():
    n=int(input())
    print((n-2)*180)
resolve()

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

    n = int(input())
    print((n-2)*180)

if __name__ == '__main__':
    main()

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
N=int(input())
print(180*(N-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
N = int(input())

print(180 * (N-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n=int(input())
    print(180*(n-2))

if __name__=='__main__':
    main()

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
N = int(input())
print(180 * (N-2))

Solution (Python):
print(180*( int(input())-2 ))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):

print((int(input()) - 2) * 180)

Solution (Python):
N = int(input())
print(180 * (N - 2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
a = int(input())
print((a - 2) * 180)

Solution (Python):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

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

if __name__ == '__main__':
    s=int(input())
    
    print(int((s-2)*180))

Solution (Python):
n = int(input())
print(180*n-360)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
N = int(input())

print((N-2)*180)

Solution (Python):
N=int(input())
print((180*(N-2)))

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import defaultdict
from bisect import *
mod = 10**9+7

N = int(input())
print(180*(N-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
N = int(input())

print((N - 2) * 180)

Solution (Python):
N = int(input())
print((N-2)*180)

Solution (Python):
n = int(input())
print(int(n * (180 - 360 / n)))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]





n=ii()
print(180*(n-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
print((int(input()) - 2) * 180)

Solution (Python):
N = int(input())
ans=(N-2)*180


print(ans)

Solution (Python):
n = int(input())

print(180 * (n - 2))

Solution (Python):
print((int(input()) - 2) * 180)

Solution (Python):
n = int(input())
print(180 * (n -2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
def main():
    print(180 * (int(input()) - 2))


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

ans = 180 * (n - 2)
print(ans)

Solution (Python):
N = int(input())

ans = (180 * (N-2))
print(ans)

Solution (Python):
n = int(input())
print (180*(n-2))

Solution (Python):
print(180*int(input())-360)

Solution (Python):
n = int(input())
print((n-2) * 180)

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
x=int(input())
print((x-2)*180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print(int(input())*180-360)

Solution (Python):
n = int(input())
ans = ( n - 2 ) * 180
print(ans)

Solution (Python):
n = int(input())
print((n-2) * 180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
n = int(input())
print((n - 2) * 180)

Solution (Python):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    n = int(input())
    print((n-2)*180)

if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
print(180*(N-2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
print(180*(N - 2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
n = int(input())

print(180 * (n - 2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):


print((int(input()) - 2) * 180)

Solution (Python):
print((int(input()) - 2) * 180)

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):

n = int(input())
print((n-2)*180)

Solution (Python):
n = int(input())

print(180*(n-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
from sys import stdin
N = int(stdin.readline().rstrip())
print(180*(N-2))

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):


N = int(input())

print(180 * (N - 2))

Solution (Python):
n = int(input())

print(180*(n-2))

Solution (Python):
k=int(input())
print((k-2)*180)

Solution (Python):
print((int(input()) - 2)*180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n=int(input())

print(180*(n-2))

Solution (Python):

 
import math
import itertools
import sys
import copy
 




N = int(input())


print (180*(N-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
N = int(input())
print(180 * (N - 2))

Solution (Python):
n = int(input())
print(180 * (n - 2))

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())

print((n-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
def main():
    N = int(input())
    print(180*(N-2))


if __name__ == '__main__':
    main()

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    print((I()-2)*180)
if __name__ == '__main__':
    main()

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,hypot,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    print((I()-2)*180)
if __name__ == '__main__':
    main()

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print(180*int(input())-360)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
N=int(input())
print(180*(N-2))

Solution (Python):
n = int(input())

print(180+180*(n-3))

Solution (Python):
import sys
if sys.platform =='ios':
	sys.stdin=open('input.txt')

n = int(input())

print((n-2)*180)

Solution (Python):
def main(n: int):
    print(180 * (n - 2))


if __name__ == "__main__":
    n = int(input())

    main(n)

Solution (Python):
N=int(input())

print(180*N-360)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
print(int(input())*180-360)

Solution (Python):
n=int(input())

print((n-2)*180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
def examA():
    N = I()
    ans = 180*(N-2)
    print(ans)


import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n  = int(input())
print((2*n-4)*90)

Solution (Python):

N = int(input())
print(180*(N-2))

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
import sys


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n = int(readline())
    print((n - 2) * 180)


if __name__ == '__main__':
    solve()

Solution (Python):
print((int(input()) - 2) * 180)

Solution (Python):
N = int(input())

ans = (N - 2) * 180 
print(ans)

Solution (Python):
print(int(input())*180-360)

Solution (Python):
print(180 * (int(input()) - 2))

Solution (Python):


n = int(input())
print(180*(n-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
n=int(input())
print(180*(n-2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):

n = int(input())
print((n - 2) * 180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())

print((n-2)*180)

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
N = int(input())
print(180*(N-2))

Solution (Python):
n = int(input())
print(int(180*(n-2)))

Solution (Python):
n=int(input())
print((n-2)*180)

Solution (Python):
N = int(input())
print((N-2)*180)

Solution (Python):

N = int(input())
print(180 * (N -2))

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())
n = (n-2)*180
print(n)

Solution (Python):
N = int(input())
print((N - 2) * 180)

Solution (Python):
print((int(input())-2)*180)

Solution (Python):
n = int(input())
print((n - 2) * 180)

Solution (Python):
print(180*(int(input())-2))

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n = int(input().rstrip('\n'))
    print((n - 2) * 180)


if __name__ == '__main__':
    slove()

Solution (Python):
n = int(input())
print((n-2)*180)

Solution (Python):
a = int(input())
b = a-2
print(b*180)

Solution (Python):
N = int(input())
print((N-2)*180)

Solution (Python):
n = int(input())
print(180*(n-2))

Solution (Python):
n =int(input())
print(180*(n-2))

Solution (Python):

n = int(input())


print((n-2)*180)

Solution (Python):
import sys
sides = int(input())
if sides < 3 or sides > 100:
  sys.exit()
print((sides-2)*180)

Solution (Python):
n = int(input())

print(int((180-360/n)*n))

Solution (Python):
print(int(input())*180-360)

Solution (Python):
def resolve():
    n = int(input())
    print(180 * (n - 2))


if __name__ == "__main__":
    resolve()

Solution (Python):
N = int(input())
print(180 * (N-2))

Solution (Python):
import sys
input = sys.stdin.readline
 
def main():
    N = int(input())
    print(180*(N-2))

if __name__ == '__main__':
    main()

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n = int(input().rstrip('\n'))
    print((n - 2) * 180)


if __name__ == '__main__':
    slove()