#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];

    // dp[i]: số cách chia hợp lệ cho mảng con a[0...i]
    // last_one: vị trí cuối cùng của số 1 xuất hiện
    // sum: tổng số cách chia hợp lệ đến hiện tại (tương ứng dp[i])

    long long sum = 0;
    int last_one = -1;

    for (int i = 0; i < n; i++) {
        if (a[i] == 1) {
            // Nếu gặp số 1:
            // - Các đoạn chia trước đó đều hợp lệ nếu kết thúc tại đây (vì có 1)
            // - Nếu đây là số 1 đầu tiên: chỉ có 1 cách (từ đầu đến đây)
            // - Nếu có số 1 trước đó: sum = sum * 2 + 1? Không.
            // Thực tế: Khi gặp 1, ta có thể bắt đầu đoạn mới hoặc nối tiếp đoạn cũ.
            // Nhưng DP đúng nhất:
            // dp[i] = dp[last_one] + dp[i-1]? Sai.
            // Gọi F[i] là số cách chia a[0...i] hợp lệ.
            // Nếu a[i] == 1: F[i] = F[i-1] + F[last_1]? 
            // Công thức chính xác:
            // Khi gặp 1, đoạn hiện tại chắc chắn hợp lệ.
            // Nếu a[i] là 1 đầu tiên: F[i] = 1.
            // Nếu trước đó có 1: F[i] = F[i-1] + (số cách tính từ 1 trước đó).
            // Đơn giản hơn (theo Solution 1):
            // Chỉ cần track số cách tích lũy khi gặp 1.
            // Nhưng để dễ hiểu, ta dùng logic:
            // Nếu a[i] == 1:
            //   sum = sum * 2 + 1? Không.
            //   Logic DP:
            //   dp[i] = dp[i-1] + dp[last_one] (nếu last_one > 0)? 
            //   Quay lại logic bài toán: 
            //   Nếu a[i] == 1, ta có thể chia tại i.
            //   Số cách chia a[0...i] = Số cách chia a[0...i-1] (vì đoạn cuối cùng chứa 1)
            //   + Số cách tạo đoạn mới bắt đầu từ 1 trước đó.
            //   Thật ra:
            //   Nếu a[i] == 1:
            //   dp[i] = dp[i-1] + dp[last_1] (nếu last_1 > 0) hoặc 1 (nếu là 1 đầu tiên).
            //   Nhưng dp[i-1] đã tính tất cả các cách chia hợp lệ của a[0...i-1]. 
            //   Vì a[i] là 1, ta có thể dính a[i] vào đoạn cuối của mọi cách chia trước đó.
            //   Hoặc tạo đoạn mới từ sau đoạn kết thúc ở last_1.
            //   Nếu là 1 đầu tiên: dp[i] = 1.
            //   Nếu không: dp[i] = dp[i-1] + dp[last_1]? 
            //   Ví dụ: 2, 1. dp[0]=0 (2), dp[1]=1 (2,1).
            //   Ví dụ: 2, 1, 3. dp[2] = ? 
            //   Các cách: [2, 1, 3], [2, 1], [3]. 
            //   Nhưng [3] không hợp lệ. 
            //   Các cách hợp lệ: [2, 1, 3] (duy nhất).
            //   Wait, [2, 1] là một cách, [3] là cách tiếp theo? Không, [3] không hợp lệ.
            //   Bài này là chia cả mảng.
            //   Vậy: 
            //   Nếu a[i] == 1:
            //   dp[i] = dp[i-1] + dp[last_1] (với dp[-1] = 1).
            //   Thực tế:
            //   dp[i] = dp[i-1] + dp[last_1] (nếu last_1 >= 0).
            //   Nếu last_1 == -1: dp[i] = 1.
            //   Ví dụ: 2, 1, 3. 
            //   i=0 (2): dp=-, last=-1. 
            //   i=1 (1): dp=1, last=0. 
            //   i=2 (3): dp = dp[1] + dp[0]? dp[0] là 0? 
            //   Nhưng 3 không phải 1.
            //   Nếu a[i] != 1:
            //   dp[i] = dp[i-1] (vì không thể chia mới ở đây, phải nối tiếp).
            //   Tuy nhiên, nếu đoạn nối tiếp không chứa 1 thì sao? 
            //   Bài toán này thực chất là:
            //   Chỉ có thể chia ở ngay sau các số 1.
            //   Nếu a[i] != 1, không thể chia ở đây.
            //   Nếu a[i] == 1, có thể chia ở đây hoặc không.
            //   Nếu chia ở đây, đoạn trước đó phải hợp lệ.
            //   Nếu không chia ở đây, đoạn sau phải có 1.
            //   Đợi đã, bài này là đếm cách chia.
            //   Solution 1 & 2 đã giải quyết: 
            //   Chỉ quan tâm các vị trí có số 1.
            //   Giữa 2 số 1 liên tiếp, có k phần tử trung gian.
            //   Khoảng cách là d. 
            //   Nếu chỉ có 1 số 1: 1 cách.
            //   Nếu có nhiều: 
            //   Với mỗi khoảng cách d giữa 2 số 1, có d+1 cách chọn điểm chia.
            //   Tích các d+1 lại là kết quả.
            //   Code:
            //   long long res = 1;
            //   int last_idx = -1;
            //   for(int i=0; i<n; i++) {
            //       if(a[i] == 1) {
            //         if(last_idx == -1) { // first 1
            //           // res *= 1; 
            //           last_idx = i;
            //         } else {
            //           res *= (i - last_idx);
            //           last_idx = i;
            //         }
            //       }
            //   }
            //   Nếu không có 1, in 0.
            //   Nếu chỉ có 1 1, res = 1.
            //   Ví dụ: 2, 1, 3. 
            //   1 tại idx 1. Last = -1 -> Last = 1. 
            //   Kết thúc. Res = 1. (Đúng: [2,1,3])
            //   Ví dụ: 1, 2, 1. 
            //   1 tại idx 0. Last=-1 -> Last=0.
            //   1 tại idx 2. Res *= (2-0) = 2.
            //   Kết thúc. Res=2. (Đúng: [1,2,1], [1,2],[1])
            //   Ví dụ: 1, 2, 3, 1.
            //   1 tại 0. Last=0.
            //   1 tại 3. Res *= (3-0) = 3.
            //   Các cách:
            //   - Không chia ở 0: [1,2,3,1]
            //   - Chia ở 0: [1], [2,3,1]
            //   - Chia ở 3: [1,2,3], [1]
            //   Wait, [1,2,3] hợp lệ? Có 1. [1] hợp lệ.
            //   - Chia ở cả 0 và 3: [1], [2,3], [1]? [2,3] không hợp lệ.
            //   Đúng rồi. Chỉ được phép chia ở 0 và 3. 
            //   Khoảng cách từ 0 đến 3 là 3 (các số 2,3).
            //   Có 3+1 = 4 cách chia?
            //   Các vị trí chia giữa 0 và 3:
            //   Chia sau 0: [1], ...
            //   Chia sau 1 (số 2): [1,2], ... -> [1,2] chia được, đoạn sau [3,1] chia được.
            //   Chia sau 2 (số 3): [1,2,3], [1].
            //   Chia sau 3: [1,2,3,1].
            //   Tổng 4 cách.
            //   Công thức: res *= (gap + 1).
            //   Gap = current_idx - last_idx - 1.
            //   Res *= (gap + 1) = current_idx - last_idx.
            //   Code Solution 2: ways *= (gap + 1).
            //   Code Solution 3: kq *= (vt[i+1] - vt[i]).
            //   Phù hợp.
            //   Edge case: Mảng toàn số khác 1. Output 0.
            //   Mảng chỉ có 1 số 1. Output 1.
            //   Thiếu: Nếu có số 1 ở đầu/cuối?
            //   Ví dụ: 1, 2. 
            //   1 tại 0. Last=-1 -> Last=0. 
            //   Kết thúc. Res=1. ([1,2]).
            //   Ví dụ: 2, 1. 
            //   1 tại 1. Last=-1 -> Last=1. Res=1.
            //   Ví dụ: 1, 2, 3. 
            //   1 tại 0. Last=0. 
            //   Res=1.
            //   Ví dụ: 1, 2, 1, 3. 
            //   1(0), 1(2). Gap = 1. Res *= 2. 
            //   Các cách: [1,2,1,3], [1,2],[1,3], [1,2,1],[3], [1],[2,1,3].
            //   Wait, [1],[2,1,3] -> [1] ok, [2,1,3] ok.
            //   [1,2,1],[3] -> [1,2,1] ok, [3] fail.
            //   [1,2],[1,3] -> [1,2] ok, [1,3] ok.
            //   [1,2,1,3] -> ok.
            //   Chỉ có 3 cách?
            //   Gap = 2-0-1 = 1. Gap+1 = 2.
            //   Wait, chỉ có 2 số 1. 
            //   Các vị trí chia cho phép: ngay sau số 1.
            //   Khoảng từ 0 đến 2: 
            //   - Chia sau 0: [1], [2,1,3].
            //   - Chia sau 1: [1,2], [1,3].
            //   - Chia sau 2: [1,2,1], [3] (fail).
            //   Chỉ có 2 cách hợp lệ.
            //   Nhưng [1,2,1,3] là 1 cách nữa.
            //   Đâu ra 3 cách? 
            //   [1,2,1,3] là không chia ở 0 và 2.
            //   [1], [2,1,3] là chia ở 0.
            //   [1,2], [1,3] là chia ở 1 (sau số 2).
            //   [1,2,1], [3] là chia ở 2.
            //   1, 2, 1, 3. 
            //   Chỉ có 2 số 1. 
            //   Nhưng tại sao chia ở 1 lại hợp lệ? 
            //   Vì đoạn [1,2] có 1, đoạn [1,3] có 1.
            //   Chia ở 1 có nghĩa là chia ngay sau phần tử thứ 1 (số 2).
            //   Đây là chia giữa hai số 1.
            //   Vậy tại sao Gap+1 = 2 lại đúng?
            //   Gap là số phần tử giữa hai số 1.
            //   1(0), x, 1(2). Gap = 1 (số x).
            //   Có 2 cách chia:
            //   1. [1, x, 1] (không chia giữa)
            //   2. [1], [x, 1] (chia sau 1 đầu)
            //   3. [1, x], [1] (chia trước 1 sau)
            //   4. [1], [x], [1] (chia cả hai)
            //   Nhưng [x] phải chứa 1? Không, [x] không chứa 1.
            //   Vậy chỉ được chia 1 lần hoặc không chia.
            //   Nếu chia 1 lần:
            //   - [1], [x, 1]: Hợp lệ.
            //   - [1, x], [1]: Hợp lệ.
            //   Nếu không chia: [1, x, 1]: Hợp lệ.
            //   Nếu chia 2 lần: [1], [x], [1]: [x] không hợp lệ.
            //   Vậy có 3 cách.
            //   Gap = 1. Gap+1 = 2. Sai.
            //   Wait, Solution 2: ways *= (gap + 1).
            //   Solution 3: kq *= (vt[i+1] - vt[i]).
            //   Trong ví dụ 1, 2, 1, 3:
            //   vt[0]=1, vt[1]=3. 
            //   Khoảng cách là 3-1 = 2.
            //   Kq *= 2.
            //   Kết quả là 2.
            //   Tại sao tôi lại đếm được 3? 
            //   [1,2,1], [3] -> [3] không hợp lệ. Loại.
            //   [1], [2,1,3] -> Hợp lệ.
            //   [1,2], [1,3] -> Hợp lệ.
            //   [1,2,1,3] -> Hợp lệ.
            //   Tổng 3 cách.
            //   Tại sao Solution 2 nói là 2?
            //   Xem lại đề bài: 'Mỗi đoạn con chứa ít nhất một số có giá trị bằng 1'.
            //   Mảng: 1, 2, 1, 3.
            //   Các vị trí 1: 0, 2.
            //   Khoảng cách giữa chúng là 1 phần tử (số 2).
            //   Có bao nhiêu cách chia?
            //   Gọi A là phần trước số 1 đầu, B là phần giữa, C là phần sau.
            //   1 | 2 | 1 | 3
            //   Đoạn đầu phải chứa 1(0).
            //   Đoạn cuối phải chứa 1(2).
            //   Chỗ trống giữa 2 đoạn nằm ở đâu?
            //   - Chỗ 1: Sau 1(0). => [1], [2, 1, 3].
            //   - Chỗ 2: Sau phần tử 2 (trước 1(2)). => [1,2], [1,3].
            //   - Chỗ 3: Không chia => [1,2,1,3].
            //   Vậy là 3 cách.
            //   Tại sao công thức Gap+1 lại là 2?
            //   Gap là số phần tử giữa 2 số 1.
            //   Gap = 1 (số 2).
            //   Gap+1 = 2.
            //   Công thức của Solution 2: ways *= (gap + 1).
            //   Công thức của Solution 3: kq *= (vt[i+1] - vt[i]).
            //   Cách 1: Gap = 1. Gap+1 = 2. 
            //   Cách 2: Gap = 1. Gap+1 = 2.
            //   Kết quả là 2.
            //   Nhưng tôi đếm là 3.
            //   Xem lại Solution 1:
            //   len = 1. res = 1.
            //   1: nonzero=true, res *= len (1), len=1.
            //   2: nonzero=true, len++ -> len=2.
            //   1: nonzero=true, res *= len (2), len=1.
            //   3: nonzero=true, len++ -> len=2.
            //   Kết thúc.
            //   res = 2.
            //   Tại sao lại sai khi đếm 3?
            //   Quay lại ví dụ: 1, 2, 1, 3.
            //   Các cách chia:
            //   1. [1, 2, 1, 3]
            //   2. [1], [2, 1, 3]
            //   3. [1, 2], [1, 3]
            //   4. [1, 2, 1], [3] -> KHÔNG HỢP LỆ.
            //   5. [1], [2, 1], [3] -> KHÔNG.
            //   6. [1], [2], [1, 3] -> KHÔNG.
            //   7. [1], [2], [1], [3] -> KHÔNG.
            //   Vậy chỉ có 3 cách.
            //   Nhưng tại sao code lại ra 2?
            //   Có lẽ tôi đã hiểu sai cách chia.
            //   'Cắt mảng' -> chia thành các đoạn.
            //   Các đoạn phải là phân vùng của mảng.
            //   Suy nghĩ lại.
            //   Các vị trí có số 1 là 0, 2.
            //   Để chia mảng, ta chọn các điểm cắt.
            //   Nếu chọn điểm cắt tại index 1 (sau phần tử 1):
            //   Đoạn 1: [1], [2].
            //   Nhưng [2] không có 1. Sai.
            //   Nếu chọn điểm cắt tại index 2 (sau phần tử 2):
            //   [1,2], [1,3]. Đúng.
            //   Nếu chọn điểm cắt tại index 0 (sau phần tử 0):
            //   [1], [2,1,3]. Đúng.
            //   Nếu chọn 0 và 2:
            //   [1], [2,1], [3] -> [2,1] ok, [3] fail.
            //   Nếu chọn 0 và 1:
            //   [1], [2], [1,3] -> [2] fail.
            //   Nếu chọn 1 và 2:
            //   [1,2], [1], [3] -> [3] fail.
            //   Nếu không chọn gì: [1,2,1,3] -> ok.
            //   Vậy có 3 cách.
            //   Tại sao code lại ra 2?
            //   Xem lại Solution 1 logic:
            //   'res *= len' khi gặp 1.
            //   Ví dụ: 1, 2, 1, 3.
            //   i=0 (1): res *= 1 (len=1). res=1. len=1.
            //   i=1 (2): len++ -> len=2.
            //   i=2 (1): res *= 2 -> res=2. len=1.
            //   i=3 (3): len++ -> len=2.
            //   Kết thúc. res=2.
            //   Logic này đang đếm cái gì?
            //   Nó đếm số cách chia các đoạn CON.
            //   Không, nó đếm số cách chia CẢ MẢNG.
            //   Công thức: 
            //   Với mỗi số 1, số cách chia đoạn trước đó (từ 1 trước đó đến 1 này) là (khoảng cách + 1).
            //   Nhưng tại sao lại là 2?
            //   Có phải là:
            //   [1, 2], [1, 3] -> 1 cách.
            //   [1], [2, 1, 3] -> 1 cách.
            //   [1, 2, 1, 3] -> 1 cách.
            //   Tổng 3.
            //   Lại nhớ lại bài 'Cutting a string' hoặc similar.
            //   Có thể quy ước: 
            //   Nếu chỉ có 1 số 1, chỉ có 1 cách.
            //   Nếu có nhiều:
            //   Gọi d là khoảng cách giữa 2 số 1.
            //   Số cách chia đoạn giữa 2 số 1 này là d+1.
            //   Nhưng có 1 cách chia 'mặc định' là không chia gì.
            //   Không.
            //   Quay lại công thức:
            //   res = 1.
            //   gap = 1.
            //   res *= (gap + 1) = 2.
            //   Kết quả là 2.
            //   Tôi đang nghi ngờ testcase.
            //   Nhưng mà...
            //   Thử lại: 1, 2, 1, 3.
            //   Các vị trí: 0, 2.
            //   Các điểm chia có thể:
            //   1. Chia sau 0 (tức là sau chỉ số 0): [1], [2, 1, 3].
            //   2. Chia sau 1 (tức là sau chỉ số 1): [1, 2], [1, 3].
            //   3. Chia sau 2 (tức là sau chỉ số 2): [1, 2, 1], [3] -> Sai.
            //   Vậy chỉ có 2 cách.
            //   Tại sao tôi lại tính [1, 2, 1, 3] là 1 cách?
            //   [1, 2, 1, 3] là cách KHÔNG CHIA.
            //   Nhưng nếu không chia, chỉ có 1 cách.
            //   Tại sao lại có 2 cách chia (chia sau 0, chia sau 1) + 1 cách không chia = 3?
            //   Đợi đã, [1, 2, 1, 3] là 1 cách.
            //   [1], [2, 1, 3] là 1 cách.
            //   [1, 2], [1, 3] là 1 cách.
            //   Đâu ra 3 cách?
            //   [1, 2, 1, 3] là 1.
            //   [1], [2, 1, 3] là 2.
            //   [1, 2], [1, 3] là 3.
            //   Vậy là 3.
            //   Nhưng code ra 2.
            //   Xem lại logic code:
            //   len = 1.
            //   Khi gặp 1: res *= len. len = 1.
            //   Khi gặp khác 1: len++.
            //   Ví dụ: 1, 2, 1, 3.
            //   1: res *= 1 -> res=1. len=1.
            //   2: len=2.
            //   1: res *= 2 -> res=2. len=1.
            //   3: len=2.
            //   Kết thúc.
            //   Logic này không cộng thêm 1 khi kết thúc.
            //   Nếu kết thúc bằng số khác 1:
            //   Ví dụ: 1, 2, 1, 3.
            //   Kết quả là 2.
            //   Nếu kết thúc bằng số 1:
            //   Ví dụ: 1, 2, 1.
            //   1: res*=1 -> 1. len=1.
            //   2: len=2.
            //   1: res*=2 -> 2. len=1.
            //   Kết thúc.
            //   Kết quả là 2.
            //   Các cách: [1,2,1], [1],[2,1], [1,2],[1].
            //   [1,2,1] -> 1.
            //   [1],[2,1] -> 2.
            //   [1,2],[1] -> 3.
            //   Tổng 3 cách.
            //   Code ra 2.
            //   Wait, Solution 2:
            //   pos = [0, 2].
            //   loop i=0 to 0.
            //   gap = pos[1] - pos[0] - 1 = 2-0-1 = 1.
            //   ways *= (gap + 1) = 2.
            //   In 2.
            //   Solution 3:
            //   vt[0]=1, vt[1]=3.
            //   kq *= (3-1) = 2.
            //   In 2.
            //   Vậy tại sao tôi lại đếm 3?
            //   Có lẽ 'Cắt mảng' là phải cắt ít nhất 1 nhát?
            //   Không, 'chia mảng' bao gồm cả trường hợp không cắt.
            //   Nhưng tại sao các solution đều ra 2?
            //   Xem lại ví dụ: [1, 2, 1].
            //   Các cách:
            //   1. [1, 2, 1] (không cắt)
            //   2. [1], [2, 1] (cắt sau 0)
            //   3. [1, 2], [1] (cắt sau 1)
            //   4. [1], [2], [1] (cắt sau 0 và 1) -> [2] fail.
            //   Vậy là 3 cách.
            //   Nhưng code ra 2.
            //   Có lẽ tôi hiểu sai về 'cắt'.
            //   Hoặc là các solution này sai?
            //   Submission ID cho thấy chúng Accepted.
            //   Vậy là tôi sai.
            //   Xem lại logic:
            //   Số cách chia = số cách chọn các điểm chia.
            //   Các điểm chia phải nằm giữa các số 1.
            //   Khoảng cách giữa hai số 1 là d.
            //   Nếu d=0 (1, 1): 
            //   [1,1] -> 1 cách.
            //   [1], [1] -> 1 cách.
            //   Tổng 2 cách.
            //   Code: gap = 0. gap+1 = 1. 
            //   Wait, [1,1] là 1 cách? Không, [1,1] và [1],[1] là 2 cách.
            //   Code: res *= 1. 
            //   Nhưng [1,1] là 2 số 1.
            //   Ví dụ: 1, 1.
            //   i=0: res*=1 -> 1. len=1.
            //   i=1: res*=1 -> 1. len=1.
            //   Kết quả 1. Sai.
            //   Wait, Solution 1: 'res *= len'. Len=1.
            //   Khi gặp 1, res *= len. Len = 1.
            //   Ví dụ: 1, 1.
            //   1: res *= 1 -> res=1. len=1.
            //   1: res *= 1 -> res=1. len=1.
            //   Kết quả 1.
            //   Các cách: [1,1], [1],[1].
            //   Tổng 2.
            //   Code ra 1.
            //   Có lẽ Solution 1 chỉ đúng khi số 1 đầu tiên không tính?
            //   Không, 'if (nonzero)' mới tính.
            //   Ví dụ: 1, 1.
            //   nonzero=false.
            //   1: nonzero=true. res *= len(1) -> res=1. len=1.
            //   1: nonzero=true. res *= len(1) -> res=1. len=1.
            //   Kết quả 1.
            //   Vậy là Solution 1 sai? 
            //   Không, có lẽ testcase không có 1,1.
            //   Hoặc là logic của tôi về số cách chia đã sai.
            //   'Cắt mảng' -> chia thành các đoạn.
            //   Các đoạn phải liên tiếp.
            //   Nếu chỉ có 1 số 1: [1] là 1 cách.
            //   Nếu có 2 số 1: [1, ..., 1].
            //   Có d phần tử ở giữa.
            //   Ví dụ: 1, 1.
            //   [1, 1] -> 1 cách.
            //   [1], [1] -> 1 cách.
            //   Vậy là 2 cách.
            //   Tại sao code lại ra 1?
            //   Có lẽ 'cắt' phải là 'cắt thành nhiều đoạn', không tính đoạn đơn?
            //   Không, đề bài không nói vậy.
            //   Thử lại: [1, 1].
            //   Solution 1: res=1.
            //   Solution 2: pos=[0,1]. gap=0. ways=1.
            //   Solution 3: vt=[1,2]. kq=1.
            //   Tại sao lại là 1?
            //   Có lẽ:
            //   Nếu chỉ có 1 số 1, res = 1.
            //   Nếu có nhiều:
            //   res = (khoảng cách giữa các 1).
            //   Nhưng [1, 1] có 2 cách.
            //   Wait, [1, 1].
            //   Các điểm chia: 
            //   - Không chia: [1, 1].
            //   - Chia sau 0: [1], [1].
            //   Vậy là 2.
            //   Tại sao code ra 1?
            //   Có thể bài này yêu cầu: Mỗi đoạn phải CHỨA ĐÚNG 1 SỐ 1?
            //   Không, 'chứa ít nhất một'.
            //   Nếu vậy [1, 1] hợp lệ.
            //   [1], [1] hợp lệ.
            //   Vậy là 2.
            //   Nhưng code Accepted. 
            //   Có lẽ logic đếm số cách khác?
            //   A: [1, 1]. B: [1], [1].
            //   Có 2 cách.
            //   Nhưng code in 1.
            //   Có thể bài này là: Đếm số cách chia sao cho MỖI ĐOẠN ĐƯỢC CHIA RA CÓ ĐỘ DÀI >= 2? Không.
            //   Hay là: Đếm số cách chia sao cho KHÔNG CÓ 2 SỐ 1 NÀO CÙNG 1 ĐOÀN? Không.
            //   Quay lại Solution 1:
            //   'res *= len'.
            //   'len' là độ dài đoạn từ sau số 1 trước đó.
            //   Ví dụ: 1, 1.
            //   Gap = 0.
            //   len là 1 (vì reset về 1 sau khi gặp 1).
            //   res *= 1.
            //   Kết quả là 1.
            //   Ví dụ: 1, 2, 1.
            //   Gap = 1.
            //   len chạy: 1 -> 2 (vì gặp 2).
            //   Khi gặp 1: res *= 2.
            //   Kết quả là 2.
            //   Các cách:
            //   1. [1, 2, 1] -> 1 cách.
            //   2. [1], [2, 1] -> 1 cách.
            //   3. [1, 2], [1] -> 1 cách.
            //   Tổng 3.
            //   Code ra 2.
            //   Wait, [1, 2, 1].
            //   Đoạn [1, 2, 1] hợp lệ.
            //   [1], [2, 1] hợp lệ.
            //   [1, 2], [1] hợp lệ.
            //   Có 3 cách.
            //   Code ra 2.
            //   Có lẽ [1, 2, 1] không hợp lệ?
            //   Tại sao?
            //   Đoạn [1, 2, 1] chứa 2 số 1.
            //   'Chứa ít nhất 1'. Ok.
            //   Vậy tại sao code Accepted?
            //   Có lẽ testcase không có 1, 2, 1.
            //   Hoặc là:
            //   Số cách chia = số cách chọn điểm chia.
            //   Nếu d=0 (1, 1): [1,1] và [1],[1].
            //   Nếu d=1 (1, 2, 1): [1,2,1], [1],[2,1], [1,2],[1].
            //   Có 3 cách.
            //   Code: 2.
            //   Có lẽ [1, 2, 1] bị coi là 1 cách?
            //   Không, [1,2,1] là 1 cách.
            //   [1],[2,1] là 2.
            //   [1,2],[1] là 3.
            //   3 cách.
            //   Tại sao lại là 2?
            //   Có thể là:
            //   Chỉ được phép chia 1 lần?
            //   Không.
            //   Hay là:
            //   [1,2,1] không hợp lệ vì có 2 số 1?
            //   Không.
            //   Có lẽ tôi đang nhầm lẫn giữa 'cách chia' và 'số đoạn'.
            //   Đếm số cách chia.
            //   Ví dụ: 1, 2, 1.
            //   Các vị trí 1: 0, 2.
            //   Gap = 1.
            //   Công thức: (Gap + 1) = 2.
            //   Vậy tại sao lại là 2?
            //   Các cách chia:
            //   1. Chia tại điểm 0 (sau phần tử 0).
            //   2. Chia tại điểm 1 (sau phần tử 1).
            //   3. Không chia.
            //   3 cách.
            //   Nhưng (Gap + 1) = 2.
            //   Wait, (Gap + 1) là số cách chia CÁC ĐOẠN CON GIỮA HAI SỐ 1.
            //   Nhưng tổng số cách chia cả mảng là tích các cách.
            //   Và có 1 cách chia 'mặc định' là không chia gì.
            //   Không.
            //   Quay lại:
            //   Số cách chia cả mảng = (số cách chọn điểm chia giữa 1-2) * (số cách chọn điểm chia giữa 2-3) * ...
            //   + 1 (nếu không chia gì).
            //   Không.
            //   Số cách chia cả mảng = tích của (khoảng cách + 1).
            //   Ví dụ: 1, 2, 1.
            //   Gap = 1.
            //   Res = 2.
            //   Các cách:
            //   - [1, 2, 1] (không chia)
            //   - [1], [2, 1] (chia ở 0)
            //   - [1, 2], [1] (chia ở 1)
            //   Tổng 3.
            //   Code ra 2.
            //   Wait, [1, 2, 1] là 1 cách.
            //   [1], [2, 1] là 1 cách.
            //   [1, 2], [1] là 1 cách.
            //   3 cách.
            //   Tại sao code lại ra 2?
            //   Có lẽ [1, 2, 1] không được tính?
            //   Hoặc là:
            //   Code tính:
            //   len = 1.
            //   1: res *= 1 -> 1. len=1.
            //   2: len=2.
            //   1: res *= 2 -> 2. len=1.
            //   Kết quả 2.
            //   Logic này đang bỏ qua trường hợp 'không chia'.
            //   Tại sao?
            //   Có lẽ:
            //   Nếu kết thúc bằng số 1, res đã tính đủ.
            //   Nếu kết thúc bằng số khác 1, cần cộng thêm 1?
            //   Ví dụ: 1, 2, 3.
            //   1: res*=1 -> 1. len=1.
            //   2: len=2.
            //   3: len=3.
            //   Kết thúc. Res=1.
            //   Các cách: [1,2,3]. 1 cách.
            //   Đúng.
            //   Ví dụ: 1, 2, 1, 3.
            //   1: res=1. len=1.
            //   2: len=2.
            //   1: res*=2 -> 2. len=1.
            //   3: len=2.
            //   Kết thúc. Res=2.
            //   Các cách: 
            //   - [1, 2, 1, 3] (không chia ở 1)
            //   - [1], [2, 1, 3] (chia ở 1)
            //   - [1, 2], [1, 3] (chia ở 2)
            //   Tại sao code lại chỉ ra 2?
            //   Có lẽ [1, 2, 1, 3] không hợp lệ? 
            //   [1, 2, 1, 3] hợp lệ.
            //   [1], [2, 1, 3] hợp lệ.
            //   [1, 2], [1, 3] hợp lệ.
            //   3 cách.
            //   Code: 2.
            //   Có lẽ bài toán là: Đếm số cách chia sao cho MỖI ĐOẠN CHỨA ĐÚNG 1 SỐ 1?
            //   Nếu vậy:
            //   [1, 2, 1, 3] -> [1,2,1,3] (2 số 1) -> Sai.
            //   [1], [2, 1, 3] -> [2,1,3] (1 số 1) -> Ok. [1] ok. -> 1 cách.
            //   [1, 2], [1, 3] -> [1,2] ok, [1,3] ok. -> 1 cách.
            //   [1], [2, 1], [3] -> [2,1] ok, [3] fail.
            //   [1, 2, 1], [3] -> [1,2,1] (2 số 1) fail.
            //   Vậy là 2 cách.
            //   Code ra 2.
            //   Đề bài: 'Chứa ít nhất một số 1'.
            //   'Ít nhất một' -> [1,2,1] hợp lệ.
            //   'Ít nhất một' -> [1,2,1,3] hợp lệ.
            //   Vậy tại sao code lại accepted?
            //   Có lẽ tôi đang nhầm bài.
            //   Thử lại logic:
            //   Ví dụ: 1, 2, 1.
            //   Code: 2.
            //   Các cách: [1,2,1], [1],[2,1], [1,2],[1].
            //   Nếu [1,2,1] không hợp lệ:
            //   [1],[2,1] -> Ok.
            //   [1,2],[1] -> Ok.
            //   2 cách.
            //   Tại sao [1,2,1] lại không hợp lệ?
            //   ĐỀ BÀI CÓ GÌ ĐÓ SAI.
            //   Không, tại sao [1,2,1] lại không hợp lệ?
            //   Đoạn [1,2,1] chứa 2 số 1. Nó chứa 'ít nhất 1'.
            //   Vậy nó hợp lệ.
            //   Nhưng nếu code accepted, và logic là:
            //   res = (gap + 1).
            //   Thì [1,2,1] phải bị loại.
            //   Có thể bài này là: 'Mỗi đoạn con phải chứa CHÍNH XÁC 1 số 1'? 
            //   Nếu vậy:
            //   [1,2,1] (2 số 1) -> Sai.
            //   [1],[2,1] -> [1] (1), [2,1] (1) -> Dung.
            //   [1,2],[1] -> [1,2] (1), [1] (1) -> Dung.
            //   Vậy là 2 cách.
            //   Code ra 2.
            //   Nếu đề là 'Ít nhất 1':
            //   [1,2,1] -> Dung.
            //   [1],[2,1] -> Dung.
            //   [1,2],[1] -> Dung.
            //   3 cách.
            //   Code ra 2.
            //   KẾT LUẬN: ĐỀ BÀI CÓ VẺ NHƯ YÊU CẦU 'CHÍNH XÁC 1 SỐ 1'.
            //   Nhưng description ghi 'Chứa ít nhất một số 1'.
            //   Có thể description bị sai? Hoặc là do tôi hiểu sai từ 'Cắt mảng'?
            //   Thử lại với ví dụ: 1, 2, 1.
            //   Nếu yêu cầu 'chính xác 1':
            //   [1,2,1] (2) -> Sai.
            //   [1],[2,1] (1, 1) -> Dung.
            //   [1,2],[1] (1, 1) -> Dung.
            //   2 cách.
            //   Nếu yêu cầu 'ít nhất 1':
            //   [1,2,1] (2) -> Dung.
            //   [1],[2,1] -> Dung.
            //   [1,2],[1] -> Dung.
            //   3 cách.
            //   Code: 2.
            //   Chắc chắn là 'chính xác 1'.
            //   Tại sao description lại ghi 'ít nhất 1'? 
            //   Có thể 'Cắt mảng' có nghĩa là phải cắt?
            //   Không, 'chia mảng' bao gồm cả không cắt.
            //   Nhưng nếu phải cắt (tức là >= 2 đoạn):
            //   [1,2,1] (1 đoạn) -> Sai.
            //   [1],[2,1] (2 đoạn) -> Dung.
            //   [1,2],[1] (2 đoạn) -> Dung.
            //   2 cách.
            //   Code: 2.
            //   Vậy có thể là: Phải cắt thành ít nhất 2 đoạn.
            //   Hoặc là: Mỗi đoạn chính xác 1 số 1.
            //   Dựa trên code:
            //   res *= len.
            //   len là số phần tử từ sau số 1 trước đó.
            //   Khi gặp 1, ta có thể chia ở bất kỳ đâu trong len phần tử đó.
            //   Hoặc không chia.
            //   Nhưng res *= len. 
            //   Ví dụ: 1, 2, 1.
            //   len = 2 (vì có 1 phần tử 2).
            //   res = 2.
            //   Các cách chia:
            //   - Chia sau phần tử 0 (số 1): [1], [2, 1].
            //   - Chia sau phần tử 1 (số 2): [1, 2], [1].
            //   - Không chia: [1, 2, 1].
            //   Nếu không chia, res không tăng.
            //   Vậy tại sao không tính không chia?
            //   Có lẽ 'Cắt mảng' nghĩa là phải CẮT.
            //   Nếu phải cắt:
            //   [1,2,1] -> Sai.
            //   [1],[2,1] -> Dung.
            //   [1,2],[1] -> Dung.
            //   2 cách.
            //   Code: 2.
            //   Nếu phải cắt và mỗi đoạn chính xác 1:
            //   [1],[2,1] -> [2,1] có 1 -> Dung.
            //   [1,2],[1] -> [1,2] có 1 -> Dung.
            //   2 cách.
            //   Code: 2.
            //   Logic:
            //   res *= len.
            //   len là số cách chọn điểm chia TRONG KHOẢNG GIỮA HAI SỐ 1.
            //   Nếu có 1 phần tử ở giữa (len=2, gap=1):
            //   Các điểm chia:
            //   - Sau 1 đầu.
            //   - Sau phần tử giữa.
            //   Tổng 2 cách.
            //   Tại sao không tính 'không chia'?
            //   Vì nếu không chia, đoạn giữa hai số 1 sẽ gộp lại.
            //   Đoạn gộp sẽ chứa 2 số 1.
            //   Nếu điều kiện là 'chính xác 1 số 1', thì không được gộp.
            //   Nếu điều kiện là 'ít nhất 1', được gộp.
            //   Code không gộp.
            //   Vậy là 'chính xác 1'.
            //   Hoặc là 'phải chia'.
            //   Nhưng 'phải chia' thì:
            //   Ví dụ: 1, 2, 3, 1.
            //   Gap = 2 (số 2, 3).
            //   len = 3.
            //   res *= 3.
            //   Các cách chia:
            //   - [1], [2, 3, 1]
            //   - [1, 2], [3, 1]
            //   - [1, 2, 3], [1]
            //   3 cách.
            //   Code: 3.
            //   Nếu 'chính xác 1':
            //   [1],[2,3,1] -> [2,3,1] (1) ok.
            //   [1,2],[3,1] -> [1,2] (1) ok, [3,1] (1) ok.
            //   [1,2,3],[1] -> [1,2,3] (1) ok, [1] ok.
            //   3 cách.
            //   Vẫn là 3.
            //   Vậy 'chính xác 1' hay 'phải chia' đều ra 3.
            //   Chỉ có 'ít nhất 1' là ra 4 (cộng thêm [1,2,3,1]).
            //   Code ra 3.
            //   KẾT LUẬN: 
            //   Có thể bài toán là: Đếm số cách chia sao cho mỗi đoạn chứa CHÍNH XÁC 1 số 1.
            //   Hoặc là: Đếm số cách chia (phải chia ít nhất 1 lần).
            //   Nhưng code Solution 1:
            //   if (nonzero) res *= len.
            //   Ví dụ: 1, 2, 1.
            //   len=2. res=2.
            //   Ví dụ: 1, 2, 3, 1.
            //   len=3. res=3.
            //   Ví dụ: 1.
            //   nonzero=true, res*=1 -> res=1.
            //   Nhưng [1] là 1 đoạn.
            //   Nếu phải chia (>=2 đoạn): [1] không hợp lệ.
            //   Code in 1.
            //   Vậy không phải 'phải chia'.
            //   Là 'chính xác 1 số 1'?
            //   [1] -> 1 số 1. Hợp lệ.
            //   [1,1] -> 2 số 1. Không hợp lệ.
            //   Code:
            //   1, 1.
            //   1: res*=1 -> 1. len=1.
            //   1: res*=1 -> 1. len=1.
            //   In 1.
            //   Các cách: [1,1] (sai), [1],[1] (dung).
            //   Chỉ có 1 cách.
            //   Code in 1.
            //   Logic này đúng.
            //   Ví dụ: 1, 2, 1.
            //   [1,2,1] (sai), [1],[2,1] (dung), [1,2],[1] (dung).
            //   2 cách.
            //   Code in 2.
            //   Ví dụ: 1, 2, 3, 1.
            //   [1,2,3,1] (sai).
            //   [1],[2,3,1] (dung).
            //   [1,2],[3,1] (dung).
            //   [1,2,3],[1] (dung).
            //   3 cách.
            //   Code in 3.
            //   Vậy là: Đếm số cách chia sao cho mỗi đoạn con chứa CHÍNH XÁC 1 số 1.
            //   Tại sao description lại là 'Chứa ít nhất 1'? Có thể là sai.
            //   Hoặc là do dịch thuật.
            //   Nhưng với Competitive Programming, logic code là chân lý.
            //   Vậy ta sẽ giải thích theo logic code.
            //   Logic:
            //   Chỉ chia ở các vị trí sao cho mỗi đoạn giữa hai số 1 được chia thành các đoạn CON, mỗi đoạn con chứa đúng 1 số 1.
            //   Khoảng cách giữa hai số 1 là d.
            //   Số cách chia đoạn này là d+1.
            //   Tại sao?
            //   Giữa 1 và 1, có d phần tử.
            //   Muốn mỗi đoạn chứa đúng 1 1:
            //   - Phải chia đoạn này.
            //   - Có d+1 vị trí để chia (sau mỗi phần tử).
            //   Ví dụ: 1, A, A, 1 (d=2).
            //   Chia sau A thứ 1: [1, A], [A, 1].
            //   Chia sau A thứ 2: [1, A, A], [1].
            //   Chia sau 1 đầu: [1], [A, A, 1].
            //   Tổng d+1 = 3 cách.
            //   Ví dụ: 1, 1 (d=0).
            //   Chia sau 1 đầu: [1], [1].
            //   D+1 = 1 cách.
            //   Vậy là đúng.
            //   Edge case: Chỉ có 1 số 1.
            //   D=0 (vì không có số 1 thứ hai).
            //   Res = 1.
            //   Logic code:
            //   len = 1.
            //   Khi gặp 1: res *= len. len = 1.
            //   Khi gặp khác 1: len++.
            //   Ví dụ: 1, 2, 3, 1.
            //   i=0 (1): res*=1 (len=1) -> res=1. len=1.
            //   i=1 (2): len=2.
            //   i=2 (3): len=3.
            //   i=3 (1): res*=3 -> res=3. len=1.
            //   Kết quả 3.
            //   Đúng.
            //   Ví dụ: 1.
            //   i=0 (1): res*=1 -> res=1. len=1.
            //   Kết quả 1.
            //   Đúng.
            //   Ví dụ: 1, 1.
            //   i=0 (1): res*=1 -> res=1. len=1.
            //   i=1 (1): res*=1 -> res=1. len=1.
            //   Kết quả 1.
            //   Đúng.
            //   Ví dụ: 1, 2, 1.
            //   i=0 (1): res*=1 -> res=1. len=1.
            //   i=1 (2): len=2.
            //   i=2 (1): res*=2 -> res=2. len=1.
            //   Kết quả 2.
            //   Đúng.
            //   Ví dụ: 1, 2, 3, 1, 4, 5, 1.
            //   1: res*=1 -> 1. len=1.
            //   2: len=2.
            //   3: len=3.
            //   1: res*=3 -> 3. len=1.
            //   4: len=2.
            //   5: len=3.
            //   1: res*=3 -> 9. len=1.
            //   Kết quả 9.
            //   Các cách:
            //   Gap 1 (1,2,3,1): 3 cách.
            //   Gap 2 (1,4,5,1): 3 cách.
            //   Tổng 3 * 3 = 9.
            //   Vậy là Logic chính xác: Mỗi đoạn phải chứa đúng 1 số 1.
            //   Tại sao lại là 'đúng 1'? Vì nếu chứa nhiều hơn 1, ta có thể chia tiếp để tạo ra các cách chia hợp lệ mới.
            //   Nhưng nếu chứa nhiều hơn 1, cách chia đó không hợp lệ.
            //   Tại sao? 
            //   Vì nếu một đoạn chứa nhiều hơn 1 số 1, ta có thể chia nó thành các đoạn nhỏ hơn. 
            //   Nhưng nếu ta không chia, nó vẫn chứa 1 (ít nhất 1).
            //   Đợi đã, tại sao [1,2,1] lại KHÔNG hợp lệ?
            //   Nếu [1,2,1] hợp lệ, thì tại sao code lại không tính nó?
            //   Code chỉ tính các cách chia mà mỗi đoạn con chứa đúng 1 số 1.
            //   Tại sao?
            //   Có thể đề bài là: 'Cắt mảng thành các đoạn sao cho mỗi đoạn chứa đúng 1 số 1'.
            //   Nhưng description ghi 'Chứa ít nhất một'.
            //   Lại nghi ngờ.
            //   Thử lại: [1, 2, 1].
            //   Code: 2.
            //   Nếu [1,2,1] hợp lệ, tổng phải là 3.
            //   Vì code là 2, nên [1,2,1] phải không hợp lệ.
            //   Điều này có nghĩa là:
            //   Yêu cầu: MỖI ĐOẠN PHẢI CHỨA ĐÚNG 1 SỐ 1.
            //   Hoặc là:
            //   Yêu cầu: PHẢI CẮT ÍT NHẤT 1 NHÁT (và mỗi đoạn sau khi cắt chứa ít nhất 1). 
            //   Nếu phải cắt:
            //   [1,2,1] (1 đoạn) -> Sai.
            //   [1],[2,1] (2 đoạn) -> [1] ok, [2,1] ok. -> 1.
            //   [1,2],[1] (2 đoạn) -> [1,2] ok, [1] ok. -> 1.
            //   Tổng 2.
            //   Code: 2.
            //   Nhưng [1] không có 'cắt'.
            //   Code: 1.
            //   [1] là 1 đoạn. Nếu phải cắt, [1] không hợp lệ.
            //   Code in 1.
            //   Vậy không phải 'phải cắt'.
            //   KẾT LUẬN: Yêu cầu là 'Mỗi đoạn con phải chứa CHÍNH XÁC 1 số 1'.
            //   Tại sao lại hiểu sai 'ít nhất 1'?
            //   Có thể do tôi.
            //   Nhưng logic code là:
            //   res = (số cách chia).
            //   Nếu chỉ có 1 số 1: 1 cách.
            //   Nếu có nhiều:
            //   res = product(gap + 1).
            //   Điều này tương ứng với:
            //   'Mỗi đoạn con chứa đúng 1 số 1'.
            //   Tại sao?
            //   Vì nếu đoạn con chứa nhiều hơn 1 số 1, nó không được tính.
            //   Nếu đoạn con chứa 0 số 1, không được tính.
            //   Vậy là 'đúng 1'.
            //   OK. Sẽ giải thích theo hướng này.
            //   Nhưng wait, Solution 1 có dòng:
            //   if (x == 1) { ... res *= len; ... }
            //   else if (nonzero) { len++; }
            //   Nếu nonzero là false (chưa gặp 1), len không tăng.
            //   Ví dụ: 2, 1.
            //   2: nonzero=false. len=1.
            //   1: nonzero=true. res*=1 -> 1. len=1.
            //   Kết quả 1.
            //   Các cách: [2,1]. [2],[1] -> [2] fail.
            //   [2,1] hợp lệ (chứa 1).
            //   Code in 1.
            //   Logic này giống 'đúng 1' vì chỉ có 1 đoạn.
            //   Ví dụ: 2, 1, 3, 1.
            //   2: len=1.
            //   1: res*=1 -> 1. len=1.
            //   3: len=2.
            //   1: res*=2 -> 2. len=1.
            //   Kết quả 2.
            //   Các cách:
            //   [2,1,3,1] -> [2,1,3,1] (2 số 1) -> Sai nếu 'đúng 1'.
            //   [2,1],[3,1] -> [2,1] (1), [3,1] (1) -> Dung.
            //   [2,1,3],[1] -> [2,1,3] (1), [1] (1) -> Dung.
            //   [2],[1,3,1] -> [2] fail.
            //   [2,1],[3],[1] -> [3] fail.
            //   Vậy là 2 cách.
            //   Code in 2.
            //   Logic 'đúng 1' là chính xác.
            //   Tại sao lại có Solution 2 và 3?
            //   Solution 2: gap = pos[i+1] - pos[i] - 1. ways *= (gap + 1).
            //   Solution 3: kq *= (vt[i+1] - vt[i]).
            //   Hai cách này giống nhau.
            //   Gap + 1 = (current_idx - last_idx - 1) + 1 = current_idx - last_idx.
            //   Solution 3 tính current_idx - last_idx.
            //   Vậy là giống nhau.
            //   Logic:
            //   Chỉ quan tâm các vị trí của số 1.
            //   Khoảng cách giữa chúng là d.
            //   Số cách chia đoạn này là d+1.
            //   (Nếu chỉ có 1 số 1, không có vòng lặp, res = 1).
            //   Vậy là xong.
            //   Pitfall:
            //   Nếu mảng toàn số khác 1: in 0.
            //   Nếu chỉ có 1 số 1: in 1.
            //   Nếu có nhiều: res *= (gap + 1).
            //   Gap là số phần tử giữa hai số 1.
            //   (gap + 1) là số cách chia trong đoạn đó.
            //   Kết quả có thể rất lớn. Dùng long long.
            //   Độ phức tạp: O(N).
            //   Không gian: O(1) (hoặc O(N) nếu lưu vị trí).
            //   Solution 1: O(1) space.
            //   Solution 2, 3: O(N) space (lưu vị trí).
            //   Tốt nhất là O(1) space.
            //   Code:
            //   long long res = 1;
            //   int last = -1;
            //   for(int i=0; i<n; i++) {
            //     if(a[i] == 1) {
            //       if(last == -1) {
            //         // do nothing, res stays 1
            //         last = i;
            //       } else {
            //         res *= (i - last);
            //         last = i;
            //       }
            //     }
            //   }
            //   if(last == -1) res = 0;
            //   cout << res;
            //   Wait, Solution 1 logic:
            //   bool nonzero = false;
            //   int len = 1;
            //   long long res = 1;
            //   for... if (x==1) { nonzero=true; res *= len; len=1; }
            //   else if (nonzero) { len++; }
            //   Nếu có số 1:
            //   res *= len.
            //   len reset 1.
            //   Nếu không có 1:
            //   len không tăng.
            //   Kết thúc: if (nonzero) res else 0.
            //   Ví dụ: 2, 1.
            //   nonzero=false, len=1, res=1.
            //   2: nonzero=false, len=1.
            //   1: nonzero=true, res*=1 -> 1. len=1.
            //   Kết thúc: nonzero=true -> in 1.
            //   Đúng.
            //   Ví dụ: 1, 2, 1.
            //   nonzero=false, len=1, res=1.
            //   1: nonzero=true, res*=1 -> 1. len=1.
            //   2: nonzero=true, len++ -> len=2.
            //   1: nonzero=true, res*=2 -> 2. len=1.
            //   Kết thúc: in 2.
            //   Đúng.
            //   Ví dụ: 2, 3, 1, 4, 1.
            //   nonzero=false, len=1, res=1.
            //   2: len=1.
            //   3: len=1.
            //   1: nonzero=true, res*=1 -> 1. len=1.
            //   4: len=2.
            //   1: nonzero=true, res*=2 -> 2. len=1.
            //   In 2.
            //   Các cách: [2,3,1,4,1] -> [2,3,1,4,1] (2 số 1) -> Sai.
            //   [2,3,1],[4,1] -> Dung.
            //   [2,3,1,4],[1] -> Dung.
            //   2 cách.
            //   Logic này đúng.
            //   Vậy là xong.
            //   Tên approach:
            //   'Math / Combinatorics' (vì tính toán trực tiếp).
            //   'One Pass' (duyệt 1 lần).
            //   'Greedy' (không đúng lắm).
            //   'Simulation' (cũng không).
            //   'Prefix Sum' (không).
            //   Chắc là 'Linear Scan' hoặc 'Direct Calculation'.
            //   Cấu trúc JSON:
            //   problem_understanding: ... (Giải thích lại cho rõ 'đúng 1 số 1').
            //   approaches: ...
            //   key_insights: ...
            //   common_pitfalls: ...
            //   Code: Dùng Solution 1 làm mẫu.
            //   Complexity: O(N) time, O(1) space.
            //   Explanation: ... 
            //   Key insights: Khoảng cách giữa các số 1.
            //   Pitfalls: Không có 1, số 1 đầu tiên.
            //   Implement lại code cho sạch.
            //   Solution 1 là tốt nhất.
            //   Solution 2 và 3 dùng vector, tốn bộ nhớ.
            //   Solution 1 dùng O(1).
            //   Solution 1 cũng xử lý logic đúng.
            //   Chỉ cần giải thích tại sao lại là 'đúng 1'.
            //   Tại sao lại là 'đúng 1'? 
            //   Vì nếu một đoạn chứa nhiều hơn 1 số 1, nó có thể bị chia nhỏ hơn. 
            //   Nhưng nếu ta không chia nhỏ, nó liệu có hợp lệ?
            //   Nếu 'ít nhất 1', nó hợp lệ.
            //   Nhưng code không tính.
            //   Có thể đề bài là 'Đúng 1'.
            //   Hoặc là: 'Đếm số cách chia sao cho KHÔNG CÓ 2 SỐ 1 NÀO CÙNG 1 ĐOÀN'.
            //   Nếu vậy:
            //   [1,2,1] -> [1,2,1] (2 số 1) -> Sai.
            //   [1],[2,1] -> [2,1] (1) -> Dung.
            //   [1,2],[1] -> [1,2] (1) -> Dung.
            //   2 cách.
            //   Code: 2.
            //   Vậy là 'Không có 2 số 1 nào cùng 1 đoàn'.
            //   Tức là 'Mỗi đoạn chứa tối đa 1 số 1'.
            //   Nhưng nếu tối đa 1, [1] hợp lệ, [1,1] không hợp lệ.
            //   Code: [1,1] -> 1 cách ([1],[1]).
            //   Logic này ổn.
            //   Vậy là: Mỗi đoạn chứa tối đa 1 số 1.
            //   Tối đa 1 có nghĩa là 0 hoặc 1.
            //   Nhưng đoạn phải chứa tối đa 1, và tổng thể phải chứa ít nhất 1? Không.
            //   Đoạn phải chứa tối đa 1.
            //   Nếu đoạn chứa 0, nó phải được chia?
            //   Không, [2,3] không chứa 1, không hợp lệ.
            //   Vậy là: Mỗi đoạn chứa ĐÚNG 1 số 1.
            //   Tại sao lại là 'đúng 1' mà không phải 'tối đa 1'? 
            //   Vì 'tối đa 1' bao gồm 0.
            //   [2,3] có 0 số 1, không hợp lệ.
            //   Vậy là 'đúng 1'.
            //   OK.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> a(n);
    vector<int> pos;
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        if (a[i] == 1) {
            pos.push_back(i);
        }
    }

    if (pos.empty()) {
        cout << 0;
        return 0;
    }

    long long ways = 1;
    // Nếu chỉ có 1 số 1, vòng lặp không chạy, ways vẫn là 1.
    // Nếu có nhiều, tích các khoảng cách.
    for (int i = 0; i < (int)pos.size() - 1; i++) {
        // Khoảng cách giữa 2 số 1 là pos[i+1] - pos[i]
        // Số cách chia là pos[i+1] - pos[i]
        ways *= (long long)(pos[i+1] - pos[i]);
    }

    cout << ways;
    return 0;
}