#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<string>

#include<cmath>

#include<algorithm>

#include<vector>

using namespace std;

const int N = 3e5 + , M = 3e5 + ;

int n, m, ans[N], offset;

int ecnt, adj[N], go[M << ], nxt[M << ];

int w[N], dep[N], cnt[N << ], fa[N][];

struct node{

    int val, delta;

    node(){}

    node(int a, int b):val(a), delta(b){}

};

vector<node> tag[N];

inline void addEdge(int u, int v){

    nxt[++ecnt] = adj[u], adj[u] = ecnt, go[ecnt] = v;

    nxt[++ecnt] = adj[v], adj[v] = ecnt, go[ecnt] = u;

}

inline int getLca(int u, int v){

    if(dep[u] < dep[v]) swap(u, v);

    int delta = dep[u] - dep[v];

    for(int i = ; i >= ; i--)

        if(( << i) & delta) u = fa[u][i];

    if(u == v) return u;

    for(int i = ; i >= ; i--)

        if(fa[u][i] != fa[v][i])

            u = fa[u][i], v = fa[v][i];

    return fa[u][];

}

inline void dfs(int u, int f){

    fa[u][] = f;

    for(int i = ; i <= ; i++)

        fa[u][i] = fa[fa[u][i - ]][i - ];

    for(int e = adj[u], v; e; e = nxt[e]){

        v = go[e];

        if(v != f){

            dep[v] = dep[u] + ;

            dfs(v, u);

        }

    }

}

inline void solve(int u){

    int cur = cnt[dep[u] + w[u]] + cnt[w[u] - dep[u] + offset];

    for(int i = ; i < tag[u].size(); i++)

        cnt[tag[u][i].val] += tag[u][i].delta;

    for(int e = adj[u], v; e; e = nxt[e]){

        if((v = go[e]) == fa[u][]) continue;

        solve(v);

    }

    ans[u] = cnt[dep[u] + w[u]] + cnt[w[u] - dep[u] + offset] - cur;

}

inline int read(){

    int i = , f = ; char ch = getchar();

    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());

    if(ch == '-') f = -, ch = getchar();

    for(; ch >= '' && ch <= ''; ch = getchar())

        i = (i << ) + (i << ) + (ch - '');

    return i * f;

}

inline void wr(int x){

    if(x < ) putchar('-'), x = -x;

    if(x > ) wr(x / );

    putchar(x %  + '');

}

int main(){

    n = read(), m = read(), offset =  * n + ;

    for(int i = ; i < n; i++){

        int x = read(), y = read();

        addEdge(x, y);

    }

    dfs(, );

    for(int i = ; i <= n; i++) w[i] = read();

    for(int i = ; i <= m; i++){

        int s = read(), t = read(), lca = getLca(s, t);

        tag[s].push_back(node(dep[s], ));

        tag[t].push_back(node(dep[s] -  * dep[lca] + offset, ));

        tag[fa[lca][]].push_back(node(dep[s], -));

        tag[lca].push_back(node(dep[s] -  * dep[lca] + offset, -));

    }

    solve();

    for(int i = ; i <= n; i++) wr(ans[i]), putchar(' ');

    return ;

}

#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<string>

#include<algorithm>

#include<vector>

using namespace std;

const int N = 1e6 + ;

int n, m, a[N], f[N], s[N], t[N], d[N], ans;

inline int read(){

    int i = , f = ; char ch = getchar();

    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());

    if(ch == '-') f = -, ch = getchar();

    for(; ch >= '' && ch <= ''; ch = getchar())

        i = (i << ) + (i << ) + (ch - '');

    return i * f;

}

inline void wr(int x){

    if(x < ) putchar('-'), x = -x;

    if(x > ) wr(x / );

    putchar(x %  + '');

}

inline bool check(int mid){

    int sum = ;

    memset(f, , sizeof f);

    for(int i = ; i <= mid; i++)

        f[s[i]] += d[i], f[t[i] + ] -= d[i];

    for(int i = ; i <= n; i++){

        sum += f[i];

        if(sum > a[i]) return false;

    }

    return true;

}

int main(){

    n = read(), m = read();

    for(int i = ; i <= n; i++) a[i] = read();

    for(int i = ; i <= m; i++) d[i] = read(), s[i] = read(), t[i] = read();

    int l = , r = m;

    while(l <= r){

        int mid = l + r >> ;

        if(check(mid)) l = mid + ;

        else ans = mid, r = mid - ;

    }

    if(ans == ) putchar('');

    else{

        wr(-), putchar('\n');

        wr(ans);

    }

    return ;

}

#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<string>

#include<cmath>

#include<algorithm>

using namespace std;

const int N = 1e6 + , oo = 0x3f3f3f3f;

int n, m, minn[N * ], a[N], tag[N * ];

inline int read(){

    int i = , f = ; char ch = getchar();

    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());

    if(ch == '-') f = -, ch = getchar();

    for(; ch >= '' && ch <= ''; ch = getchar())

        i = (i << ) + (i << ) + (ch - '');

    return i * f;

}

inline void wr(int x){

    if(x < ) putchar('-'), x = -x;

    if(x > ) wr(x / );

    putchar(x %  + '');

}

