OIG XIV - kop

// https://szkopul.edu.pl/problemset/problem/imOmSmDfdk-dlL7rD_ggN1ji/site/?key=statement

#include <bits/stdc++.h>

using namespace std;

#define int long long

constexpr int sizik = 1000 * 1001, INF = INT64_MAX;

#define ar std::array
#define pr std::pair
#define vec std::vector

// #define GARY_DBG

typedef vec<vec<int>> _kra;

int t[sizik], kra[sizik];
int d[4 * sizik], lazy[4 * sizik];
int n;

void build_seg_tree_re(int v, int tl, int tr) {
    if (tl == tr) {
        d[v] = kra[tl];
    } else {
        int tm = (tl + tr) / 2;
        build_seg_tree_re(2 * v, tl, tm);
        build_seg_tree_re(2 * v + 1, tm + 1, tr);
        d[v] = std::min(d[2 * v], d[2 * v + 1]);
    }
}

void build_seg_tree(int v, int tl, int tr) {
    for (int i = tl; i <= 4 * tr; i++) {
        d[i] = INF;
    }

    build_seg_tree_re(v, tl, tr);
}

void push(int v) {
    d[v * 2] += lazy[v];
    lazy[v * 2] += lazy[v];
    d[v * 2 + 1] += lazy[v];
    lazy[v * 2 + 1] += lazy[v];
    lazy[v] = 0;
}

void update(int v, int tl, int tr, int l, int r, int z, bool dbg = false) {
    if (l > r) return;
    if (tl == l && tr == r) {
        d[v] += z;
        lazy[v] += z;
        return;
    }
    push(v);
    int tm = (tl + tr) / 2;
    update(2 * v, tl, tm, l, std::min(r, tm), z);
    update(2 * v + 1, tm + 1, tr, std::max(tm + 1, l), r, z);
    d[v] = std::min(d[2 * v], d[2 * v + 1]);
}

void add_op(int a, int b, int c) {
    if (c == 0) return;
    if (b >= 2 * a - 1) {
        if (a > 1) update(1, 1, n - 1, a - 1, std::min(2 * a - 2, n - 1), c, true);
        if ((b) <= (n - 1)) update(1, 1, n - 1, b, std::min(2 * b, n - 1), -c, true);
    } else {
        if (a > 1) update(1, 1, n - 1, a - 1, b - 1, c, true);
        if ((2 * a - 1) <= (n - 1)) update(1, 1, n - 1, 2 * a - 1, std::min(2 * b, n - 1), -c, true);
    }
}

bool check() {
    return d[1] >= 0;
}

void print_ans() {
    if (check()) {
        std::cout << "TAK\n";
    } else {
        std::cout << "NIE\n";
    }
}

void solve() {
    std::cin >> n;

    for (int i = 1; i <= n; i++) {
        std::cin >> t[i];
    }

    for (int i = 2; i <= n; i++) {
        int p = i >> 1;
        kra[i - 1] = t[i] - t[p];
    }

    int q;
    std::cin >> q;

    if (n == 1) {
        q++;
        for (; q > 0; q--)
            std::cout << "TAK\n";
        return;
    }

    build_seg_tree(1, 1, n - 1);
    print_ans();

    for (; q > 0; q--) {
        int a, b, c;
        std::cin >> a >> b >> c;

        add_op(a, b, c);
        print_ans();
    }
}

int32_t main() {
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}