## 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\']\n# Tuple of shell loading.\n# (<orbit>, <final count>, <code>)\n# Codes are:\n#    -2 - Remove one electron at a time and ultimately remove the shell so we don\'t get something like 5d0 for this one.\n#    -1 - Remove electrons in this shell one at a time.  Don\'t remove the shell.\n#     0 - Add this shell with zero electrons so that it does show up as something like 5d0 in the sequence.\n#     1 - Add 1 at a time\n#     2 - Add but the first one is a double skip because of electrons dropped before.\n\nshells = (\n    ("1s", 2, 1),\n    ("2s", 2, 1),\n    ("2p", 6, 1),\n    ("3s", 2, 1),\n    ("3p", 6, 1),\n    ("4s", 2, 1),\n    ("3d", 3, 1),\n    ("4s", 1, -1),\n    ("3d", 5, 2),\n    ("4s", 2, 1),\n    ("3d", 8, 1),\n    ("4s", 1, -1), # Cu\n    ("3d", 10, 1), # Cu\n    ("4s", 2, 1), # Zn\n    ("4p", 6, 1),\n    ("5s", 2, 1),\n    ("4d", 2, 1),\n    ("5s", 1, -1),\n    ("4d", 5, 2),\n    ("5s", 2, 1),\n    ("5s", 1, -1),\n    ("4d", 8, 2),\n    ("5s", 0, -1),\n    ("4d", 10, 2),\n    ("5s", 2, 1),\n    ("5p", 6, 1),\n    ("6s", 2, 2), # Ba\n    ("4f", 0, 0), # La\n    ("5d", 1, 1), # La\n    ("4f", 1, 1), # Ce\n    ("5d", 0, -2), #Pr\n    ("4f", 7, 2), # Eu\n    ("5d", 1, 1),\n    ("5d", 0, -2),\n    ("4f", 14, 1), # Yb\n    ("5d", 7, 1), # IR\n    ("6s", 1, -1), # Pt\n    ("5d", 10, 1), # Au\n    ("6s", 2, 1), # Hg\n    ("6p", 6, 1), # Rn\n    ("7s", 2, 1), # Ra\n    ("5f", 0, 0), # Ac\n    ("6d", 2, 1), # Th\n    ("6d", 1, -1), # Pa\n    ("5f", 4, 2), # Np\n    ("6d", 0, -2), #Pu\n    ("5f", 7, 2), # Am\n    ("6d", 1, 1), # Cm\n    ("6d", 0, -2), # Bk\n    ("5f", 14, 2), # No\n    ("6d", 1, 1), # Lr\n#  These exceptions should exist per https://ptable.com/ but they don\'t in the tests.\n#    ("7p", 1, 1), # Lr\n#    ("7p", 0, -2), # Rf\n#    ("6d", 7, 2), # Mt\n#    ("7s", 1, -1), # Ds\n    ("6d", 9, 2), # Ds\n    ("7s", 2, 1), # Rg\n    ("6d", 10, 1), # Cn\n    ("7p", 6, 1)\n    )\n    \n# Order of shells.    \nshell_seq = ["1s", "2s", "2p", "3s", "3p", "3d", "4s", "4p", "4d", "4f", "5s", "5p", "5d", "5f", "6s", "6p", "6d", "7s", "7p"]\n    \ndef get_electron_configuration(element):\n    # Create our electron shell dictionary\n    e = {}\n    # Get the atomic number\n    a = ELEMENTS.index(element)+1\n    # Keep track of the total number electrons.  This is easier/faster than summing up the numbers in the dict.\n    t = 0\n    # Loop through the shells\n    for o, cnt, code in shells:\n        # If we reached the atomic number, we stop.\n        if t == a:\n            break\n        else:\n            # If orbit isn\'t in the dict, add it.\n            # Note:  Even if code=0 this portion will add the orbit so it will show up in "o in e" below when building the o_list.\n            if o not in e: e[o] = 0\n            # If the code is -2, count down and delete the orbit.\n            if code == -2:\n                while e[o] > cnt:\n                    e[o] -= 1\n                    t -= 1\n                del(e[o])\n            # If the code is -1, count down.\n            elif code == -1:\n                while e[o] > cnt:\n                    e[o] -= 1\n                    t -= 1\n            # IF the code is positve, count up.  We just use the 2 for ease in building the table above.\n            # Nothing special is required for code=2 vs code=1\n            elif code > 0:\n                while t != a and e[o] < cnt:\n                    e[o] += 1\n                    t += 1\n    \n    # Combine the orbits and counts.  Use the shell_seq to get the order correct and don\'t include shells that aren\'t in e.\n    o_list = [f"{o}{e[o]}" for o in shell_seq if o in e]\n    # Join the list and output.\n    return f"{element} -> {\' \'.join(o_list)}"\n'
_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: 6111