## Introduction


Each chemical element in its neutral state has a specific number of electrons associated with it. This is represented by the **atomic number** which is noted by an integer number next to or above each element of the periodic table (as highlighted in the image above).

As we move from left to right, starting from the top row of the periodic table, each element differs from its predecessor by 1 unit (electron). Electrons fill in different orbitals sets according to a specific order. Each set of orbitals, when full, contains an even number of electrons.

The orbital sets are:
* The _**s** orbital_ - a single orbital that can hold a maximum of 2 electrons.
* The _**p** orbital set_ - can hold 6 electrons.
* The _**d** orbital set_ - can hold 10 electrons.
* The _**f** orbital set_ - can hold 14 electrons.


The order in which electrons are filling the different set of orbitals is shown in the picture above. First electrons will occupy the **1s** orbital, then the **2s**, then the **2p** set, **3s** and so on.

Electron configurations show how the number of electrons of an element is distributed across each orbital set. Each orbital is written as a sequence that follows the order in the picture, joined by the number of electrons contained in that orbital set. The final electron configuration is a single string of orbital names and number of electrons per orbital set where the first 2 digits of each substring represent the orbital name followed by a number that states the number of electrons that the orbital set contains.

For example, a string that demonstrates an electron configuration of a chemical element that contains 10 electrons is: `1s2 2s2 2p6`. This configuration shows that there are two electrons in the `1s` orbital set, two electrons in the `2s` orbital set, and six electrons in the `2p` orbital set. `2 + 2 + 6 = 10` electrons total.

___

# Task

Your task is to write a function that displays the electron configuration built according to the Madelung rule of all chemical elements of the periodic table. The argument will be the symbol of a chemical element, as displayed in the periodic table.

**Note**: There will be a preloaded array called `ELEMENTS` with chemical elements sorted by their atomic number.

For example, when the element "O" is fed into the function the output should look like: 

`"O -> 1s2 2s2 2p4"`

However, there are some exceptions! The electron configurations of the elements below should end as:

```
Cr -> ...3d5 4s1
Cu -> ...3d10 4s1
Nb -> ...4d4 5s1
Mo -> ...4d5 5s1
Ru -> ...4d7 5s1
Rh -> ...4d8 5s1
Pd -> ...4d10 5s0
Ag -> ...4d10 5s1
La -> ...4f0 5d1
Ce -> ...4f1 5d1
Gd -> ...4f7 5d1 6s2
Pt -> ...4f14 5d9 6s1
Au -> ...4f14 5d10 6s1
Ac -> ...5f0 6d1 7s2
Th -> ...5f0 6d2 7s2
Pa -> ...5f2 6d1 7s2
U  -> ...5f3 6d1 7s2
Np -> ...5f4 6d1 7s2
Cm -> ...5f7 6d1 7s2
```

**Note**: for `Ni` the electron configuration should be `3d8 4s2` instead of `3d9 4s1`.

```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 = 'ELEMENTS = [\'H\', \'He\', \'Li\', \'Be\', \'B\', \'C\', \'N\', \'O\', \'F\', \'Ne\', \'Na\', \'Mg\', \'Al\', \'Si\', \'P\', \'S\', \'Cl\', \'Ar\', \'K\', \'Ca\', \'Sc\', \'Ti\', \'V\', \'Cr\', \'Mn\', \'Fe\', \'Co\', \'Ni\', \'Cu\', \'Zn\', \'Ga\', \'Ge\', \'As\', \'Se\', \'Br\', \'Kr\', \'Rb\', \'Sr\', \'Y\', \'Zr\', \'Nb\', \'Mo\', \'Tc\', \'Ru\', \'Rh\', \'Pd\', \'Ag\', \'Cd\', \'In\', \'Sn\', \'Sb\', \'Te\', \'I\', \'Xe\', \'Cs\', \'Ba\', \'La\', \'Ce\', \'Pr\', \'Nd\', \'Pm\', \'Sm\', \'Eu\', \'Gd\', \'Tb\', \'Dy\', \'Ho\', \'Er\', \'Tm\', \'Yb\', \'Lu\', \'Hf\', \'Ta\', \'W\', \'Re\', \'Os\', \'Ir\', \'Pt\', \'Au\', \'Hg\', \'Tl\', \'Pb\', \'Bi\', \'Po\', \'At\', \'Rn\', \'Fr\', \'Ra\', \'Ac\', \'Th\', \'Pa\', \'U\', \'Np\', \'Pu\', \'Am\', \'Cm\', \'Bk\', \'Cf\', \'Es\', \'Fm\', \'Md\', \'No\', \'Lr\', \'Rf\', \'Db\', \'Sg\', \'Bh\', \'Hs\', \'Mt\', \'Ds\', \'Rg\', \'Cn\', \'Nh\', \'Fl\', \'Mc\', \'Lv\', \'Ts\', \'Og\']\ndef get_electron_configuration(a):\n    d = {"s":2, "p":6, "d":10, "f":14}\n    o = [[x, d[x[1]]] for x in ["1s","2s","2p","3s","3p","4s","3d","4p","5s","4d","5p","6s","4f","5d","6p","7s","5f","6d","7p"]][::-1]\n    exceptions = {"Cr":[2, "4s1 3d5"], "Cu":[2, "4s1 3d10"], "Nb":[2, "5s1 4d4"], "Mo":[2, "5s1 4d5"], "Ru":[2, "5s1 4d7"], "Rh":[2, "5s1 4d8"], "Pd":[2, "5s0 4d10"], "Ag":[2, "5s1 4d10"], "La":[1, "4f0 5d1"], "Ce":[1, "4f1 5d1"], "Gd":[1, "4f7 5d1"], "Pt":[3, "6s1 4f14 5d9"], "Au":[3, "6s1 4f14 5d10"], "Ac":[1, "5f0 6d1"], "Th":[1, "5f0 6d2"], "Pa":[1, "5f2 6d1"], "U":[1, "5f3 6d1"], "Np":[1, "5f4 6d1"], "Cm":[1, "5f7 6d1"]}\n    r, n = [], ELEMENTS.index(a) + 1\n    while n > 0:\n        s, m = o.pop()\n        x = min(n, m)\n        n -= x\n        r.append("{}{}".format(s, x))\n    if a in exceptions:\n        m, s = exceptions[a]\n        r = r[:-m] + s.split()\n    return "{} -> {}".format(a, " ".join(sorted(r, key=lambda x: (x[0], d[x[1]]))))'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'get_electron_configuration'
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: 9900