#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;

long long balanceArrayPartition(vector<long long>& weights) {
    int n = weights.size();
    if (n == 0) return 0;
    
    // Separate even and odd indexed elements
    vector<long long> even, odd;
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) even.push_back(weights[i]);
        else odd.push_back(weights[i]);
    }
    
    // Compute all possible subset sums for even and odd
    // For each possible sum s, we want to know if it's achievable
    // and what's the maximum total mass we can get
    
    // Since we want to maximize total mass = sum_even_included + sum_odd_included
    // subject to sum_even_included == sum_odd_included = s
    // Total mass = 2 * s
    // So we want to find the maximum s such that s is achievable as a subset sum
    // of both even and odd arrays.
    
    // Use bitset or unordered_set for subset sums
    // Given constraints, we'll use unordered_set for flexibility
    
    unordered_set<long long> evenSums, oddSums;
    evenSums.insert(0);
    oddSums.insert(0);
    
    for (long long w : even) {
        vector<long long> newSums;
        for (long long s : evenSums) {
            newSums.push_back(s + w);
        }
        for (long long s : newSums) {
            evenSums.insert(s);
        }
    }
    
    for (long long w : odd) {
        vector<long long> newSums;
        for (long long s : oddSums) {
            newSums.push_back(s + w);
        }
        for (long long s : newSums) {
            oddSums.insert(s);
        }
    }
    
    // Find the maximum common sum
    long long maxCommonSum = 0;
    for (long long s : evenSums) {
        if (oddSums.find(s) != oddSums.end()) {
            maxCommonSum = max(maxCommonSum, s);
        }
    }
    
    return 2 * maxCommonSum;
}

int main() {
    int n;
    cin >> n;
    vector<long long> weights(n);
    for (int i = 0; i < n; i++) {
        cin >> weights[i];
    }
    cout << balanceArrayPartition(weights) << endl;
    return 0;
}

import java.util.*;
import java.io.*;

public class Main {
    public static long balanceArrayPartition(long[] weights) {
        int n = weights.length;
        if (n == 0) return 0;
        
        // Separate even and odd indexed elements
        List<Long> even = new ArrayList<>();
        List<Long> odd = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            if (i % 2 == 0) even.add(weights[i]);
            else odd.add(weights[i]);
        }
        
        // Compute all possible subset sums
        Set<Long> evenSums = new HashSet<>();
        Set<Long> oddSums = new HashSet<>();
        evenSums.add(0L);
        oddSums.add(0L);
        
        for (long w : even) {
            Set<Long> newSums = new HashSet<>();
            for (long s : evenSums) {
                newSums.add(s + w);
            }
            evenSums.addAll(newSums);
        }
        
        for (long w : odd) {
            Set<Long> newSums = new HashSet<>();
            for (long s : oddSums) {
                newSums.add(s + w);
            }
            oddSums.addAll(newSums);
        }
        
        // Find the maximum common sum
        long maxCommonSum = 0;
        for (long s : evenSums) {
            if (oddSums.contains(s)) {
                maxCommonSum = Math.max(maxCommonSum, s);
            }
        }
        
        return 2 * maxCommonSum;
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine().trim());
        long[] weights = new long[n];
        String[] parts = br.readLine().trim().split(" ");
        for (int i = 0; i < n; i++) {
            weights[i] = Long.parseLong(parts[i]);
        }
        System.out.println(balanceArrayPartition(weights));
    }
}

def balance_array_partition(weights):
    n = len(weights)
    if n == 0:
        return 0
    
    # Separate even and odd indexed elements
    even = []
    odd = []
    for i in range(n):
        if i % 2 == 0:
            even.append(weights[i])
        else:
            odd.append(weights[i])
    
    # Compute all possible subset sums
    even_sums = {0}
    odd_sums = {0}
    
    for w in even:
        new_sums = set()
        for s in even_sums:
            new_sums.add(s + w)
        even_sums.update(new_sums)
    
    for w in odd:
        new_sums = set()
        for s in odd_sums:
            new_sums.add(s + w)
        odd_sums.update(new_sums)
    
    # Find the maximum common sum
    max_common_sum = 0
    for s in even_sums:
        if s in odd_sums:
            max_common_sum = max(max_common_sum, s)
    
    return 2 * max_common_sum

if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = input().split()
    n = int(data[0])
    weights = list(map(int, data[1:n+1]))
    print(balance_array_partition(weights))

function balanceArrayPartition(weights) {
    const n = weights.length;
    if (n === 0) return 0;
    
    // Separate even and odd indexed elements
    const even = [];
    const odd = [];
    for (let i = 0; i < n; i++) {
        if (i % 2 === 0) even.push(weights[i]);
        else odd.push(weights[i]);
    }
    
    // Compute all possible subset sums
    const evenSums = new Set([0]);
    const oddSums = new Set([0]);
    
    for (const w of even) {
        const newSums = [];
        for (const s of evenSums) {
            newSums.push(s + w);
        }
        for (const s of newSums) {
            evenSums.add(s);
        }
    }
    
    for (const w of odd) {
        const newSums = [];
        for (const s of oddSums) {
            newSums.push(s + w);
        }
        for (const s of newSums) {
            oddSums.add(s);
        }
    }
    
    // Find the maximum common sum
    let maxCommonSum = 0;
    for (const s of evenSums) {
        if (oddSums.has(s)) {
            maxCommonSum = Math.max(maxCommonSum, s);
        }
    }
    
    return 2 * maxCommonSum;
}

// Driver code
const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    terminal: false
});

let lines = [];
rl.on('line', line => lines.push(line));
rl.on('close', () => {
    const n = parseInt(lines[0]);
    const weights = lines[1].split(' ').map(Number);
    console.log(balanceArrayPartition(weights));
});