class Krawedz():
    def __init__(self, poczatek, koniec, waga):
        self.poczatek = poczatek
        self.koniec = koniec
        self.waga = waga

class KrawedzSkierowana():
    def __init__(self, koniec, waga):
        self.koniec = koniec
        self.waga = waga

class WierzcholekDrzewa():
    def __init__(self, glebokosc, przodkowie):
        self.glebokosc = glebokosc
        self.przodkowie = przodkowie

class StrukturaZbiorowRolacznych():
    def __init__(self, n):
        self._rodzice = list(range(n))
        self._rzedy = n * [0]
    def znajdz(self, indeks):
        if self._rodzice[indeks] != indeks:
            self._rodzice[indeks] = self.znajdz(self._rodzice[indeks])
        return self._rodzice[indeks]
    def polacz(self, lhs, rhs):
        lhs_korzen = self.znajdz(lhs)
        rhs_korzen = self.znajdz(rhs)
        if lhs_korzen == rhs_korzen:
            return False
        if self._rzedy[lhs_korzen] < self._rzedy[rhs_korzen]:
            self._rodzice[lhs_korzen] = rhs_korzen
        else:
            self._rodzice[rhs_korzen] = lhs_korzen
            if self._rzedy[lhs_korzen] == self._rzedy[rhs_korzen]:
                self._rzedy[lhs_korzen] += 1
        return True

n, k, q = [int(x) for x in input().split()]
krawedzie = []
for _ in range(k):
    poczatek, koniec, waga = [int(x) for x in input().split()]
    krawedzie.append(Krawedz(poczatek - 1, koniec - 1, waga))
krawedzie.sort(key = lambda kraw: kraw.waga, reverse = True)
las = StrukturaZbiorowRolacznych(n)
drzewoRozpinajace = [[] for _ in range(n)]
for i in range(k):
    kraw = krawedzie[i]
    if las.polacz(kraw.poczatek, kraw.koniec):
        drzewoRozpinajace[kraw.poczatek].append(KrawedzSkierowana(kraw.koniec, kraw.waga))
        drzewoRozpinajace[kraw.koniec].append(KrawedzSkierowana(kraw.poczatek, kraw.waga))
drzewoUkorzenione = [WierzcholekDrzewa(0, []) for _ in range(n)]
odwiedzono = n * [False]
stos = [0]
while len(stos) > 0:
    wierzcholek = stos.pop()
    odwiedzono[wierzcholek] = True
    for kraw in drzewoRozpinajace[wierzcholek]:
        if not odwiedzono[kraw.koniec]:
            stos.append(kraw.koniec)
            dziecko = drzewoUkorzenione[kraw.koniec]
            dziecko.glebokosc = drzewoUkorzenione[wierzcholek].glebokosc + 1
            dziecko.przodkowie.append(KrawedzSkierowana(wierzcholek, kraw.waga))
            i = 0
            while i < len(drzewoUkorzenione[dziecko.przodkowie[i].koniec].przodkowie):
                zrodlowaKraw = drzewoUkorzenione[dziecko.przodkowie[i].koniec].przodkowie[i]
                dziecko.przodkowie.append(
                    KrawedzSkierowana(zrodlowaKraw.koniec,
                                      min(zrodlowaKraw.waga, dziecko.przodkowie[i].waga)))
                i += 1
for _ in range(q):
    a, b = [int(x) - 1 for x in input().split()]
    if drzewoUkorzenione[a].glebokosc < drzewoUkorzenione[b].glebokosc:
        a, b = b, a
    roznicaGlebokosci = drzewoUkorzenione[a].glebokosc - drzewoUkorzenione[b].glebokosc
    wynik = 2000000000
    i = 0
    while 1 << i <= roznicaGlebokosci:
        if roznicaGlebokosci & 1 << i:
            wynik = min(wynik, drzewoUkorzenione[a].przodkowie[i].waga)
            a = drzewoUkorzenione[a].przodkowie[i].koniec
        i += 1
    while a != b:
        skok = len(drzewoUkorzenione[a].przodkowie) - 1
        while skok > 0 and drzewoUkorzenione[a].przodkowie[skok].koniec \
                == drzewoUkorzenione[b].przodkowie[skok].koniec:
            skok -= 1
        wynik = min(wynik, drzewoUkorzenione[a].przodkowie[skok].waga)
        a = drzewoUkorzenione[a].przodkowie[skok].koniec
        wynik = min(wynik, drzewoUkorzenione[b].przodkowie[skok].waga)
        b = drzewoUkorzenione[b].przodkowie[skok].koniec
    print(wynik)
