1class Egg:
  2    def __init__(self):
  3        self._pattern = []
  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        to_add = 0.0
 11        for hex_color, percentage in args:
 12            to_add += percentage
 13
 14        if to_add + self._filled > 100.0:
 15            raise ValueError("Too much paint! Cannot fill more than 100% of the egg.")
 16        
 17        for hex_color, percentage in args:
 18            self._pattern.append((hex_color.upper(), percentage))
 19
 20        self._filled += to_add
 21
 22    def _color_value(self, hex_color):
 23        r = int(hex_color[0:2], 16)
 24        g = int(hex_color[2:4], 16)
 25        b = int(hex_color[4:6], 16)
 26        return r + g + b
 27    
 28    def _side_strength(self, top=True):
 29        start = 0.0 if top else 50.0
 30        end = 50.0 if top else 100.0
 31        strength = 0.0
 32        painted_so_far = 0.0
 33
 34        for hex_color, percentage in self._pattern:
 35            seg_start = painted_so_far
 36            seg_end = painted_so_far + percentage
 37            overlap_start = max(seg_start, start)
 38            overlap_end = min(seg_end, end)
 39
 40            if overlap_start < overlap_end:
 41                overlap_percentage = overlap_end - overlap_start
 42                proportion = overlap_percentage / 50.0
 43                strength += self._color_value(hex_color) * proportion
 44
 45            painted_so_far = seg_end
 46
 47        return strength
 48    
 49    def _notify_tournament(self, other, winner, side):
 50        if (self._tournament is not None and self._tournament is other._tournament):
 51            self._tournament._record_match(self, other, winner, side)
 52
 53    def _duel(self, other, top):
 54        if top:
 55            if self._broken_top or other._broken_top:
 56                raise TypeError("Broken side cannot be used again")
 57        else:
 58            if self._broken_bottom or other._broken_bottom:
 59                raise TypeError("Broken side cannot be used again")
 60
 61        my_strength = self._side_strength(top=top)
 62        other_strength = other._side_strength(top=top)
 63
 64        if my_strength > other_strength:
 65            winner = self
 66            loser = other
 67        else:
 68            winner = other
 69            loser = self
 70
 71        if top:
 72            loser._broken_top = True
 73        else:
 74            loser._broken_bottom = True
 75
 76        self._notify_tournament(other, winner, "top" if top else "bottom")
 77        return winner
 78    
 79    def __mul__(self, other):
 80        return self._duel(other, top=True)
 81    
 82    def __matmul__(self, other):
 83        return self._duel(other, top=False)
 84        
 85class EggTournament:
 86    def __init__(self):
 87        self._eggs_by_name = {}
 88        self._names_by_egg = {}
 89        self._history = []
 90        self._wins = {}
 91
 92    def register(self, egg, name):
 93        if egg._tournament is not None:
 94            raise ValueError("An egg cannot be registered in multiple tournaments")
 95
 96        if not name.isidentifier():
 97            raise ValueError("Invalid registration name")
 98
 99        if name in self._eggs_by_name:
100            raise ValueError(f"Egg with name {name} has already been registered")
101
102        self._eggs_by_name[name] = egg
103        self._names_by_egg[egg] = name
104        self._wins[egg] = 0
105        egg._tournament = self
106
107    def _record_match(self, egg1, egg2, winner, side):
108        self._history.append({
109            "eggs": frozenset((egg1, egg2)),
110            "winner": winner,
111            "side": side,
112        })
113        self._wins[winner] += 1
114
115    def __contains__(self, egg):
116        return egg in self._names_by_egg
117
118    def __getitem__(self, key):
119        egg1 = egg2 = side = None
120
121        if isinstance(key, tuple) and len(key) == 3:
122            egg1, egg2, side = key
123        elif isinstance(key, slice):
124            egg1 = key.start
125            egg2 = key.stop
126            side = key.step
127        else:
128            raise KeyError
129
130        pair = frozenset((egg1, egg2))
131
132        for record in reversed(self._history):
133            if record["eggs"] == pair and record["side"] == side:
134                return record["winner"]
135
136        raise KeyError
137
138    def _ranking_groups(self):
139        eggs = list(self._wins.keys())
140        eggs.sort(key=lambda egg: self._wins[egg], reverse=True)
141
142        groups = {}
143        current_position = 0
144        previous_wins = None
145
146        for index, egg in enumerate(eggs):
147            wins = self._wins[egg]
148
149            if previous_wins is None or wins < previous_wins:
150                current_position += 1
151
152            groups.setdefault(current_position, set()).add(egg)
153            previous_wins = wins
154
155        return groups
156
157    def _position_of_egg(self, target_egg):
158        groups = self._ranking_groups()
159
160        for position, eggs in groups.items():
161            if target_egg in eggs:
162                return position
163
164        raise AttributeError("Apologies, there is no such egg registered")
165
166    def __rmatmul__(self, position):
167        groups = self._ranking_groups()
168
169        if position not in groups:
170            raise IndexError
171
172        eggs = groups[position]
173        if len(eggs) == 1:
174            return next(iter(eggs))
175        return eggs
176
177    def __getattr__(self, name):
178        if name not in self._eggs_by_name:
179            raise AttributeError("Apologies, there is no such egg registered")
180
181        egg = self._eggs_by_name[name]
182        return {"position": self._position_of_egg(egg), "victories": self._wins[egg]}