Alex and Lee continue their games with piles of stones.  There are a number of piles arranged in a row, and each pile has a positive integer number of stones piles[i].  The objective of the game is to end with the most stones. 
Alex and Lee take turns, with Alex starting first.  Initially, M = 1.
On each player's turn, that player can take all the stones in the first X remaining piles, where 1 <= X <= 2M.  Then, we set M = max(M, X).
The game continues until all the stones have been taken.
Assuming Alex and Lee play optimally, return the maximum number of stones Alex can get.
 
Example 1:
Input: piles = [2,7,9,4,4]
Output: 10
Explanation:  If Alex takes one pile at the beginning, Lee takes two piles, then Alex takes 2 piles again. Alex can get 2 + 4 + 4 = 10 piles in total. If Alex takes two piles at the beginning, then Lee can take all three piles left. In this case, Alex get 2 + 7 = 9 piles in total. So we return 10 since it's larger. 

 
Constraints:

1 <= piles.length <= 100
1 <= piles[i] <= 10 ^ 4

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

def _disabled_input(*args, **kwargs):
    raise RuntimeError("input() is disabled in callable mode")
builtins.input = _disabled_input

ns = {"__name__": "__judge__"}  # prevent if __name__ == "__main__" blocks
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "# So the basic idea here is that there is no reason to have separate sum_alex and sum_lee variables, because they both sum up to suffix_sum[pile]\n# Here is an example (X - we haven't desided yet, A - taken by Alex, L - taken by Lee)\n\n# XXXXXXXXXXAALAAALLLAALA\n#           ^\n# \\t\\t  pile\n# From this you can see that in order to calculate the number of piles taken by this player so far we just substract the number of the piles taken by another player from the total number of piles up to the current pile position.\n# The next important thing to notice is that minimizing sum for the one player leads to maximising it for another and vice versa.\n# This leads us to conclusion that we can do the same with just a single variable sum_next_player.\n# The alrorightm now looks the following way:\n\n# We're trying to pick up to 2 * M piles from the current position and pass the turn to the next player\n# We're getting back from the next player the maximum sum they were able to get and trying to minimize it\n# Now when we found the minimum sum for the other player that also means we found the maximum sum for us, so return it\n# That's how we got to the nice and short Top-Down DP solution.\n# The only thing left - convert it to Bottom-Up solution to make the interviewer happy. And here is it\n\nclass Solution:\n    @staticmethod\n    def _suffix_sum(piles: List[int]) -> List[int]:\n        suffix_sum = [0]\n\n        for pile in reversed(piles):\n            suffix_sum.append(suffix_sum[-1] + pile)\n\n        suffix_sum.reverse()\n\n        return suffix_sum\n    \n    def stoneGameII(self, piles: List[int]) -> int:\n        suffix_sum = self._suffix_sum(piles)\n\n        dp = [[0] * (len(piles) + 1) for _ in range(len(piles) + 1)]\n\n        for pile in reversed(range(len(piles))):\n            for M in reversed(range(len(piles))):\n                sum_next_player = suffix_sum[pile]\n\n                for next_pile in range(pile + 1, min(pile + 2 * M + 1, len(piles) + 1)):\n                    sum_next_player = min(\n                        sum_next_player, dp[next_pile][max(M, next_pile - pile)]\n                    )\n\n                sum_player = suffix_sum[pile] - sum_next_player\n\n                dp[pile][M] = sum_player\n\n        return dp[0][1]"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'stoneGameII'
if _fn_name:
    if "Solution" in ns:
        try:
            _obj = ns["Solution"]()
            if hasattr(_obj, _fn_name):
                _target = getattr(_obj, _fn_name)
        except Exception:
            _target = None
    if _target is None and _fn_name in ns and callable(ns[_fn_name]):
        _target = ns[_fn_name]
# Fallback: if there's exactly one user-defined function, use it
if _target is None:
    _cands = [v for k, v in ns.items() if callable(v) and getattr(v, "__module__", "") in ("__judge__", "__main__")]
    _user_funcs = [c for c in _cands if getattr(c, "__name__", "").startswith("_") is False]
    if len(_user_funcs) == 1:
        _target = _user_funcs[0]
if _target is None:
    raise RuntimeError(f"Could not resolve callable '{_fn_name}'")

_raw = sys.stdin.read().strip()
if _raw:
    _parsed = json.loads(_raw)
    if isinstance(_parsed, dict):
        _kwargs = _parsed.get("kwargs", {})
        _args = _parsed.get("args", [])
    else:
        _args, _kwargs = _parsed, {}
else:
    _args, _kwargs = [], {}
if not isinstance(_args, (list, tuple)):
    _args = [_args]
_res = _target(*_args, **_kwargs)
try:
    sys.stdout.write(repr(_res) + "\n")
except Exception:
    pass

```

Measured memory_bytes: 6924