Story:
In the realm of numbers, the apocalypse has arrived. Hordes of zombie numbers have infiltrated and are ready to turn everything into undead. The properties of zombies are truly apocalyptic: they reproduce themselves unlimitedly and freely interact with each other. Anyone who equals them is doomed. Out of an infinite number of natural numbers, only a few remain. This world needs a hero who leads remaining numbers in hope for survival: The highest number to lead those who still remain.

Briefing:
There is a list of positive natural numbers. Find the largest number that cannot be represented as the sum of this numbers, given that each number can be added unlimited times. Return this number, either 0 if there are no such numbers, or -1 if there are an infinite number of them.

Example:
```
Let's say [3,4] are given numbers. Lets check each number one by one:
1 - (no solution) - good
2 - (no solution) - good
3 = 3 won't go
4 = 4 won't go
5 - (no solution) - good
6 = 3+3 won't go
7 = 3+4 won't go
8 = 4+4 won't go
9 = 3+3+3 won't go
10 = 3+3+4 won't go
11 = 3+4+4 won't go
13 = 3+3+3+4 won't go
```
...and so on. So 5 is the biggest 'good'. return 5

Test specs:
Random cases will input up to 10 numbers with up to 1000 value

Special thanks:
Thanks to Voile-sama, mathsisfun-sama, and Avanta-sama for heavy assistance. And to everyone who tried and beaten the kata ^_^

```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 gcd(a,b): #Just a simple Euclidean algorithm to compute gcd\n    while (b != 0):\n      a,b = b,a%b\n    return a\n\n\n\ndef survivor(zombies):\n\n    if (len(zombies) == 0): #First let's deal with lists of length == 0\n        return -1\n\n    zombies.sort()    #Then let's sort the list\n    if zombies[0] == 1:    #If zombie[0] is 1, we know every number will be biten\n        return 0  \n    \n    ####################################################################\n    #Let's check if there is an infinity of solutions.                 #\n    #It is equivalent to see if gcd of all numbers is different from 1.#\n    ####################################################################\n    \n    zombies_gcd = 0\n    for z in zombies:\n        zombies_gcd = gcd(z,zombies_gcd)\n    if zombies_gcd != 1:\n        return -1\n    \n    ####################################################################\n    #Now let's list every number to see who's the last one to be bitten#\n    ####################################################################\n    \n    length = zombies[-1] + 1\n    who_is_bitten = [False for i in range(length)]\n    \n\n    for z in zombies:    #Of courses zombies are considered as bitten\n        who_is_bitten[z] = True        \n    \n    i = zombies[0] - 1    #We know that zombies[0]-1 is a survivor so we can begin by that number\n    \n    #We keep track of the number of consecutive zombies\n    consecutive_zombies = 0\n    \n\n    while (consecutive_zombies < zombies[0]): #we know if there are zombies[0] consecutive zombies in a row, \n                                              #then there won't be any survivor after that\n        if not(who_is_bitten[i]):         #If the number is not bitten, then it becomes the new last survivor\n            result = i\n            consecutive_zombies = 0\n        else:         #Otherwise, it bites other numbers which are at range\n            consecutive_zombies += 1\n            while (i + zombies[-1] >= len(who_is_bitten)): #if the list is too short we have to add new numbers\n                who_is_bitten.append(False)\n    \n            for z in zombies:\n                who_is_bitten[i + z] = True  #Then number i bites numbers that are at its range\n        \n        i += 1\n        \n    return result"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'survivor'
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: 6204