#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <cstdint>

using ull = unsigned long long int;

static const size_t MAX_N = 300 * 1000;

static const ull MOD = 1000 * 1000 * 1000 + 7;
static const ull DOUBLE_MOD = 2 * MOD;

enum class color : uint8_t {
    red,
    black
};

struct tree_node {
    ull key = 0;
    ull value = 0;
    ull sum = 0;
    tree_node* left = nullptr;
    tree_node* right = nullptr;
    color col = color::red;
};

tree_node pool[MAX_N + 100];
size_t nodes_allocated = 0;

tree_node* tree_new_empty() {
    return nullptr;
}

tree_node* tree_node_allocate() {
    return &pool[nodes_allocated++];
}

void tree_node_update_sum(tree_node* t) {
    t->sum = t->value;
    if (t->left) {
        t->sum += t->left->sum;
    }
    if (t->right) {
        t->sum += t->right->sum;
    }
    t->sum %= MOD;
}

tree_node* tree_rotate_left(tree_node* t) {
    tree_node* x = t->right;
    t->right = x->left;
    x->col = t->col;
    t->col = color::red;
    x->left = t;

    tree_node_update_sum(x->left);
    tree_node_update_sum(x);

    return x;
}

tree_node* tree_rotate_right(tree_node* t) {
    tree_node* x = t->left;
    t->left = x->right;
    x->col = t->col;
    t->col = color::red;
    x->right = t;

    tree_node_update_sum(x->right);
    tree_node_update_sum(x);

    return x;
}

void tree_flip_colors(tree_node* t) {
    t->col = (color)(1 - (int)t->col);
    t->left->col = (color)(1 - (int)t->left->col);
    t->right->col = (color)(1 - (int)t->right->col);
}

bool tree_node_is_red(const tree_node* t) {
    return t ? t->col == color::red : false;
}

tree_node* tree_fix_up(tree_node* t) {
    tree_node_update_sum(t);
    if (!tree_node_is_red(t->left) && tree_node_is_red(t->right)) {
        t = tree_rotate_left(t);
    }
    if (tree_node_is_red(t->left) && tree_node_is_red(t->left->left)) {
        t = tree_rotate_right(t);
    }
    if (tree_node_is_red(t->left) && tree_node_is_red(t->right)) {
        tree_flip_colors(t);
    }
    return t;
}

tree_node* tree_add_inner(tree_node* t, ull key, ull value) {
    if (!t) {
        tree_node* ret = tree_node_allocate();
        ret->key = key;
        ret->value = value;
        ret->sum = value;
        return ret;
    }

    if (t->key > key) {
        t->left = tree_add_inner(t->left, key, value);
    } else if (t->key < key) {
        t->right = tree_add_inner(t->right, key, value);
    } else {
        t->value = (t->value + value) % MOD;
        tree_node_update_sum(t);
        return t;
    }

    return tree_fix_up(t);
}

tree_node* tree_add(tree_node* t, ull key, ull value) {
    tree_node* ret = tree_add_inner(t, key, value);
    ret->col = color::black;
    return ret;
}

ull tree_get_sum(tree_node* t) {
    return t ? t->sum : 0;
}

ull tree_get_prefix(tree_node* t, ull before) {
    if (!t) {
        return 0;
    }

    if (t->key >= before) {
        return tree_get_prefix(t->left, before);
    } else {
        return tree_get_sum(t->left) + t->value + tree_get_prefix(t->right, before);
    }
}

void tree_print(tree_node* t, int depth = 0) {
    if (!t) {
        return;
    }

    tree_print(t->left, depth + 1);
    for (int i = 0; i < depth; i++) {
        printf("  ");
    }
    printf("key: %llu, value: %llu, sum: %llu\n", t->key, t->value, t->sum);
    tree_print(t->right, depth + 1);
}

int tree_consistency_check_inner(tree_node* t) {
    if (!t) {
        return 1;
    }

    if (t->col == color::red) {
        assert(!tree_node_is_red(t->left));
    }

    // This is an implementation of 2-3 trees,
    // so the right node MUST be black
    assert(!tree_node_is_red(t->right));

    const int left_blacks = tree_consistency_check_inner(t->left);
    const int right_blacks = tree_consistency_check_inner(t->right);
    assert(left_blacks == right_blacks);
    return left_blacks + (t->col == color::black);
}

void tree_consistency_check(tree_node* t) {
    assert(!tree_node_is_red(t));
    tree_consistency_check_inner(t);
}

