We want to find the numbers higher or equal than 1000 that the sum of every four consecutives digits cannot be higher than a certain given value.
If the number is ``` num = d1d2d3d4d5d6 ```, and the maximum sum of 4 contiguous digits is ```maxSum```, then:
```python
d1 + d2 + d3 + d4 <= maxSum
d2 + d3 + d4 + d5 <= maxSum
d3 + d4 + d5 + d6 <= maxSum
```
For that purpose, we need to create a function, ```max_sumDig()```, that receives ```nMax```, as the max value of the interval to study (the range (1000, nMax) ), and a certain value, ```maxSum```, the maximum sum that every four consecutive digits should be less or equal to. The function should output the following list with the data detailed bellow:

```[(1), (2), (3)]```

(1) - the amount of numbers that satisfy the constraint presented above 

(2) - the closest number to the mean of the results, if there are more than one, the smallest number should be chosen.

(3) - the total sum of all the found numbers

Let's see a case with all the details:
```
max_sumDig(2000, 3) -------> [11, 1110, 12555]

(1) -There are 11 found numbers: 1000, 1001, 1002, 1010, 1011, 1020, 1100, 1101, 1110, 1200 and 2000

(2) - The mean of all the found numbers is:
      (1000 + 1001 + 1002 + 1010 + 1011 + 1020 + 1100 + 1101 + 1110 + 1200 + 2000) /11 = 1141.36363,  
      so 1110 is the number that is closest to that mean value.

(3) - 12555 is the sum of all the found numbers
      1000 + 1001 + 1002 + 1010 + 1011 + 1020 + 1100 + 1101 + 1110 + 1200 + 2000 = 12555

Finally, let's see another cases
```
max_sumDig(2000, 4) -----> [21, 1120, 23665]

max_sumDig(2000, 7) -----> [85, 1200, 99986]

max_sumDig(3000, 7) -----> [141, 1600, 220756]
```

Happy coding!!

```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 = '\ndef sum_int(i):\n    """Sum digits of an integer - standard"""\n    s=0\n    while i != 0:\n        s += i % 10\n        i //= 10\n    return s\n\ndef find_4digs(m,MaxNum,MaxSum):\n    """start by finding all 4 digit numbers n m \\leq n \\leq MaxNum with sum \\leq MaxSum"""\n    \n    sts=[m]\n    for i in range(0, 4):\n        for st in sts:            \n            while (sum_int(st+10**i)<= MaxSum and st+10**i <= MaxNum):\n                sts.append(st+10**i)\n                st += 10**i\n    sts=list(set(sts)) # delete duplicates\n    return (sts)\n\ndef find_5digs(nums,MaxNum,MaxSum):\n    """ takes in a list of 4 digit numbers \\leq MaxNum and with sum \\leq MaxSum. Returns list of 4 and 5 digit nums \n    with every consecutive 4 digits satisfying the same conditions"""\n    #TODO: Generalize to x digit numbers\n    \n    for s in  nums:\n        # add digits before the 4 digit nums\n        for i in range(1, MaxSum - sum_int(int(str(s)[0:3]))+1):\n            cand1 = int(str(i)+str(s))\n            if cand1 <= MaxNum:\n                nums.append(cand1)\n        # add digits after the 4 digit nums\n        for i in range(0,MaxSum-sum_int(int(str(s)[1:4]))+1):\n            cand2 = int( str(s) + str(i) )\n            if cand2 <= MaxNum:\n                nums.append(cand2)    \n\n    nums=list(set(nums)) # delete duplcates\n    return nums\n    \ndef max_sumDig(MaxNum,MaxSum):\n    """ Find all numbers satisfying the conditions. """\n    \n    nums = find_4digs(1000,MaxNum,MaxSum)\n    nums = find_5digs(nums,MaxNum,MaxSum)\n    \n    # calcualte min distance from mean\n    mean = sum(nums)/len(nums)           \n    dists=[ abs(s-mean) for s in nums] \n    \n    for i in range(len(dists)):\n        if dists[i] == min(dists):\n            min_dist=nums[i]   \n            \n    return [len(nums), min_dist, sum(nums)]\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'max_sumDig'
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: 7942