class UnionFindVerSize():

    def __init__(self, N):

        """ N個のノードのUnion-Find木を作成する """

        # 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる

        self._parent = [n for n in range(0, N)]

        # グループのサイズ（個数）

        self._size = [1] * N

        self._even = [i%2 for i in range(0,N)]

        self._odd =[(i+1)%2 for i in range(0,N)]



    def find_root(self, x):

        """ xの木の根(xがどのグループか)を求める """

        if self._parent[x] == x: return x

        self._parent[x] = self.find_root(self._parent[x]) # 縮約

        return self._parent[x]



    def unite(self, x, y):

        """ xとyの属するグループを併合する """

        gx = self.find_root(x)

        gy = self.find_root(y)

        if gx == gy: return



        # 小さい方を大きい方に併合させる（木の偏りが減るので）

        if self._size[gx] < self._size[gy]:

            self._parent[gx] = gy

            self._size[gy] += self._size[gx]

            self._even[gy] += self._even[gx]

            self._odd[gy] += self._odd[gx]

        else:

            self._parent[gy] = gx

            self._size[gx] += self._size[gy]

            self._even[gx] += self._even[gy]

            self._odd[gx] += self._odd[gy]



    def get_size(self, x):

        """ xが属するグループのサイズ（個数）を返す """

        return self._size[self.find_root(x)]



    def is_same_group(self, x, y):

        """ xとyが同じ集合に属するか否か """

        return self.find_root(x) == self.find_root(y)



    def calc_group_num(self):

        """ グループ数を計算して返す """

        N = len(self._parent)

        ans = 0

        for i in range(N):

            if self.find_root(i) == i:

                ans += 1

        return ans



    def calc_comb(self):

        N=len(self._parent)

        ans=0

        for i in range(N):

            if self.find_root(i) ==i:

                ans+=self._even[i]*self._odd[i]

        return ans





import sys



N,M=list(map(int,input().split()))

uf=UnionFindVerSize(2*N)

for i in range(M):

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

    uf.unite(2*a-2,2*b-1)

    uf.unite(2*b-2,2*a-1)



ans=uf.calc_comb()

for i in range(N):

    if uf.is_same_group(2*i,2*i+1):

        ans-=1



ans//=2

print((ans-M))
class UnionFindVerSize():

    def __init__(self, N):

        """ N個のノードのUnion-Find木を作成する """

        # 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる

        self._parent = [n for n in range(0, N)]

        # グループのサイズ（個数）

        self._size = [1] * N

        self._even = [i%2 for i in range(0,N)]

        self._odd =[(i+1)%2 for i in range(0,N)]



    def find_root(self, x):

        """ xの木の根(xがどのグループか)を求める """

        if self._parent[x] == x: return x

        self._parent[x] = self.find_root(self._parent[x]) # 縮約

        return self._parent[x]



    def unite(self, x, y):

        """ xとyの属するグループを併合する """

        gx = self.find_root(x)

        gy = self.find_root(y)

        if gx == gy: return



        # 小さい方を大きい方に併合させる（木の偏りが減るので）

        if self._size[gx] < self._size[gy]:

            self._parent[gx] = gy

            self._size[gy] += self._size[gx]

            self._even[gy] += self._even[gx]

            self._odd[gy] += self._odd[gx]

        else:

            self._parent[gy] = gx

            self._size[gx] += self._size[gy]

            self._even[gx] += self._even[gy]

            self._odd[gx] += self._odd[gy]



    def get_size(self, x):

        """ xが属するグループのサイズ（個数）を返す """

        return self._size[self.find_root(x)]



    def is_same_group(self, x, y):

        """ xとyが同じ集合に属するか否か """

        return self.find_root(x) == self.find_root(y)



    def calc_group_num(self):

        """ グループ数を計算して返す """

        N = len(self._parent)

        ans = 0

        for i in range(N):

            if self.find_root(i) == i:

                ans += 1

        return ans



    def calc_comb(self):

        N=len(self._parent)

        ans=0

        for i in range(N):

            if self.find_root(i) ==i:

                ans+=self._even[i]*self._odd[i]

        return ans





import sys



input=sys.stdin.readline



N,M=list(map(int,input().split()))

uf=UnionFindVerSize(2*N)

for i in range(M):

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

    uf.unite(2*a-2,2*b-1)

    uf.unite(2*b-2,2*a-1)



ans=uf.calc_comb()

for i in range(N):

    if uf.is_same_group(2*i,2*i+1):

        ans-=1



ans//=2

print((ans-M))

