In the board game Talisman, when two players enter combat the outcome is decided by a combat score, equal to the players power plus any modifiers plus the roll of a standard 1-6 dice. The player with the highest combat score wins and the opposing player loses a life. In the case of a tie combat ends with neither player losing a life.

For example:
```
Player 1: 5 Power, 0 Modifier
Player 2: 3 Power, 2 Modifier

Player 1 rolls a 4, Player 2 rolls a 2.

(5 + 0 + 4) -> (3 + 2 + 2)
Player 1 wins (9 > 7)
```

Your task is to write a method that calculates the required roll for the player to win.

The player and enemy stats are given as an array in the format:
```python
[power, modifier]
```

For example for the examples used above the stats would be given as:
```python
get_required([5, 0], [3, 2]) # returns 'Random'
```

If the player has at least 6 more power (including modifiers) than the enemy they automatically wins the fight, as the enemy's combat score couldn't possibly exceed the player's. In this instance the method should return "Auto-win".

For example:
```python
get_required([9, 0], [2, 1]) # returns 'Auto-win' as the enemy can't possibly win
```

If the enemy has at least 6 more power (including modifiers) than the player they automatically wins the fight, as the player's combat score couldn't possibly exceed the enemy's. In this instance the method should return "Auto-lose".

For example:
```python
get_required([2, 1], [9, 0]) # returns 'Auto-lose' as the player can't possibly win
```

If the player and enemy have the same power (including modifiers) the outcome is purely down to the dice roll, and hence would be considered completely random. In this instance the method should return "Random".

For example (as above):
```python
get_required([5, 0], [3, 2]) # returns 'Random' as it is purely down to the dice roll
```

If the player has greater power than the enemy (including modifiers) the player could guarantee a win by rolling a high enough number on the dice. In this instance the method should return a range equal to the numbers which would guarantee victory for the player.

```python
get_required([6, 0], [2, 2]) # returns '(5..6)' as rolling a 5 or 6 would mean the enemy could not win
get_required([7, 1], [2, 2]) # returns '(3..6)' as rolling anything 3 through 6 would mean the enemy could not win
```

If the player has less power than the enemy (including modifiers) the player can only win if the enemy rolls a low enough number, providing they then roll a high enough number. In this instance the method should return a range equal to the numbers which would allow the player a chance to win.

```python
get_required([4, 0], [6, 0]) # returns '(1..3)' as this would be the only outcome for which the player could still win
get_required([1, 1], [6, 0]) # returns '(1..1)' as this would be the only outcome for which the player could still win
```

If the better case scenario for the player is to hope for a tie, then return `"Pray for a tie!"`.

```python
get_required([7, 2], [6, 8]) # returns "Pray for a tie!"
```

```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 = "def get_required(player, enemy):\n    p, e = sum(player), sum(enemy)\n    math_wins = [x for x in range(1, 7) if p+x > e+6]\n    lucky = [x for x in range(1, 7) if e+x < p+6]\n    return 'Random' if p == e else\\\n           'Auto-win' if p >= e+6 else\\\n           'Auto-lose' if e >= p+6 else\\\n           'Pray for a tie!' if e-p == 5 else\\\n           '({}..{})'.format(min(math_wins), max(math_wins)) if p > e else\\\n           '({}..{})'.format(min(lucky), max(lucky))"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'get_required'
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: 6002