1MATERIAL_BITS = {
  2    'Concrete': 1 << 0,  # 1 (binary 00001)
  3    'Brick':    1 << 1,  # 2 (binary 00010)
  4    'Stone':    1 << 2,  # 4 (binary 00100)
  5    'Wood':     1 << 3,  # 8 (binary 01000)
  6    'Steel':    1 << 4,  # 16 (binary 10000)
  7}
  8
  9BASE_MATERIAL_DENSITIES = {
 10    'Concrete': 2500,
 11    'Brick': 2000,
 12    'Stone': 1600,
 13    'Wood': 600,
 14    'Steel': 7700,
 15}
 16
 17
 18class Material:
 19    def __init__(self, mass: float):
 20        if mass <= 0:
 21            raise ValueError("Mass must be a positive number.")
 22        self.mass: float = mass
 23        self.used: bool = False
 24        self._volume: float = None  # Cached value for the volume
 25
 26    def __hash__(self):
 27        return id(self)  # Hashing the object by its unique id
 28
 29    @property
 30    def volume(self):
 31        if self._volume is None:
 32            self._volume = self.mass / self.density  
 33        return self._volume
 34
 35
 36class Concrete(Material):
 37    density = BASE_MATERIAL_DENSITIES['Concrete']
 38    material_bit = MATERIAL_BITS['Concrete']
 39
 40
 41class Brick(Material):
 42    density = BASE_MATERIAL_DENSITIES['Brick']
 43    material_bit = MATERIAL_BITS['Brick']
 44
 45
 46class Stone(Material):
 47    density = BASE_MATERIAL_DENSITIES['Stone']
 48    material_bit = MATERIAL_BITS['Stone']
 49
 50
 51class Wood(Material):
 52    density = BASE_MATERIAL_DENSITIES['Wood']
 53    material_bit = MATERIAL_BITS['Wood']
 54
 55
 56class Steel(Material):
 57    density = BASE_MATERIAL_DENSITIES['Steel']
 58    material_bit = MATERIAL_BITS['Steel']
 59
 60
 61class Factory:
 62    material_classes = {
 63        'Concrete': Concrete,
 64        'Brick': Brick,
 65        'Stone': Stone,
 66        'Wood': Wood,
 67        'Steel': Steel,
 68    }
 69    dynamic_classes = {}
 70    all_materials = set()
 71
 72    # Precompute bitmask to material names mapping for quick lookup
 73    _bitmask_to_materials = {
 74        bitmask: [name for name, bit in MATERIAL_BITS.items() if bitmask & bit]
 75        for bitmask in range(1, 1 << len(MATERIAL_BITS))
 76    }
 77
 78    def __init__(self):
 79        self.material_bitmask = 0  # Represent current materials as a bitmask
 80        self.materials = set()      # Set of Material instances managed by this factory
 81
 82    def __call__(self, *args, **kwargs):
 83        self._validate_call(args, kwargs)
 84
 85        if kwargs:
 86            return self._create_materials(kwargs)
 87        else:
 88            return self._use_materials(args)
 89
 90    def _validate_call(self, args, kwargs):
 91        if (args and kwargs) or (not args and not kwargs):
 92            raise ValueError("Invalid input.")
 93
 94    def _create_materials(self, kwargs):
 95        materials_created = []
 96        for material_name, mass in kwargs.items():
 97            material_class = self._get_material_class(material_name)
 98            material = self._instantiate_material(material_class, mass)
 99            self._add_material(material)