class UnionFindVerSize:
    def __init__(self, N):
        """N個のノードのUnion-Find木を作成する"""
        # 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる
        self._parent = [n for n in range(0, N)]
        # グループのサイズ（個数）
        self._size = [1] * N
        self._even = [i % 2 for i in range(0, N)]
        self._odd = [(i + 1) % 2 for i in range(0, N)]

    def find_root(self, x):
        """xの木の根(xがどのグループか)を求める"""
        if self._parent[x] == x:
            return x
        self._parent[x] = self.find_root(self._parent[x])  # 縮約
        return self._parent[x]

    def unite(self, x, y):
        """xとyの属するグループを併合する"""
        gx = self.find_root(x)
        gy = self.find_root(y)
        if gx == gy:
            return
        # 小さい方を大きい方に併合させる（木の偏りが減るので）
        if self._size[gx] < self._size[gy]:
            self._parent[gx] = gy
            self._size[gy] += self._size[gx]
            self._even[gy] += self._even[gx]
            self._odd[gy] += self._odd[gx]
        else:
            self._parent[gy] = gx
            self._size[gx] += self._size[gy]
            self._even[gx] += self._even[gy]
            self._odd[gx] += self._odd[gy]

    def get_size(self, x):
        """xが属するグループのサイズ（個数）を返す"""
        return self._size[self.find_root(x)]

    def is_same_group(self, x, y):
        """xとyが同じ集合に属するか否か"""
        return self.find_root(x) == self.find_root(y)

    def calc_group_num(self):
        """グループ数を計算して返す"""
        N = len(self._parent)
        ans = 0
        for i in range(N):
            if self.find_root(i) == i:
                ans += 1
        return ans

    def calc_comb(self):
        N = len(self._parent)
        ans = 0
        for i in range(N):
            if self.find_root(i) == i:
                ans += self._even[i] * self._odd[i]
        return ans


import sys

N, M = list(map(int, input().split()))
uf = UnionFindVerSize(2 * N)
for i in range(M):
    a, b = list(map(int, input().split()))
    uf.unite(2 * a - 2, 2 * b - 1)
    uf.unite(2 * b - 2, 2 * a - 1)
ans = uf.calc_comb()
for i in range(N):
    if uf.is_same_group(2 * i, 2 * i + 1):
        ans -= 1
ans //= 2
print((ans - M))

class UnionFindVerSize:
    def __init__(self, N):
        """N個のノードのUnion-Find木を作成する"""
        # 親の番号を格納する。自分が親だった場合は、自分の番号になり、それがそのグループの番号になる
        self._parent = [n for n in range(0, N)]
        # グループのサイズ（個数）
        self._size = [1] * N
        self._even = [i % 2 for i in range(0, N)]
        self._odd = [(i + 1) % 2 for i in range(0, N)]

    def find_root(self, x):
        """xの木の根(xがどのグループか)を求める"""
        if self._parent[x] == x:
            return x
        self._parent[x] = self.find_root(self._parent[x])  # 縮約
        return self._parent[x]

    def unite(self, x, y):
        """xとyの属するグループを併合する"""
        gx = self.find_root(x)
        gy = self.find_root(y)
        if gx == gy:
            return
        # 小さい方を大きい方に併合させる（木の偏りが減るので）
        if self._size[gx] < self._size[gy]:
            self._parent[gx] = gy
            self._size[gy] += self._size[gx]
            self._even[gy] += self._even[gx]
            self._odd[gy] += self._odd[gx]
        else:
            self._parent[gy] = gx
            self._size[gx] += self._size[gy]
            self._even[gx] += self._even[gy]
            self._odd[gx] += self._odd[gy]

    def get_size(self, x):
        """xが属するグループのサイズ（個数）を返す"""
        return self._size[self.find_root(x)]

    def is_same_group(self, x, y):
        """xとyが同じ集合に属するか否か"""
        return self.find_root(x) == self.find_root(y)

    def calc_group_num(self):
        """グループ数を計算して返す"""
        N = len(self._parent)
        ans = 0
        for i in range(N):
            if self.find_root(i) == i:
                ans += 1
        return ans

    def calc_comb(self):
        N = len(self._parent)
        ans = 0
        for i in range(N):
            if self.find_root(i) == i:
                ans += self._even[i] * self._odd[i]
        return ans


import sys

input = sys.stdin.readline
N, M = list(map(int, input().split()))
uf = UnionFindVerSize(2 * N)
for i in range(M):
    a, b = list(map(int, input().split()))
    uf.unite(2 * a - 2, 2 * b - 1)
    uf.unite(2 * b - 2, 2 * a - 1)
ans = uf.calc_comb()
for i in range(N):
    if uf.is_same_group(2 * i, 2 * i + 1):
        ans -= 1
ans //= 2
print((ans - M))

+input = sys.stdin.readline