inline void build(int k, int l, int r){

    if(l == r){

        minn[k] = a[l];

        return;

    }

    int mid = l + r >> , lc = k << , rc = k <<  | ;

    build(lc, l, mid);

    build(rc, mid + , r);

    minn[k] = min(minn[lc], minn[rc]);

}

inline void minuss(int k, int v){

    minn[k] -= v;

    tag[k] += v;

}

inline void pushDown(int k){

    if(tag[k]){

        if(minn[k << ] != -) minuss(k << , tag[k]);

        if(minn[k <<  | ] != -) minuss(k <<  | , tag[k]);

        tag[k] = ;

    }

}

inline void modify(int k, int l, int r, int x, int y, int v){

    if(x <= l && r <= y){

        minuss(k, v);

        return;

    }

    pushDown(k);

    int mid = l + r >> , lc = k << , rc = k <<  | , ret = oo;

    if(x <= mid) modify(lc, l, mid, x, y, v);

    if(y > mid) modify(rc, mid + , r, x, y, v);

    minn[k] = min(minn[lc], minn[rc]);

}

inline int query(int k, int l, int r, int x, int y){

    if(x <= l && r <= y) return minn[k];

    pushDown(k);

    int mid = l + r >> , lc = k << , rc = k <<  | , ret = oo;

    if(x <= mid) ret = min(ret, query(lc, l, mid, x, y));

    if(y > mid) ret = min(ret, query(rc, mid + , r, x, y));

    return ret;

}

int main(){

    n = read(), m = read();

    for(int i = ; i <= n; i++) a[i] = read();

    memset(minn, -, sizeof tag);

    build(, , n);

    for(int i = ; i <= m; i++){

        int d = read(), s = read(), t = read();

        if(s > t) swap(s, t);

//        cout<<s<<" "<<t<<" "<<query(1, 1, n, s, t)<<"!!!"<<endl;

        if(query(, , n, s, t) < d){

            wr(-), putchar('\n'), wr(i);

            return ;

        }

        modify(, , n, s, t, d);

    }

    wr();

    return ;

}

#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<string>

#include<algorithm>

#include<cmath>

using namespace std;

const int N = 1e5 + ;

int n, ans, last;

int main(){

    cin >> n;

    for(int i = ; i <= n; i++){

        int tmp; cin >> tmp;

        if(tmp - last > ) ans += tmp - last;

        last = tmp;

    }

    cout << ans;

    return ;

}

#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<string>

#include<algorithm>

#include<cmath>

using namespace std;

int klen, slen, key[];

char k[], s[], t[];

int main(){

    cin >> k >> s;

    klen = strlen(k), slen = strlen(s);

    for(int i = ; i < klen; i++){

        if('a' <= k[i] && k[i] <= 'z')

            key[i] = k[i] - 'a';

        else key[i] = k[i] - 'A';

    }

    for(int i = ; i < slen; i++){

        if('a' <= s[i] && s[i] <= 'z'){

            t[i] = s[i] - key[i % (klen)];

            while(t[i] < 'a') t[i] += ;

        }

        else if('A' <= s[i] && s[i] <= 'Z'){

            t[i] = s[i] - key[i % (klen)];

            while(t[i] < 'A') t[i] += ;

        }

        else continue;

        putchar(t[i]);

    }

    return ;

}

#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<cstring>

#include<string>

#include<algorithm>

#include<cmath>

using namespace std;

const int N = 1e5 + , H = 1e6 + ;

int n, h[N], f[N], g[N], maxh, maxxF[H], maxxG[H], ans;

inline int read(){

    int i = , f = ; char ch = getchar();

    for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());

    if(ch == '-') f = -, ch = getchar();

    for(; ch >= '' && ch <= ''; ch = getchar())

        i = (i << ) + (i << ) + (ch - '');

    return i * f;

}

inline void wr(int x){

    if(x < ) putchar('-'), x = -x;

    if(x > ) wr(x / );

    putchar(x %  + '');

}

inline void uptF(int x, int v){

    for(int i = x; i <= maxh; i += (i&(-i)))

        maxxF[i] = max(maxxF[i], v);

}

inline void uptG(int x, int v){

    for(int i = x; i <= maxh; i += (i&(-i)))

        maxxG[i] = max(maxxG[i], v);

}

inline int queryF(int x){

    int ret = ;

    for(int i = x; i > ; i-=(i&-i))

        ret = max(maxxF[i], ret);

    return ret;

}

inline int queryG(int x){

    int ret = ;

    for(int i = x; i > ; i-=(i&-i))

        ret = max(ret, maxxG[i]);

    return ret;

}

int main(){

    n = read();

    for(int i = ; i <= n; i++) h[i] = read() + , maxh = max(maxh, h[i]);

    maxh += ;

    for(int i = ; i <= n; i++){

        f[i] = max(queryG(h[i] - ) + , f[i]);

        g[i] = max(queryF(maxh - h[i] - ) + , g[i]);

        uptF(maxh - h[i], f[i]);

        uptG(h[i], g[i]);

        ans = max(ans, max(f[i], g[i]));

    }

    wr(ans);

    return ;

}