1class Egg:
  2    def __init__(self):
  3        self._segments = []
  4        self._filled = 0.0
  5        self._broken_top = False
  6        self._broken_bottom = False
  7        self._tournament = None
  8
  9    def paint(self, *args):
 10        total_new = sum(p for _, p in args)
 11
 12        if self._filled + total_new > 100.0:
 13            raise ValueError("Too much paint")
 14
 15        current = self._filled
 16
 17        for hex_color, percentage in args:
 18            pigment = self._pigment(hex_color)
 19
 20            start = current
 21            end = current + percentage
 22
 23            if start < 50 < end:
 24                self._segments.append((start, 50, pigment))
 25                self._segments.append((50, end, pigment))
 26            else:
 27                self._segments.append((start, end, pigment))
 28
 29            current = end
 30
 31        self._filled += total_new
 32
 33    def _pigment(self, hex_color):
 34        r = int(hex_color[0:2], 16)
 35        g = int(hex_color[2:4], 16)
 36        b = int(hex_color[4:6], 16)
 37        return r + g + b
 38
 39    def _strength(self, top):
 40        if top and self._broken_top:
 41            raise TypeError("Top side is broken")
 42        if not top and self._broken_bottom:
 43            raise TypeError("Bottom side is broken")
 44
 45        low, high = (0, 50) if top else (50, 100)
 46        total = 0.0
 47
 48        for start, end, pigment in self._segments:
 49            overlap_start = max(start, low)
 50            overlap_end = min(end, high)
 51
 52            if overlap_start < overlap_end:
 53                portion = (overlap_end - overlap_start) / 50
 54                total += portion * pigment
 55
 56        return total
 57
 58    def _battle(self, other, top):
 59        s1 = self._strength(top)
 60        s2 = other._strength(top)
 61
 62        if s1 > s2:
 63            winner, loser = self, other
 64        else:
 65            winner, loser = other, self
 66
 67        if top:
 68            loser._broken_top = True
 69        else:
 70            loser._broken_bottom = True
 71
 72        if self._tournament and self._tournament is other._tournament:
 73            self._tournament.record(self, other, "top" if top else "bottom", winner)
 74
 75        return winner
 76
 77    def __mul__(self, other):
 78        return self._battle(other, True)
 79
 80    def __matmul__(self, other):
 81        return self._battle(other, False)
 82
 83
 84class EggTournament:
 85    def __init__(self):
 86        self._eggs = {}
 87        self._names = {}
 88        self._history = {}
 89        self._wins = {}
 90
 91    def register(self, egg, name):
 92        if not name.isidentifier():
 93            raise ValueError("Invalid registration name")
 94
 95        if name in self._eggs:
 96            raise ValueError(f"Egg with name {name} has already been registered")
 97
 98        if egg._tournament is not None:
 99            raise ValueError("An egg cannot be registered in multiple tournaments")
100
101        self._eggs[name] = egg
102        self._names[egg] = name
103        self._wins[egg] = 0
104        egg._tournament = self
105
106    def _pair_key(self, egg1, egg2):
107        return (egg1, egg2) if id(egg1) < id(egg2) else (egg2, egg1)
108
109    def record(self, egg1, egg2, side, winner):
110        if egg1 not in self._names or egg2 not in self._names:
111            return
112
113        key = self._pair_key(egg1, egg2), side
114        self._history[key] = winner
115        self._wins[winner] += 1
116
117    def __getitem__(self, item):
118        if isinstance(item, tuple):
119            egg1, egg2, side = item
120        elif isinstance(item, slice):
121            egg1, egg2, side = item.start, item.stop, item.step
122        else:
123            raise KeyError
124
125        key = self._pair_key(egg1, egg2), side
126
127        if key not in self._history:
128            raise KeyError
129
130        return self._history[key]
131
132    def __contains__(self, egg):
133        return egg in self._names
134
135    def __getattr__(self, name):
136        if name not in self._eggs:
137            raise AttributeError("Apologies, there is no such egg registered")
138
139        egg = self._eggs[name]
140        return {
141            "position": self._position(egg),
142            "victories": self._wins[egg]
143        }
144
145    @property
146    def ranking(self):
147        sorted_eggs = sorted(self._wins.items(), key=lambda x: -x[1])
148
149        ranking = {}
150        current_pos = 1
151        last_wins = None
152
153        for i, (egg, wins) in enumerate(sorted_eggs):
154            if wins != last_wins:
155                current_pos = i + 1
156
157            if current_pos not in ranking:
158                ranking[current_pos] = set()
159
160            ranking[current_pos].add(egg)
161            last_wins = wins
162
163        return ranking
164
165    def _position(self, egg):
166        for pos, eggs in self.ranking.items():
167            if egg in eggs:
168                return pos
169
170    def __rmatmul__(self, position):
171        if position not in self.ranking:
172            raise IndexError
173
174        eggs = self.ranking[position]
175
176        if len(eggs) == 1:
177            return list(eggs)[0]
178
179        return eggs