#include <iostream>
#include <vector>
#include <algorithm>

struct Ter {
    int p;
    std::vector<int> ki_szomszedok, be_szomszedok;
};

using Graf = std::vector<Ter>;

Graf beolvas(std::istream &be) {
    int n, m;
    be >> n >> m;

    Graf g(n);
    for (auto &ter : g) {
        be >> ter.p;
    }

    for (int i = 0; i < m; i++) {
        int honnan, hova;
        be >> honnan >> hova;
        g[honnan - 1].ki_szomszedok.push_back(hova - 1);
        g[hova - 1].be_szomszedok.push_back(honnan - 1);
    }

    return g;
}

void topo_sorrend(int akt_ter, const Graf &g, std::vector<bool> &lattam, std::vector<int> &sorrend) {
    if (lattam[akt_ter]) {
        return;
    }
    lattam[akt_ter] = true;

    for (const auto sz : g[akt_ter].ki_szomszedok) {
        topo_sorrend(sz, g, lattam, sorrend);
    }

    sorrend.push_back(akt_ter);
}

void feldolgoz(const Graf &g) {
    const int n = static_cast<int>(g.size());

    std::vector<int> szulo(n, -1), max_p(n, -1);
    std::vector<bool> lattam(n, false);
    std::vector<int> ts;

    topo_sorrend(0, g, lattam, ts);

    max_p[0] = g[0].p;
    for (int i = static_cast<int>(ts.size()) - 1; i >= 0; i--) {
        const auto akt = ts[i];

        int m = 0;
        for (const auto sz : g[akt].be_szomszedok) {
            if (m < max_p[sz]) {
                m = max_p[sz];
                szulo[akt] = sz;
            }
        }
        max_p[akt] = g[akt].p + m;
    }

    std::cout << max_p[n - 1] << '\n';
    if (max_p[n - 1] != -1) {
        std::vector<int> sorrend;
        for (int akt = n - 1; akt != -1; akt = szulo[akt]) {
            sorrend.push_back(akt);
        }

        while (!sorrend.empty()) {
            std::cout << sorrend.back() + 1 << ' ';
            sorrend.pop_back();
        }
       std::cout << '\n';
    }
}

int main() {
    const auto g = beolvas(std::cin);
    feldolgoz(g);

    return 0;
}