If we multiply the integer      `717 (n)` by `7 (k)`, the result will be equal to `5019`.

Consider all the possible ways that this last number may be split as a string and calculate their corresponding sum obtained by adding the substrings as integers. When we add all of them up,... surprise, we got the original number `717`:

```
Partitions as string                Total Sums
['5', '019']                        5 + 19 = 24
['50', '19']                       50 + 19 = 69
['501', '9']                      501 + 9 = 510
['5', '0', '19']                5 + 0 + 19 = 24
['5', '01', '9']                 5 + 1 + 9 = 15
['50', '1', '9']                50 + 1 + 9 = 60
['5', '0', '1', '9']         5 + 0 + 1 + 9 = 15
                            ____________________
                              Big Total:    717
                            ____________________
```
In fact, `717` is one of the few integers that has such property with a factor `k = 7`.

Changing the factor `k`, for example to `k = 3`, we may see that the integer `40104` fulfills this property.

Given an integer `start_value` and an integer `k`, output the smallest integer `n`, but higher than `start_value`, that fulfills the above explained properties.

If by chance, `start_value`, fulfills the property, do not return `start_value` as a result, only the next integer. Perhaps you may find this assertion redundant if you understood well the requirement of the kata: "output the smallest integer `n`, but higher than `start_value`"

The values for `k` in the input may be one of these: `3, 4, 5, 7`

### Features of the random tests

If you want to understand the style and features of the random tests, see the *Notes* at the end of these instructions.

The random tests are classified in three parts.

- Random tests each with one of the possible values of `k` and a random `start_value` in the interval `[100, 1300]`
- Random tests each with a `start_value` in a larger interval for each value of `k`, as follows:
 - for `k = 3`, a random `start value` in the range `[30000, 40000]`
 - for `k = 4`, a random `start value` in the range `[2000, 10000]`
 - for `k = 5`, a random `start value` in the range `[10000, 20000]`
 - for `k = 7`, a random `start value` in the range `[100000, 130000]`
- More challenging tests, each with a random `start_value` in the interval `[100000, 110000]`.



See the examples tests.

Enjoy it.

# Notes:

- As these sequences are finite, in other words, they have a maximum term for each value of k, the tests are prepared in such way that the `start_value`  will always be less than this maximum term. So you may be confident that your code will always find an integer.

- The values of `k` that generate sequences of integers, for the constrains of this kata are: 2, 3, 4, 5, and 7. The case `k = 2` was not included because it generates only two integers.

- The sequences have like "mountains" of abundance of integers but also have very wide ranges like "valleys" of scarceness. Potential solutions, even the fastest ones, may time out searching the next integer due to an input in one of these valleys. So it was intended to avoid these ranges.

Javascript and Ruby versions will be released soon.

```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 = 'from bisect import bisect_right\n\ndef next_higher(start_value, k):\n    d = {3: [162, 378, 756, 1161, 1206, 1611, 1989, 34992, 35208, 35388, 37332, 37548, 37728, 40104, 72972, 73152, 75312, 75492, 75708, 77652, 77832, 77868, 78048, 80208, 80388, 113256, 115596, 115812, 117972, 118152, 118368, 120312, 120492, 120708, 155916],\n         4: [198, 260, 276, 520, 536, 552, 796, 812, 1072, 1108, 1368, 1384, 1644, 1680, 1940, 1956, 2216, 2232, 2492, 10728, 10872, 79536, 109008, 110592, 140064, 193488],\n         5: [108, 171, 846, 1692, 4212, 14724, 18936, 19224, 20304, 103608, 123912, 148608, 168912],\n         7: [717, 861, 1005, 1149, 1158, 1293, 1302, 1431, 14308, 14316, 28624, 28632, 28716, 42948, 43024, 43032, 57264, 57272, 57348, 57432, 71664, 71672, 71748, 85988, 86064, 86072, 86148, 100388, 100464, 100472, 101448, 114704, 114788, 114864, 114872, 115764, 115772, 129104, 129188, 130088, 130164, 130172]}\n    return d[k][bisect_right(d[k], start_value)]'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'next_higher'
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: 6120