100            materials_created.append(material)
101            self.material_bitmask |= material_class.material_bit  # Use material_class.material_bit
102        return tuple(materials_created)
103
104    def _get_material_class(self, material_name):
105        material_class = self.material_classes.get(material_name)
106        if material_class is None:
107            raise ValueError(f"Unknown material: {material_name}")
108        return material_class
109
110    def _instantiate_material(self, material_class, mass):
111        return material_class(mass)
112
113    def _add_material(self, material):
114        self.materials.add(material)  # Add to factory's materials
115        Factory.all_materials.add(material)  # Add to global all_materials
116        # Update the bitmask with the material's bit
117        self.material_bitmask |= material.material_bit
118
119    def _use_materials(self, materials):
120        self._validate_materials(materials)
121        self._mark_materials_as_used(materials)
122
123        material_bitmask, total_mass = self._calculate_bitmask_and_mass(materials)
124        new_class = self._get_or_create_dynamic_class(material_bitmask)
125
126        new_material = self._create_new_material(new_class, total_mass)
127        self.material_bitmask |= new_class.material_bit  # Set the bit for the new composite material
128        return new_material
129
130    def _validate_materials(self, materials):
131        known_classes = tuple(self.material_classes.values()) + tuple(self.dynamic_classes.values())
132
133        for material in materials:
134            if not isinstance(material, known_classes):
135                raise ValueError(f"Invalid material instance: {material}")
136            if material.used:
137                raise AssertionError(f"Material {material} is already used.")
138
139    def _mark_materials_as_used(self, materials):
140        for material in materials:
141            material.used = True
142            self.materials.discard(material)  # Remove from factory's materials
143            self.material_bitmask &= ~material.material_bit  # Clear the bit for the used material
144            Factory.all_materials.discard(material)  # Remove from global all_materials
145
146    def _calculate_bitmask_and_mass(self, materials):
147        material_bitmask = 0
148        total_mass = 0
149        for material in materials:
150            material_bitmask |= material.material_bit  # Combine material bits using bitwise OR
151            total_mass += material.mass
152        return material_bitmask, total_mass
153
154    def _get_or_create_dynamic_class(self, material_bitmask):
155        # Try to find existing class by material_bitmask
156        for cls in self.dynamic_classes.values():
157            if cls.material_bit == material_bitmask:
158                return cls
159        # Generate class name
160        base_materials = self._determine_base_materials(material_bitmask)
161        class_name = self._generate_class_name(base_materials)
162        # Check if class already exists in material_classes
163        if class_name in self.material_classes:
164            return self.material_classes[class_name]
165        # Create new dynamic class
166        return self._create_dynamic_class(material_bitmask)
167
168    def _create_dynamic_class(self, material_bitmask):
169        base_materials = self._determine_base_materials(material_bitmask)
170        density = self._calculate_density(base_materials)
171        class_name = self._generate_class_name(base_materials)
172
173        attributes = {
174            'density': density,
175            'material_bit': material_bitmask,
176        }
177        new_class = type(class_name, (Material,), attributes)
178        # Store the new class using the class name as the key
179        self.material_classes[class_name] = new_class
180        self.dynamic_classes[material_bitmask] = new_class
181        return new_class
182
183    def _determine_base_materials(self, material_bitmask):
184        # Use precomputed bitmask to materials mapping for efficiency
185        return self._bitmask_to_materials.get(material_bitmask, [])
186
187    def _calculate_density(self, base_materials):
188        densities = [BASE_MATERIAL_DENSITIES[name] for name in base_materials]
189        return sum(densities) / len(densities)
190
191    def _generate_class_name(self, base_materials):
192        # Generate class name by sorting material names to ensure consistency
193        return '_'.join(sorted(base_materials))
194
195    def _create_new_material(self, new_class, total_mass):
196        new_material = new_class(total_mass)
197        self.materials.add(new_material)  # Add to factory's materials
198        Factory.all_materials.add(new_material)  # Add to global all_materials
199        return new_material
200
201    def can_build(self, volume_needed):
202        # Calculate total volume of current materials in this factory
203        total_volume = sum(material.volume for material in self.materials)
204        return total_volume >= volume_needed
205
206    @classmethod
207    def can_build_together(cls, volume_needed):
208        # Calculate total volume of all materials across all factories
209        total_volume = sum(material.volume for material in cls.all_materials)
210        return total_volume >= volume_needed