/*#pragma GCC optimize("O3")
#pragma GCC optimization("Ofast,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")*/
#include <bits/stdc++.h>
/*#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>*/
#define ll long long
#define ll1 long long
#define ull unsigned long long
#define dou long double
#define str string
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll, ll>
#define vpll vector<pll>
#define vbool vector<bool>
#define vstr vector<str>
#define vvll vector<vll>
#define pb push_back
#define pf push_front
#define endl "\n"
#define fr first
#define se second
// #define sortcmp(a) sort(a.begin(), a.end(), cmp)
#define sort(a) sort(a.begin(), a.end())
#define reverse(a) reverse(a.begin(), a.end())
#define speed ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define INF 1000000000000000007
#define ordered_set tree<ll, null_type, less_equal<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace std;
//using namespace __gnu_pbds;
mt19937 rng(time(0));
ll randll(ll l, ll r) {
return uniform_int_distribution<ll>(l, r)(rng);
}
struct ed{
ll a, b, c, d, i;
};
vector<vpll> g, rg;
vector<vector<pair<ll, pll>>> rg1, g1;
void dijkstra(ll n, vll& d, vector<vpll>& g1) {
set<pll> s;
for (int i = 1; i <= n; i ++) {
s.insert({d[i], i});
}
while (s.size()) {
pll p = *s.begin();
s.erase(s.begin());
for (auto i : g1[p.se]) {
if (p.fr+i.se < d[i.fr]) {
s.erase({d[i.fr], i.fr});
d[i.fr] = p.fr+i.se;
s.insert({d[i.fr], i.fr});
}
}
}
}
void dijkstra1(ll n, vll& d, vll& p1, vector<vector<pair<ll, pll>>> g1) {
set<pll> s;
for (int i = 1; i <= n; i ++) {
s.insert({d[i], i});
}
while (s.size()) {
pll p = *s.begin();
s.erase(s.begin());
for (auto i : g1[p.se]) {
if (p.fr+i.se.fr < d[i.fr]) {
p1[i.fr] = i.se.se;
s.erase({d[i.fr], i.fr});
d[i.fr] = p.fr+i.se.fr;
s.insert({d[i.fr], i.fr});
}
}
}
}
void dijkstra_nm(ll n, vll& d, vector<vpll>& g1) {
vbool us(n+7, 0);
while (1) {
pll p = {INF, INF};
for(int i = 1; i <= n; i ++){
if(us[i]) continue;
p = min(p, (pll){d[i], i});
}
if(p.fr == INF) return;
us[p.se] = 1;
for (auto i : g1[p.se]) {
if (p.fr+i.se < d[i.fr]) {
d[i.fr] = p.fr+i.se;
}
}
}
}
set<ll> edge;
vbool us;
void dfs(ll v, vll& d) {
us[v] = 1;
ll p = -1;
for (auto i : rg1[v]) {
if (d[i.fr]+i.se.fr != d[v]) continue;
p = i.se.se;
if(!us[i.fr]) dfs(i.fr, d);
}
edge.insert(p);
}
int main(){
speed;
srand(time(0));
ll n, m;
cin >> n >> m;
vector<ed> v(m);
g.resize(n+7);
rg.resize(n+7);
rg1.resize(n+7);
g1.resize(n+7);
for(int i = 0; i < m; i ++){
ll a, b, c, d;
cin >> a >> b >> c >> d;
v[i] = {a, b, c, d, i};
g[a].pb({b, c});
rg[b].pb({a, c});
rg1[b].pb({a, {c, i}});
g1[a].pb({b, {c, i}});
}
vll d_1(n+7, INF), d_n(n+7, INF), rd_1(n+7, INF), rd_n(n+7, INF);
d_1[1] = d_n[n] = rd_1[1] = rd_n[n] = 0;
vll p1(n+7, -1);
dijkstra1(n, d_1, p1, g1);
for(int i = 1; i <= n; i ++){
edge.insert(p1[i]);
}
p1.clear();
p1.resize(n+7, 0);
dijkstra1(n, d_n, p1, g1);
for(int i = 1; i <= n; i ++){
edge.insert(p1[i]);
}
dijkstra(n, rd_1, rg);
dijkstra(n, rd_n, rg);
ll minl = INF;
minl = min(minl, d_1[n]+d_n[1]);
/*for(auto i : edge){
cout << i.fr << ' ' << i.se << endl;
}*/
for(auto& i : v){
if(edge.find(i.i) == edge.end()){
ll mn = d_n[1];
mn = min(mn, d_n[i.b]+rd_1[i.a]+i.c);
minl = min(minl, mn+d_1[i.b]+rd_n[i.a]+i.d+i.c);
continue;
}
vector<vpll> g1(n+7);
for(auto& j : v){
if(j.a == i.a && j.b == i.b && j.c == i.c && j.d == i.d) g1[j.b].pb({j.a, j.c});
else g1[j.a].pb({j.b, j.c});
}
vll d(n+7, INF);
d[n] = 0;
dijkstra_nm(n, d, g1);
ll k = d[1]+i.d;
d.clear();
d.resize(n+7, INF);
d[1] = 0;
dijkstra_nm(n, d, g1);
k += d[n];
minl = min(minl, k);
//minl = min(minl, d[1]+d_1[i.b]+rd_n[i.a]+i.d+i.c);
}
//cout << d_1[n] << endl;
for(auto& i : v){
if(edge.find(i.i) == edge.end()){
//cout << i.a << ' ' << i.b << ' ' << rd_1[i.a]+d_n[i.b] << endl;
ll mn = d_1[n];
mn = min(mn, d_1[i.a]+rd_n[i.b]+i.c);
minl = min(minl, mn+rd_1[i.a]+d_n[i.b]+i.d+i.c);
continue;
}
//cout << i.a << ' ' << i.b << endl;
vector<vpll> g1(n+7);
for(auto& j : v){
if(j.a == i.a && j.b == i.b && j.c == i.c && j.d == i.d) g1[j.b].pb({j.a, j.c});
else g1[j.a].pb({j.b, j.c});
}
vll d(n+7, INF);
d[n] = 0;
dijkstra_nm(n, d, g1);
ll k = d[1]+i.d;
d.clear();
d.resize(n+7, INF);
d[1] = 0;
dijkstra_nm(n, d, g1);
k += d[n];
minl = min(minl, k);
}
if(minl == INF) cout << -1 << endl;
else cout << minl << endl;
}