void print_nice(tree_node* t, ull shift) {
    if (!t) {
        return;
    }

    print_nice(t->left, shift);
    printf("  %llu: %llu\n", (2 * t->key + shift) % MOD, t->value);
    print_nice(t->right, shift);
}

int main() {
    int n;
    assert(1 == scanf("%d", &n));

    tree_node* evens = tree_new_empty();
    tree_node* odds = tree_new_empty();

    ull shift = 0;

    auto query_wrapping_range = [] (tree_node* t, ull begin, ull end) -> ull {
        // printf("Query range %llu %llu\n", begin, end);
        if (begin < end) {
            return tree_get_prefix(t, end)
                - tree_get_prefix(t, begin);
        } else {
            // ull a = tree_get_sum(t);
            // ull b = tree_get_prefix(t, begin);
            // ull c = tree_get_prefix(t, end);
            // printf("a: %llu, b: %llu, c: %llu\n", a, b, c);
            // return a - b + c;
            return tree_get_sum(t)
                - tree_get_prefix(t, begin)
                + tree_get_prefix(t, end);
        }
    };

    auto count_mopadulos = [&] () {
        // printf("shift: %llu\n", shift);
        ull mopadulos = 0;

        if (shift % 2 == 0) {
            {
                const ull begin = (shift / 2) % MOD;
                const ull end = (begin + (MOD / 2 + 1)) % MOD;
                mopadulos += query_wrapping_range(evens, begin, end);
            }
            {
                const ull begin = (shift / 2 + MOD / 2) % MOD;
                const ull end = (begin + (MOD / 2 + 1)) % MOD;
                mopadulos += query_wrapping_range(odds, begin, end);
            }
        } else {
            {
                const ull begin = (shift / 2 + 1) % MOD;
                const ull end = (begin + (MOD / 2 + 1)) % MOD;
                mopadulos += query_wrapping_range(odds, begin, end);
            }
            {
                const ull begin = (shift / 2 + MOD / 2) % MOD;
                const ull end = (begin + (MOD / 2 + 1)) % MOD;
                mopadulos += query_wrapping_range(evens, begin, end);
            }
        }

        // {
        //     const ull begin = ((shift + 1) / 2) % MOD;
        //     const ull end = (begin + (MOD / 2 + 1)) % MOD;
        //     mopadulos += query_wrapping_range((shift%2==0) ? evens : odds, begin, end);
        //     // printf("POOF %llu\n", mopadulos);
        // }
    
        // {
        //     const ull begin = ((shift / 2) + (MOD / 2)) % MOD;
        //     const ull end = (begin + (MOD / 2 + 1)) % MOD;
        //     mopadulos += query_wrapping_range((shift%2==0) ? odds : evens, begin, end);
        //     // printf("POOF %llu\n", mopadulos);
        // }
        return mopadulos % MOD;
    };

    // ull sum = 0;

    for (int i = 0; i < n; i++) {
        ull x;
        assert(1 == scanf("%llu", &x));

        // puts("");

        ull mopadulos = 1;
        if (i > 0) {
            mopadulos = count_mopadulos();
            shift = (shift + DOUBLE_MOD - x) % DOUBLE_MOD;
        }

        // printf("i: %d, x: %llu, mopadulos: %llu\n", i, x, mopadulos);
        // printf("Evens:\n");
        // tree_print(evens, 1);
        // printf("Odds:\n");
        // tree_print(odds, 1);

        if (mopadulos > 0) {
            const ull adjusted_x = (shift + x) % DOUBLE_MOD;
            if (adjusted_x % 2 == 0) {
                evens = tree_add(evens, adjusted_x/2, mopadulos);
                // tree_consistency_check(evens);
            } else {
                odds = tree_add(odds, adjusted_x/2, mopadulos);
                // tree_consistency_check(odds);
            }

            // sum = (sum + mopadulos) % MOD;
            // ull calc_sum = (tree_get_sum(evens) + tree_get_sum(odds)) % MOD;
            // if (calc_sum != sum) {
            //     printf("OH NO! Expected %llu, got %llu, step %d\n", sum, calc_sum, i);
            //     return 1;
            // }
        }

        // printf("Shift2: %llu\n", shift);
        // printf("Dump:\n");
        // print_nice(evens, DOUBLE_MOD - shift);
        // print_nice(odds, 2 * DOUBLE_MOD - shift + 1);
    }

    // puts("");

    ull result = count_mopadulos();
    // printf("Evens:\n");
    // tree_print(evens, 1);
    // printf("Odds:\n");
    // tree_print(odds, 1);
    printf("%llu\n", result);

    return 0;
}