def razdalja_povezava(x0, y0, x1, y1):
    return abs(x1-x0) + abs(y1-y0)

def pravilna(povezava):
    x0, y0, x1, y1 = povezava
    # preveri dolzino
    prekratka = razdalja_povezava(x0, y0, x1, y1) > 0

    # preveri, da je vodoravna ali navpicna in ne diagonalna
    diagonalna = (x0 == x1) or (y0 == y1)

    return prekratka and diagonalna

def pravilne(povezave):
    for i in povezave:
        if not pravilna(i):
            return False

    return True

def urejena(povezava):
    x0, y0, x1, y1 = povezava

    if x1 < x0 or y1 < y0:
        return x1, y1, x0, y0

    return povezava

def na_povezavi(x, y, povezava):
    x0, y0, x1, y1 = urejena(povezava)

    return  x0 <= x <= x1 and y0 <= y <= y1

def povezave_tocke(x, y, povezave):
    r = set()

    for i in povezave:
        if na_povezavi(x, y, i):
            r.add(urejena(i))

    return r

def generiraj_tuples_povezava(povezava):
    pov = []

    x0, y0, x1, y1 = povezava

    if x0 == x1:
        z0 = y0
        z1 = y1
    else:
        z0 = x0
        z1 = x1

    for i in range(z0, z1 + 1):
        if x0 == x1:
            r = (x0, i)
        else:
            r = (i, y0)
        pov.append(r)

    return pov

def secisce(povezava1, povezava2):
    if not pravilna(povezava1) and not pravilna(povezava2): return None

    pov1 = generiraj_tuples_povezava(urejena(povezava1))
    pov2 = generiraj_tuples_povezava(urejena(povezava2))

    for i in pov1:
        for j in pov2:
            if i == j:
                return i

    return None

def urejeni_povezavi(povezava1, povezava2):
    pov1 = urejena(povezava1)
    pov2 = urejena(povezava2)

    x0_1, y0_1, x1_1, y1_1 = pov1
    x0_2, y0_2, x1_2, y1_2 = pov2

    if x0_1 < x0_2:
        return pov1, pov2
    elif x0_2 < x0_1:
        return pov2, pov1

    if y0_1 < y0_2:
        return pov1, pov2
    elif y0_2 < y0_1:
        return pov2, pov1

    if x1_1 < x1_2:
        return pov1, pov2
    elif x1_2 < x1_1:
        return pov2, pov1

    if y1_1 < y1_2:
        return pov1, pov2
    elif y1_2 < y1_1:
        return pov2, pov1

    # sigurno ne bosta dve identični povezavi prileteli sem? :D
    if x0_1 == x0_2 and y0_1 == y0_2: return None

def krizisca(povezave):
    krizisce = {}

    for povezava1 in povezave:
        povezava1 = urejena(povezava1)

        for povezava2 in povezave:
            povezava2 = urejena(povezava2)

            # nočemo primerjati križišče s samim sabo
            if povezava1 == povezava2:
                continue

            # sortiranje povezav
            pov1, pov2 = urejeni_povezavi(povezava1, povezava2)

            # preverimo če trenutni povezavi že obstajata v slovarju
            if (pov1, pov2) in krizisce:
                continue

            # preverimo če najdemo sečišče
            sec = secisce(pov1, pov2)

            # če ga najdemo dodamo vnos v slovar
            if sec is not None:
                # drugi imeni spr samo zaradi manjša zmede, ker se lahko zamenjata
                krizisce[(pov1, pov2)] = sec

    return krizisce

def mozna_pot(pot, mreza):
    for povezava in pot:
        # dobimo urejeno povezavo
        pov = urejena(povezava)
        obstaja_pot = False

        # preverimo če obstaja povezava v mreži
        for x,y in mreza.keys():
            if pov == x or pov == y:
                obstaja_pot = True
                break

        # če ne obstaja pot takoj zaključi izvajanje
        if not obstaja_pot:
            return False

        # to be continued, preveriti moramo še če se vse povezave stikajo skupaj
        for i in range(0, len(pot)):
            # preverjamo trenutno povezavo z naslednjo, zato
            if i + 1 == len(pot): break

            if secisce(pot[i], pot[i+1]) is None: return False

    return True

def razdalja(pot, mreza):
    skupna_razdalja = 0

    povezava1, povezava2 = urejeni_povezavi(pot[0], pot[1])
    sec = mreza[(povezava1, povezava2)] # ker imamo zagotovilo v navodilih, da ima pot vsaj dve povezavi
    print(povezava1, povezava2)

    for i in range(2, len(pot)):
        # ker gledamo i za 1 vnaprej (torej tudi naslednjo pot)
        if i + 1 == len(pot): break

        x0, y0 = sec

        povezava1, povezava2 = urejeni_povezavi(pot[i], pot[i+1])
        trenutno_sec = mreza[(povezava1, povezava2)]
        x1, y1 = trenutno_sec

        skupna_razdalja += razdalja_povezava(x0, y0, x1, y1)

        sec = trenutno_sec

    return skupna_razdalja

def main():
    print()

main()