| f | from fractions import Fraction | f | from fractions import Fraction | 
             |  |  |  | 
             | class Sausage: |  | class Sausage: | 
             |  |  |  | 
            | n |     def __init__(self, meat='pork!', volume=1): | n |     def __init__(self, ground='pork!', volume=1): | 
             |         self.meat = meat |  |         self.ground = ground | 
             |         self.volume = Fraction(volume) |  |         self.volume = Fraction(volume) | 
             |  |  |  | 
             |     def __abs__(self): |  |     def __abs__(self): | 
             |         return self.volume |  |         return self.volume | 
             |  |  |  | 
             |     def __add__(self, other): |  |     def __add__(self, other): | 
            | n |         return Sausage(self.meat, self.volume + other.volume) | n |         return Sausage(self.ground, self.volume + other.volume) | 
             |  |  |  | 
             |     def __sub__(self, other): |  |     def __sub__(self, other): | 
            | n |         return Sausage(self.meat, max(self.volume - other.volume, 0)) | n |         return Sausage(self.ground, max(self.volume - other.volume, 0)) | 
             |  |  |  | 
             |     def __mul__(self, factor): |  |     def __mul__(self, factor): | 
            | n |         return Sausage(self.meat, self.volume * factor) | n |         return Sausage(self.ground, self.volume * factor) | 
             |  |  |  | 
             |     def __rmul__(self, factor): |  |     def __rmul__(self, factor): | 
             |         return self * factor |  |         return self * factor | 
             |  |  |  | 
             |     def __truediv__(self, divisor): |  |     def __truediv__(self, divisor): | 
            | n |         return Sausage(self.meat, self.volume / divisor) | n |         return Sausage(self.ground, self.volume / divisor) | 
             |  |  |  | 
             |     def __bool__(self): |  |     def __bool__(self): | 
             |         return self.volume > 0 |  |         return self.volume > 0 | 
             |  |  |  | 
             |     def __str__(self): |  |     def __str__(self): | 
             |         if self.volume == 0: |  |         if self.volume == 0: | 
             |             return '/|\n||\n||\n||\n\\|' |  |             return '/|\n||\n||\n||\n\\|' | 
             |         full_loafs = int(self.volume) |  |         full_loafs = int(self.volume) | 
            | n |         rems = self.volume - full_loafs | n |         remaining_fraction = self.volume - full_loafs | 
             |         str1, str2, str3 = ('', '', '') |  |         top_border, ground_line, bottom_border = ('', '', '') | 
             |         for i in range(full_loafs): |  |         for _ in range(full_loafs): | 
             |             border1, filling, border2 = self.full() |  |             a, b, c = self._create_full_loaf() | 
             |             str1 += border1 |  |             top_border += a | 
             |             str2 += filling |  |             ground_line += b | 
             |             str3 += border2 |  |             bottom_border += c | 
             |         if rems > 0: |  |         if remaining_fraction > 0: | 
             |             border1, filling, border2 = self.partial(rems) |  |             a, b, c = self._create_partial_loaf(remaining_fraction) | 
             |             str1 += border1 |  |             top_border += a | 
             |             str2 += filling |  |             ground_line += b | 
             |             str3 += border2 |  |             bottom_border += c | 
             |         return str1 + '\n' + (str2 + '\n') * 3 + str3 |  |         return top_border + '\n' + (ground_line + '\n') * 3 + bottom_bor | 
             |   |  | der | 
             |  |  |  | 
            | n |     def full(self): | n |     def _create_full_loaf(self): | 
             |  |  |         ground_remainder = 12 % len(self.ground) | 
             |         main = 12 // len(self.meat) |  |         ground_main = 12 // len(self.ground) | 
             |         remain = 12 % len(self.meat) |  |  | 
             |         border1 = '/------------\\' |  |         top_border = '/------------\\' | 
             |         filling = f'|{self.meat * main + self.meat[:remain]}|' |  |         ground_line = f'|{self.ground * ground_main + self.ground[:groun | 
             |   |  | d_remainder]}|' | 
             |         border2 = '\\------------/' |  |         bottom_border = '\\------------/' | 
             |         return (border1, filling, border2) |  |         return (top_border, ground_line, bottom_border) | 
             |  |  |  | 
            | t |     def partial(self, fraction): | t |     def _create_partial_loaf(self, fraction): | 
             |         remaining_length = fraction.numerator * (12 // fraction.denomina |  |         total_ground_length = fraction.numerator * (12 // fraction.denom | 
             | tor) |  | inator) | 
             |         count_of_meat = remaining_length // len(self.meat) |  |         ground_count = total_ground_length // len(self.ground) | 
             |         remaining_meat_length = remaining_length - count_of_meat * len(s |  |         leftover_ground_length = total_ground_length - ground_count * le | 
             | elf.meat) |  | n(self.ground) | 
             |         border1 = '/' + '-' * remaining_length + '|' |  |         top_border = '/' + '-' * total_ground_length + '|' | 
             |         filling = f'|{self.meat * count_of_meat + self.meat[:remaining_m |  |         ground_line = f'|{self.ground * ground_count + self.ground[:left | 
             | eat_length]}|' |  | over_ground_length]}|' | 
             |         border2 = '\\' + '-' * remaining_length + '|' |  |         bottom_border = '\\' + '-' * total_ground_length + '|' | 
             |         return (border1, filling, border2) |  |         return (top_border, ground_line, bottom_border) |