Problem: D --Invisible

Problem Statement

You are trying to play a card game called "Invisible" with your friends. This card game uses two types of cards, a "scoring card" and a "jamming card". A positive value is written on each score card. The rules of this card game are as follows.

* The game is played by two players, player 1 and player 2. The game starts on player 1's turn.
* There is one stack and two decks in the field. The stack consists of cards placed by two players. In addition, the deck possessed by each player consists of the score card and the obstruction card possessed by that player. Players can check the order of cards in themselves or in their opponent's deck at any time. There are no cards on the stack at the beginning of the game.
* The two players alternately perform one of the following two actions exactly once.
* Put the top card of your deck on the top of the stack. However, this action cannot be performed when there are no cards in your deck.
* Pass your turn.
* When the player passes the turn, the following processing is performed.
* Each player gets all the scoring cards in the stack that meet the following two conditions. The score card obtained is removed from the field.
1. This is the score card you put on the stack.
2. Above any disturbing cards placed by your opponent (when there are no disturbing cards in your stack, the player gets all the cards he or she puts on the stack).
* Remove all cards in the stack.



If both players pass in succession with no cards on the stack, the game ends. The final score of each player is the sum of the numbers written on the score card obtained by each player.

Each player takes the best action to maximize the value obtained by subtracting the opponent's score from his own score. Your job is to calculate the difference between Player 1's score and Player 2's score when each player behaves optimally for each player's deck given.

Input

The input consists of a single test case of the form:

$ n $ $ m $
$ a_1 $ $ a_2 $ $ \ dots $ $ a_n $
$ b_1 $ $ b_2 $ $ \ dots $ $ b_m $

The first line consists of positive integers $ n $, $ m $ ($ 1 \ le n, m \ le 50 $) representing the number of decks. The second line consists of $ n $ integers, where $ a_i $ represents the $ i $ th card from the top of player 1's deck ($ 1 \ le i \ le n $). $ a_i $ is more than $ 1 $, less than $ 1 {,} 000 {,} 000 $, or $ -1 $. The third line consists of $ m $ integers, where $ b_j $ represents the $ j $ th card from the top of player 2's deck ($ 1 \ le j \ le m $). $ b_j $ is more than $ 1 $, less than $ 1 {,} 000 {,} 000 $, or $ -1 $. When $ a_i $ and $ b_j $ are positive integers, it represents a scoring card, and when it is $ -1 $, it represents a jamming card.

Output

Output (Score of Player 1)-(Score of Player 2) when each player behaves optimally.

Sample Input 1


twenty two
100 -1
200 300

Output for the Sample Input 1


-100

<image>
<image>
<image>


Sample Input 2


3 5
10 30 -1
-1 90 20 10 -1

Output for the Sample Input 2


0

Sample Input 3


4 5
15 20 10 30
50 30 10 20 25

Output for the Sample Input 3


-60





Example

Input

2 2
100 -1
200 300


Output

-100

Solution (in CPP):

Solution:
#include <iostream>
#include <vector>
#include <map>
#include <tuple>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int N;
int M;
ll a[50];
ll asum[50];
ll b[50];
ll bsum[50];
inline ll aget(const int l, const int r)
{
    return (l <= r ? asum[r] - (l == 0 ? 0 : asum[l - 1]) : 0);
}
inline ll bget(const int l, const int r)
{
    return (l <= r ? bsum[r] - (l == 0 ? 0 : bsum[l - 1]) : 0);
}

map<tuple<bool, int, int, int, int, bool>, P> memo;
P dp(const bool Alice, const int l1, const int r1, const int l2, const int r2, const bool passed)
{
    if (memo.find(make_tuple(Alice, l1, r1, l2, r2, passed)) != memo.end()) {
        return memo[make_tuple(Alice, l1, r1, l2, r2, passed)];
    }
    const bool empty = l1 > r1 and l2 > r2;
    P answer;
    if (Alice) {
        if (r1 == N - 1) {
            if (empty and passed) {
                answer = P{0, 0};
            } else {
                const P next = dp(not Alice, r1 + 1, r1, r2 + 1, r2, empty);
                const ll sa = aget(l1, r1);
                const ll sb = bget(l2, r2);
                answer = P{next.first + sa, next.second + sb};
            }
        } else {
            const P next1 = (empty and passed) ? P{0, 0} : dp(not Alice, r1 + 1, r1, r2 + 1, r2, empty);
            const ll sa = aget(l1, r1);
            const ll sb = bget(l2, r2);
            const P ans1 = P{next1.first + sa, next1.second + sb};
            const P ans2 = (a[r1 + 1] == 0) ? dp(not Alice, l1, r1 + 1, r2 + 1, r2, false) : dp(not Alice, l1, r1 + 1, l2, r2, false);
            answer = ans1.first - ans1.second > ans2.first - ans2.second ? ans1 : ans2;
        }
    } else {
        if (r2 == M - 1) {
            if (empty and passed) {
                answer = P{0, 0};
            } else {
                const P next = dp(not Alice, r1 + 1, r1, r2 + 1, r2, empty);
                const ll sa = aget(l1, r1);
                const ll sb = bget(l2, r2);
                answer = P{next.first + sa, next.second + sb};
            }
        } else {
            const P next1 = (empty and passed) ? P{0, 0} : dp(not Alice, r1 + 1, r1, r2 + 1, r2, empty);
            const ll sa = aget(l1, r1);
            const ll sb = bget(l2, r2);
            const P ans1 = P{next1.first + sa, next1.second + sb};
            const P ans2 = (b[r2 + 1] == 0) ? dp(not Alice, r1 + 1, r1, l2, r2 + 1, false) : dp(not Alice, l1, r1, l2, r2 + 1, empty);
            answer = ans1.first - ans1.second < ans2.first - ans2.second ? ans1 : ans2;
        }
    }
    memo[make_tuple(Alice, l1, r1, l2, r2, passed)] = answer;
    return answer;
}

int main()
{
    cin >> N >> M;
    for (int i = 0; i < N; i++) {
        cin >> a[i];
        if (a[i] == -1) {
            a[i] = 0;
        }
    }
    asum[0] = a[0];
    for (int i = 1; i < N; i++) {
        asum[i] = asum[i - 1] + a[i];
    }
    for (int i = 0; i < M; i++) {
        cin >> b[i];
        if (b[i] == -1) {
            b[i] = 0;
        }
    }
    bsum[0] = b[0];
    for (int i = 1; i < M; i++) {
        bsum[i] = bsum[i - 1] + b[i];
    }
    const P ans = dp(true, 0, -1, 0, -1, false);
    cout << ans.first - ans.second << endl;
    return 0;
}