Zonk is addictive dice game. In each round player rolls 6 dice. Then (s)he composes combinations from them. Each combination gives certain points. 

Then player can take one or more dice combinations to his hand and re-roll remaining dice or save his score. Dice in player's hand won't be taken into account in subsequent rolls.

If no combinations can be composed - situation is called "zonk". Player thrown zonk loses all points in this round and next player moves. So it's player decision when to reroll and when to stop and save his score.

Your task is simple - just evaluate current roll and return maximum number of points can be scored from it. If no combinations can be made - function must return string ``"Zonk"`` (without quotes).

There are different variations of Zonk. In this kata, we will use most common table of combinations:

CombinationExample rollPoints
Straight (1,2,3,4,5 and 6)6 3 1 2 5 41000 points
Three pairs of any dice2 2 4 4 1 1750 points
Three of 11 4 1 11000 points
Three of 22 3 4 2 2200 points
Three of 33 4 3 6 3 2300 points
Three of 44 4 4400 points
Three of 52 5 5 5 4500 points
Three of 66 6 2 6600 points
Four of a kind1 1 1 1 4 62 × Three-of-a-kind score (in example, 2000 pts)
Five of a kind5 5 5 4 5 53 × Three-of-a-kind score (in example, 1500 pts)
Six of a kind4 4 4 4 4 44 × Three-of-a-kind score (in example, 1600 pts)
Every 14 3 1 2 2100 points
Every 55 2 650 points


Each die cannot be used in multiple combinations the same time, so three pairs of 2, 3 and 5 will worth you only ``750`` points (for three pairs), not 850 (for three pairs and two fives). But you can select multiple combinations, ``2 2 2 1 6`` will worth you ``300`` points (200 for three-of-kind '2' plus 100 for single '1' die)

Examples:
```python
  get_score([1,2,3]) # returns 100 = points from one 1
  get_score([3,4,1,1,5]) # returns 250 = points from two 1 and one 5
  get_score([2,3,2,3,3,2]) # returns 500 = three of 2 + three of 3
  get_score([1,1,1,1,1,5]) # returns 3050 = five 1 + one 5
  get_score([2,3,4,3,6,6]) # returns "Zonk" = no combinations here
  get_score([2,2,6,6,2,2]) # returns 400 = four 2, this cannot be scored as three pairs
  get_score([1,3,4,3,4,1]) # returns 750 = three pairs
  get_score([3,3,3,3]) # returns 600 = four of 3
  get_score([1,2,3,4,5]) # returns 150 = it's not straight
```
Of course, in real Zonk game it's sometimes not worth to collect all combination from roll. Taking less dice and rerolling more remaining may be better, but task is just to calculate maximum possible score from current single roll.

P.S. Inspired by this kata: http://www.codewars.com/kata/5270d0d18625160ada0000e4

```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 = '#List Comprehensions is so powerful\nfrom itertools import groupby\ndef get_score(a): \n    s = 0\n    if set(a)==set([1,2,3,4,5,6]): s=1000  #Straight\n    else:\n        if len(set([i*10 if i==1 else i for i in a if a.count(i)==2]))==3: s=750 #Three pairs\n        else:\n            s+=sum(sum(set([i*10 if i==1 else i for i in a if a.count(i)==k]))*100*(k-2) for k in (3,4,5,6)) #Three-four-five-six\n            s+=sum((i*10 if i==1 else i)*a.count(i) for i in (1,5) if a.count(i) in (1,2))*10 # Every 1 and 5\n    return s if s!=0 else "Zonk"'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'get_score'
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: 6540