```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func sumRange(L, R uint64) uint64 {
	if L > R {
		return 0
	}
	num := R - L + 1
	return (L + R) * num / 2
}

func choose2(x uint64) uint64 {
	if x < 2 {
		return 0
	}
	return x * (x - 1) / 2
}

type Edge struct {
	u, v uint64
}

type uint64Slice []uint64

func (a uint64Slice) Len() int           { return len(a) }
func (a uint64Slice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a uint64Slice) Less(i, j int) bool { return a[i] < a[j] }

func nextUint64(reader *bufio.Reader) uint64 {
	var res uint64
	var b byte
	var err error
	for {
		b, err = reader.ReadByte()
		if err != nil || (b >= '0' && b <= '9') {
			break
		}
	}
	if err != nil {
		return 0
	}
	res = uint64(b - '0')
	for {
		b, err = reader.ReadByte()
		if err != nil || b < '0' || b > '9' {
			break
		}
		res = res*10 + uint64(b - '0')
	}
	return res
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	n := nextUint64(reader)
	m := nextUint64(reader)

	A := nextUint64(reader)
	B := nextUint64(reader)
	C := nextUint64(reader)

	edges := make([]Edge, m)
	degree := make([]uint64, n)
	for i := uint64(0); i < m; i++ {
		u := nextUint64(reader)
		v := nextUint64(reader)
		edges[i] = Edge{u, v}
		degree[u]++
		degree[v]++
	}

	adj := make([][]uint64, n)
	out := make([][]uint64, n)
	for i := uint64(0); i < n; i++ {
		adj[i] = make([]uint64, 0, degree[i])
		out[i] = make([]uint64, 0, degree[i])
	}

	for _, e := range edges {
		u, v := e.u, e.v
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)

		if degree[u] < degree[v] || (degree[u] == degree[v] && u < v) {
			out[u] = append(out[u], v)
		} else {
			out[v] = append(out[v], u)
		}
	}

	term1 := uint64(0)
	for i := uint64(0); i < n; i++ {
		rem_large := n - 1 - i
		rem_small := i

		waysA := choose2(rem_large)
		waysB := rem_small * rem_large
		waysC := choose2(rem_small)

		term1 += i * (A*waysA + B*waysB + C*waysC)
	}

	term2 := uint64(0)
	for _, e := range edges {
		u, v := e.u, e.v
		if u > v {
			u, v = v, u
		}

		if u > 0 {
			sum_x1 := sumRange(0, u-1)
			term2 += A*sum_x1 + u*(B*u+C*v)
		}

		if u+1 <= v-1 {
			num2 := v - u - 1
			sum_x2 := sumRange(u+1, v-1)
			term2 += num2*(A*u+C*v) + B*sum_x2
		}

		if v+1 <= n-1 {
			num3 := n - 1 - v
			sum_x3 := sumRange(v+1, n-1)
			term2 += num3*(A*u+B*v) + C*sum_x3
		}
	}

	term3 := uint64(0)
	N_less := make([]uint64, 0, n)
	N_greater := make([]uint64, 0, n)

	for v := uint64(0); v < n; v++ {
		N_less = N_less[:0]
		N_greater = N_greater[:0]
		sum_less := uint64(0)
		sum_greater := uint64(0)

		for _, u := range adj[v] {
			if u < v {
				N_less = append(N_less, u)
				sum_less += u
			} else {
				N_greater = append(N_greater, u)
				sum_greater += u
			}
		}

		sort.Sort(uint64Slice(N_less))
		sort.Sort(uint64Slice(N_greater))

		lenL := uint64(len(N_less))
		for i, u := range N_less {
			idx := uint64(i)
			term3 += A*(lenL-1-idx)*u + B*idx*u
		}
		term3 += C * v * choose2(lenL)

		lenG := uint64(len(N_greater))
		for i, w := range N_greater {
			idx := uint64(i)
			term3 += B*(lenG-1-idx)*w + C*idx*w
		}
		term3 += A * v * choose2(lenG)

		term3 += A*sum_less*lenG + C*sum_greater*lenL + B*v*lenL*lenG
	}

	term4 := uint64(0)
	marked := make([]bool, n)
	for u := uint64(0); u < n; u++ {
		for _, v := range out[u] {
			marked[v] = true
		}
		for _, v := range out[u] {
			for _, w := range out[v] {
				if marked[w] {
					arr := [3]uint64{u, v, w}
					if arr[0] > arr[1] {
						arr[0], arr[1] = arr[1], arr[0]
					}
					if arr[1] > arr[2] {
						arr[1], arr[2] = arr[2], arr[1]
					}
					if arr[0] > arr[1] {
						arr[0], arr[1] = arr[1], arr[0]
					}
					term4 += A*arr[0] + B*arr[1] + C*arr[2]
				}
			}
		}
		for _, v := range out[u] {
			marked[v] = false
		}
	}

	ans := term1 - term2 + term3 - term4
	fmt.Println(ans)
}
```