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):
N = int(input())
print(180*(N-2))

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

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())               
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())
ans = int(180 * (n - 2))
print(ans)

Solution (Python):
def read():
    N = int(input().strip())
    return N, 


def solve(N):
    return (N - 2) * 180


if __name__ == '__main__':
    inputs = read()
    print("%d" % solve(*inputs))

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
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 II(): return int(sys.stdin.readline())
def SI(): return int(input())
from collections import defaultdict

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

Solution (Python):
import bisect
from operator import itemgetter
import math
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

Solution (Python):

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

print(int(180*(a[0]-2)))

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

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

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

Solution (Python):
def getlist():
	return map(int, input().split())

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

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

print((N-2)*180)

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

Solution (Python):
import math
from functools import reduce
from collections import deque

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


def get_nums_l():
    return [ int(s) for s in input().split(" ")]


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

n = int(input())

print((n-2) * 180)

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

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(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((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()) - 360 )

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    n = f()[0]
    print((n-2)*180)

solve()

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

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

print((n-2) * 180)

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

print(s)

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    N = int(input())

    return 180 * (N - 2)


if __name__ == '__main__':
    print(main())

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

print(180*(n-2))

Solution (Python):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


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


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


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


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(N):
    return 180*(N-2)


def main():
    N = read_int()
    print(slv(N))


if __name__ == '__main__':
    main()

Solution (Python):

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

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

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):
N = int(input())
print(180 * (N - 2))

Solution (Python):










import numpy as np
import math
import copy

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

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

Solution (Python):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict
import math


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def gcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    ret = math.factorial(x)
    ret = ret // (math.factorial(x - y) * math.factorial(y))

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance


class UnionFind:

    def __init__(self, n):
        self.parent = [i for i in range(n)]

    def root(self, i):
        if self.parent[i] == i:
            return i
        self.parent[i] = self.root(self.parent[i])
        return self.parent[i]

    def unite(self, i, j):
        rooti = self.root(i)
        rootj = self.root(j)
        if rooti == rootj:
            return
        if rooti < rootj:
            self.parent[rootj] = rooti
        else:
            self.parent[rooti] = rootj

    def same(self, i, j):
        return self.root(i) == self.root(j)





def main():
    n = intin()

    print((n - 2) * 180)


if __name__ == '__main__':
    main()

Solution (Python):

nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

N = n()

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):
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())
ans = 180 * (N - 2)
print(int(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):
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())

ans = (n-2)*180

print(ans)

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())

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

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().rstrip()
def mi(): return map(int, input().split())


N = int(input())

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

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

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

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

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

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

print((n-2)*180)

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

Solution (Python):
n=int(raw_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):
print(180*(int(input())-2))

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

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):
print((int(input())-2)*180)

Solution (Python):
n = int(raw_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(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(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(180*(N-2))

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

print(180 * (N - 2))

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
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 II(): return int(sys.stdin.readline())
def SI(): return input()

def main():
    N = II()
    ans = 180 * (N - 2)
    return ans

print(main())

Solution (Python):
import bisect
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys

sys.setrecursionlimit(2147483647)
INF = float('inf')

if os.getenv('LOCAL'):
    sys.stdin = open('_in.txt')


N = int(sys.stdin.readline())
print((N-2)*180)

Solution (Python):


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


if __name__ == '__main__':
    main()

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

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

print((n - 2) * 180)

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

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

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

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007


def A():
    n = I()
    print(180*(n-2))
    return


def B():
    n = I()

    return


def C():
    n = I()
    return


def D():
    n = I()
    return


def E():
    n = I()
    return


def F():
    n = I()
    return


if __name__ == "__main__":
    A()

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((n-2)*180)

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

Solution (Python):
def gcd_core(a, b):
    if b == 0:
        return a
    else:
        return gcd_core(b, a % b)


def gcd(arr):
    g = gcd_core(arr[0], arr[1])
    for i in range(2, len(arr)):
        g = gcd_core(g, arr[i])
    return g

n = int(input())

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,copy,functools
import random

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 list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
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 pe(s): return print(str(s), file=sys.stderr)


def main():
    n = I()

    return (n-2) * 180


print(main())

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    n = II()
    print((n-2)*180)
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

Solution (Python):




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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

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

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(180*(N-2))

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

Solution (Python):
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
nsm = lambda: map(str, sys.stdin.readline().split())

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

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

print((N - 2) * 180)

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

print(180*(n-2))

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

Solution (Python):
n = int(input())
print(str((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):
n = int(input())

print(180 * (n - 2))

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7

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

def main():
  n=I()
  return 180*(n-2)

print(main())

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, log2
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

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()))
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):
from collections import Counter
from collections import deque
from functools import reduce
from pprint import pprint

import bisect
import copy
import fractions
import math
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) 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 MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers): return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers): return reduce(LCM, numbers)
def LCM(m, n): return (m * n // fractions.gcd(m, n))
def unite(x, y):
    
    x = root(x)
    y = root(y)
    if x == y:
        return
    
    node[x] = y
def same(x,y): return bool(root(x) == root(y))
def root(x):
    if node[x] == x:  
        return x
    else:
        node[x] = root(node[x])  
        return node[x]
def dfs(v):
    
    visited[v] = True
    for v2 in range(n):
        if graph[v][v2] == False:  
            continue
        if visited[v2] == True:  
            continue
        dfs(v2)


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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

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 collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    n = II()
    print((n-2)*180)
    return


def B():
    return


def C():
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

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

Solution (Python):
from sys import exit, setrecursionlimit, stderr, stdin
from functools import reduce
from itertools import *
from collections import defaultdict, Counter
from bisect import bisect
import functools

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

def read():
  return int(input())

def reads():
  return [int(x) for x in input().split()]

N = read()
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

sys.setrecursionlimit(10 ** 7)

def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x) - 1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

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

Solution (Python):

def main():
    buf = input()
    buflist = buf.split()
    N = int(buflist[0])
    print(180 * (N - 2))

if __name__ == '__main__':
    main()

Solution (Python):
import sys
from fractions import gcd
from itertools import groupby as gb
from itertools import permutations as perm
from itertools import combinations as comb
from collections import Counter as C
from collections import defaultdict as dd
sys.setrecursionlimit(10**5)
def y(f):
    if f:
        print('Yes')
    else:
        print('No')
def Y(f):
    if f:
        print('YES')
    else:
        print('NO')

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(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*180-360)

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

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