#include <iostream>
#include <vector>
#include <functional>
#include <set>
#include <algorithm>
void printNewLine(){std::cout << "\n";}
template<typename T, typename... Ts>
std::tuple<Ts...> tail(std::tuple<T,Ts...> as){
return std::apply([](T &a, Ts... b){return std::make_tuple(b...);},as);
}
template<typename T>
void print(T a){std::cout << a;}
template<typename T, typename Ts>
void print(std::tuple<T,Ts> a){
print(std::get<0>(a));
print(" ");
print(std::get<1>(a));
}
template<typename T, typename... Ts>
void print(std::tuple<T,Ts...> a){
print(std::get<0>(a));
print(" ");
print(tail(a));
}
template<typename T>
void println(T a){print(a);printNewLine();}
template<typename T>
void printVec(std::vector<T> arr, int width = -1){
if (width == -1) width = arr.size();
for (int i = 0; i < (int)arr.size(); i++){
if ((i%width) == width-1){
print(" ");
println(arr[i]);
}else if ((i%width) == 0){
print(arr[i]);
}else {
print(" ");
print(arr[i]);
}
}
}
std::tuple<int> readInt1(){
int a;
std::cin >> a;
return {a};
}
std::tuple<int,int> readInt2(){
int a, b;
std::cin >> a >> b;
return {a,b};
}
std::tuple<int,int,int> readInt3(){
int a, b, c;
std::cin >> a >> b >> c;
return {a,b,c};
}
std::vector<int> readVecInt(int n){
std::vector<int> arr(n);
for (int i = 0; i < n; i++){
int a;
std::cin >> a;
arr[i] = a;
}
return arr;
}
std::vector<std::tuple<int,int>> readVecTup2(int n){
std::vector<std::tuple<int,int>> arr(n);
for (int i = 0; i < n; i++){
int a, b;
std::cin >> a;
std::cin >> b;
arr[i] = {a,b};
}
return arr;
}
std::vector<std::tuple<int,int,int>> readVecTup3(int n){
std::vector<std::tuple<int,int,int>> arr(n);
for (int i = 0; i < n; i++){
int a, b, c;
std::cin >> a;
std::cin >> b;
std::cin >> c;
arr[i] = {a,b,c};
}
return arr;
}
template<typename T>
void sortBy(std::vector<T> &arr){
std::sort(arr.begin(),arr.end(),[](const T &a, const T &b){ return a < b; });
}
template<typename T>
T binarySearch(T min, T max, std::function<bool(T)> leq){
if (min == max) return max;
T guess = (min+max)/2;
if (leq(guess)){
return binarySearch(min,guess,leq);
}else{
return binarySearch(guess+1,max,leq);
}
}
template<typename T>
T binarySearchDecending(T min, T max, std::function<bool(T)> leq){
std::function<bool(T)> gt = [leq](T x){
return !leq(x);
};
return binarySearch(min,max+1, gt)-1;
}
template<typename T>
double avg(std::vector<T> &arr){
double mult = 1.0/arr.size();
double s = 0;
for (T x : arr){
s += mult*(double)x;
}
return s;
}
template<typename T>
T sum(std::vector<T> &arr){
T s = 0;
for (T x : arr){
s += x;
}
return s;
}
template<typename T>
std::vector<T> cloneVec(std::vector<T> a){
return a;
}
template<typename T>
void extendedFibonachi(std::vector<T> &initial, int nlast, T upto, T mod ){
for (int i = nlast; i <= upto; i++){
initial[i] = 0;
for (int n = 1; n <= nlast && n <= i; n++){
initial[i] += initial[i-n];
initial[i] %=mod;
}
}
}
template<typename T>
std::vector<T> padding(std::vector<T> &initial, T num, int start, int end){
std::vector<T> arr(start+initial.size()+end);
for (int i = 0; i < start; i++){
arr[i] = num;
}
for (int i = 0; i < (int)initial.size(); i++){
arr[start+i] = initial[i];
}
for (int i = 0; i < end; i++){
arr[start+initial.size()+i] = num;
}
return arr;
}
template<typename T>
int findMax(int start, int end, std::function<T(int)> &maxHeuristic){
T initialGuess = maxHeuristic(start);
int index = start;
for (int i = start; i <= end; i++){
if (initialGuess < maxHeuristic(i)){
initialGuess = maxHeuristic(i);
index = i;
}
}
return index;
}
template<typename T>
void operateOnMax(int start, int end, std::function<T(int)> &maxHeuristic, std::function<void(int)> &found){
found(findMax(start,end,maxHeuristic));
}
#include <stack>
template<typename T>
void stackOperate(T init,std::function<std::vector<T>(T)> operate){
std::stack<T> stack;
stack.push(init);
while (!stack.empty()){
T next = stack.top();
stack.pop();
std::vector<T> nextSteps = operate(next);
for (T a : nextSteps){
stack.push(a);
}
}
}
template<typename T>
void recursiveVectorSplit(int start, int end, int distl, int distr, std::function<T(int)> &maxHeuristic, std::function<void(int)> &found){
if (start == end){
return found(start);
}else if (end < start){
return;
}
std::tuple<int,int> range = {start,end};
std::function<std::vector<std::tuple<int,int>>(std::tuple<int,int>)> splitter = [distl, distr,&maxHeuristic,&found](std::tuple<int,int> range){
auto [start,end] = range;
int idx = findMax(start, end, maxHeuristic);
found(idx);
std::vector<std::tuple<int,int>> next;
if (idx+distl+1 <= end){
next.push_back({idx+distl+1,end});
}
if (start <= idx-distr-1){
next.push_back({start, idx-distr-1});
}
return next;
};
stackOperate(range,splitter);
}
void dice(){
auto [n] = readInt1();
std::vector<long long> arr(std::max(7,n+1));
arr[0] = 1;
for (int i = 0; i < 6; i++){
arr[i+1] = 1<<i;
}
extendedFibonachi(arr,6,(long long)n,(long long)1000*1000*1000+7);
println(arr[n]);
}
void cardGame(){
auto [n] = readInt1();
auto arr = readVecInt(n);
arr[0] = 0;
arr[arr.size()-1] = 0;
//printVec(arr);
arr = padding(arr,0,1,1);
//printVec(arr);
std::function<int(int)> heuristic = [&arr](int idx){
return arr[idx]-arr[idx-1]-arr[idx-2]-arr[idx+1]-arr[idx+2];
};
long long sum = 0;
std::function<void(int)> operate = [&arr, &sum](int idx){
arr[idx-2] = 0;
arr[idx-1] = 0;
sum += arr[idx];
arr[idx+1] = 0;
arr[idx+2] = 0;
//printVec(arr);
};
//printVec(arr);
//println(arr[arr.size()-1-2]);
recursiveVectorSplit(2,(int)arr.size()-1-2,2,2,heuristic,operate);
println(sum);
}
void mariocart(){
auto [n,m,k] = readInt3();
auto arr = readVecInt(m);
std::set<int> c;
for (int a : arr){ c.emplace(a);}
int position = 0;
for (int i = 1; i <=k; i++){
if (c.find(position) != c.end()){
position += 2;
} else {
position += 1;
}
position %= n;
}
println(position*100);
}
void continnousSum(){
auto [n] = readInt1();
auto arri = readVecInt(n);
std::vector<long long> arr(n);
for (int idx = 0; idx < (int)arr.size(); idx++){
arr[idx] = arri[idx];
};
//std::function<int(int)> maxFunc = [&arrMax](int idx){
for (int idx = 1; idx < (int)arr.size(); idx++){
arr[idx] = std::max(arr[idx-1]+arr[idx],arr[idx]);
};
long long m = arr[0];
for (long long a : arr){
m = std::max(a,m);
};
println(m);
}
void roulette(){
auto [n] = readInt1();
auto arri = readVecInt(n);
std::vector<long long> arr(n);
for (int idx = 0; idx < (int)arr.size(); idx++){
arr[idx] = arri[idx];
};
std::vector<long long> heur(n);
for (int idx = 0; idx < (int)arr.size(); idx++){
heur[idx] = -arr[(idx-1+n)%n]+arr[idx]-arr[(idx+1)%n];
};
printVec(heur);
}
template<typename T>
std::vector<T> distanceTable(std::vector<T> init, std::function<T(T,T)> distance){
int n = init.size();
std::vector<T> table(n*n);
for (int i = 0; i < n; i++){
table[i+n*i] = init[i];
for (int j = i-1; j >= 0; j--){
table[j+n*i] = distance(init[j],table[j+1+n*i]);
}
for (int j = i+1; j < n; j++){
table[j+n*i] = distance(table[j-1+n*i],init[j]);
}
}
return table;
}
template<typename T, typename N>
std::vector<N> map(std::vector<T> a, std::function<N(T)> transform){
std::vector<N> b(a.size());
int i = 0;
for (T x : a){
b[i] = transform(x);
i++;
}
return b;
}
template<typename T, typename N>
std::vector<N> convertVec(std::vector<T> a){
std::vector<N> b(a.size());
int i = 0;
for (T x : a){
b[i] = x;
i++;
}
return b;
}
template<typename T>
T add(T a,T b){
return a+b;
}
void particles(){
auto [n] = readInt1();
auto arri = convertVec<int,long long>(readVecInt(n));
std::vector<long long> table = distanceTable(arri,(std::function<long long(long long,long long)>)(add<long long>));
printVec(table,n);
//println(cost[n*n-1]);
}
int main() {
//carManufacturing();
//bottle();
//movie();
//cow();
//castle();
//dice();
cardGame();
//mariocart();
//continnousSum();
//roulette();
//particles();
exit(0);
}