1class Egg:
  2    def __init__(self):
  3        self.parts = [] 
  4        self.filled = 0.0
  5
  6        self.top_broken = False
  7        self.bottom_broken = False
  8
  9        self.tournament = None
 10
 11    def paint(self, *args):
 12        total_to_add = 0.0
 13
 14        for color, percent in args:
 15            total_to_add += percent
 16
 17        if self.filled + total_to_add > 100.0:
 18            raise ValueError("Too much paint")
 19
 20        current_start = self.filled
 21        new_parts = []
 22
 23        for color, percent in args:
 24            pigment = self._get_pigment(color)
 25            current_end = current_start + percent
 26            new_parts.append((current_start, current_end, pigment))
 27            current_start = current_end
 28
 29        self.parts.extend(new_parts)
 30        self.filled += total_to_add
 31
 32    def _get_pigment(self, hex_color):
 33        hex_color = hex_color.upper()
 34
 35        r = int(hex_color[0:2], 16)
 36        g = int(hex_color[2:4], 16)
 37        b = int(hex_color[4:6], 16)
 38
 39        return r + g + b
 40
 41    def _get_side_info(self, side):
 42        if side == "top":
 43            side_start = 0.0
 44            side_end = 50.0
 45        elif side == "bottom":
 46            side_start = 50.0
 47            side_end = 100.0
 48        else:
 49            raise ValueError("Invalid side")
 50
 51        total_strength = 0.0
 52        total_coverage = 0.0
 53
 54        for start, end, pigment in self.parts:
 55            overlap_start = max(start, side_start)
 56            overlap_end = min(end, side_end)
 57
 58            if overlap_start < overlap_end:
 59                overlap_length = overlap_end - overlap_start
 60                total_coverage += overlap_length
 61                total_strength += pigment * (overlap_length / 50.0)
 62
 63        return total_strength, total_coverage
 64
 65    def _fight(self, other, side):
 66        if not isinstance(other, Egg):
 67            return NotImplemented
 68
 69        if side == "top":
 70            if self.top_broken or other.top_broken:
 71                raise TypeError("One of the eggs has a broken top side")
 72        elif side == "bottom":
 73            if self.bottom_broken or other.bottom_broken:
 74                raise TypeError("One of the eggs has a broken bottom side")
 75        else:
 76            raise ValueError("Invalid side")
 77
 78        my_strength, my_coverage = self._get_side_info(side)
 79        other_strength, other_coverage = other._get_side_info(side)
 80
 81        if my_strength > other_strength:
 82            winner = self
 83            loser = other
 84        elif other_strength > my_strength:
 85            winner = other
 86            loser = self
 87        else:
 88            if my_coverage > other_coverage:
 89                winner = self
 90                loser = other
 91            elif other_coverage > my_coverage:
 92                winner = other
 93                loser = self
 94            else:
 95               
 96                winner = self
 97                loser = other
 98
 99        if side == "top":
100            loser.top_broken = True
101        else:
102            loser.bottom_broken = True
103
104        if self.tournament is not None and self.tournament is other.tournament:
105            self.tournament._record_battle(self, other, side, winner)
106
107        return winner
108
109    def __mul__(self, other):
110        return self._fight(other, "top")
111
112    def __matmul__(self, other):
113        return self._fight(other, "bottom")
114
115
116class EggTournament:
117    def __init__(self):
118        self.name_to_egg = {}
119        self.egg_to_name = {}
120        self.wins = {}
121
122        self.battles = []
123
124    def register(self, egg, name):
125        if egg.tournament is not None:
126            raise ValueError("An egg cannot be registered in multiple tournaments")
127
128        if not name.isidentifier():
129            raise ValueError("Invalid registration name")
130
131        if name in self.name_to_egg:
132            raise ValueError(f"Egg with name {name} has already been registered")
133
134        self.name_to_egg[name] = egg
135        self.egg_to_name[egg] = name
136        self.wins[egg] = 0
137        egg.tournament = self
138
139    def _record_battle(self, egg1, egg2, side, winner):
140        if egg1 not in self.egg_to_name or egg2 not in self.egg_to_name:
141            return
142
143        self.battles.append({
144            "egg1": egg1,
145            "egg2": egg2,
146            "side": side,
147            "winner": winner
148        })
149
150        self.wins[winner] += 1
151
152    def __getitem__(self, key):
153        if isinstance(key, tuple):
154            if len(key) != 3:
155                raise KeyError("Invalid key")
156            egg1, egg2, side = key
157        elif isinstance(key, slice):
158            egg1 = key.start
159            egg2 = key.stop
160            side = key.step
161        else:
162            raise KeyError("Invalid key")
163
164        if side not in ("top", "bottom"):
165            raise KeyError("Invalid key")
166
167        for battle in reversed(self.battles):
168            same_pair = (
169                (battle["egg1"] is egg1 and battle["egg2"] is egg2) or
170                (battle["egg1"] is egg2 and battle["egg2"] is egg1)
171            )
172
173            if same_pair and battle["side"] == side:
174                return battle["winner"]
175
176        raise KeyError("No such battle")
177
178    def _get_positions(self):
179        sorted_eggs = sorted(self.wins.items(), key=lambda pair: pair[1], reverse=True)
180
181        positions = {}
182        current_position = 1
183
184        for i in range(len(sorted_eggs)):
185            egg, wins = sorted_eggs[i]
186
187            if i == 0:
188                positions[egg] = current_position
189            else:
190                previous_egg, previous_wins = sorted_eggs[i - 1]
191
192                if wins < previous_wins:
193                    current_position += 1
194
195                positions[egg] = current_position
196
197        return positions
198
199    def __rmatmul__(self, place):
200        positions = self._get_positions()
201        result = set()
202
203        for egg, position in positions.items():
204            if position == place:
205                result.add(egg)
206
207        if len(result) == 0:
208            raise IndexError("No eggs on this position")
209
210        if len(result) == 1:
211            return next(iter(result))
212
213        return result
214
215    def __getattr__(self, name):
216        if name in self.name_to_egg:
217            egg = self.name_to_egg[name]
218            positions = self._get_positions()
219
220            return {
221                "position": positions[egg],
222                "victories": self.wins[egg]
223            }
224
225        raise AttributeError("Apologies, there is no such egg registered")
226
227    def __contains__(self, egg):
228        return egg in self.egg_to_name