from sys import stdin
input = stdin.readline
from collections import defaultdict

class UnionFind:
    def __init__(self,n):
        self.n = n
        self.parent_size = [-1]*n
 
    def leader(self,a):
        if self.parent_size[a] < 0:
            return a
        self.parent_size[a] = self.leader(self.parent_size[a])
        return self.parent_size[a]
 
    def merge(self,a,b):
        x, y = self.leader(a), self.leader(b)
        if x == y:
            return 
        if abs(self.parent_size[x]) < abs(self.parent_size[y]):
            x, y = y, x
        self.parent_size[x] += self.parent_size[y]
        self.parent_size[y] = x
        return 
 
    def same(self,a,b):
        return self.leader(a) == self.leader(b)
 
    def size(self,a):
        return abs(self.parent_size[self.leader(a)])
 
    def groups(self):
        result = [[] for _ in range(self.n)]
        for i in range(self.n):
            result[self.leader(i)].append(i)
        return [r for r in result if r != []]

INF = 1<<60

N, M, X, K = map(int, input().split())
A = list(map(int, input().split()))
G = [[] for _ in range(N)]
for i in range(M):
    u, v = map(int, input().split())
    u, v = u-1, v-1
    if X < abs(A[u]-A[v]): continue
    G[u].append(v)
    G[v].append(u)

def nC2(n):
    return n*(n-1)//2
def nC3(n):
    return n*(n-1)*(n-2)//6

if 3 <= K:
    UF = UnionFind(N*2)
    UF2 = UnionFind(N*2)
    for n in range(N):
        for v in G[n]:
            if A[n] < A[v]:
                UF.merge(n, v+N)
            else:
                UF.merge(n+N, v)
    for n in range(N):
        MIN, MAX = -INF, INF
        for v in G[n]:
            if A[v] <= A[n]:
                MIN = max(MIN, A[v])
            else:
                MAX = min(MAX, A[v])
        if abs(MIN-MAX) <= X:
            UF.merge(n, n+N)
    GR = UF.groups()
    ans = 0
    for g in GR:
        cnt = 0
        S = set()
        for n in g:
            if n < N:
                S.add(n)
            else:
                S.add(n-N)
        ans += nC2(len(S))*2
    D = defaultdict(int)
    for n in range(N):
        if UF.same(n, n+N): continue
        a, b = UF.leader(n), UF.leader(n+N)
        if a > b: a, b = b, a
        ans -= D[(a, b)]
        D[(a, b)] += 1
    print(ans)
else:
    UF = UnionFind(N)
    for n in range(N):
        for v in G[n]:
            UF.merge(n, v)
    ans = 0
    for i in range(N):
        if UF.leader(i) == i:
            ans += nC2(UF.size(i))*2

    print(ans)