1_MATERIALS_DENSITIES = {
  2    'Concrete': 2500,
  3    'Brick': 2000,
  4    'Stone': 1600,
  5    'Wood': 600,
  6    'Steel': 7700,
  7}
  8
  9class Material:
 10    """Base class for materials with mass and density."""
 11
 12    _DENSITY = 1
 13
 14    def __init__(self, mass):
 15        """Initialize the material with a given mass."""
 16        self.mass = mass
 17        self._is_valid = True
 18
 19    @property
 20    def volume(self):
 21        """Calculate the volume of the material."""
 22        return self.mass / self._DENSITY
 23
 24    def validate(self):
 25        """Check if the material is still valid for use."""
 26        if not self._is_valid:
 27            raise AssertionError('Not valid material found.')
 28        
 29    def invalidate(self):
 30        """Mark the material as invalid."""
 31        self._is_valid = False
 32        
 33    def get_base_materials(self):
 34        return [type(self).__name__]
 35
 36
 37class Concrete(Material):
 38    """Concrete material with predefined density."""
 39    _DENSITY = _MATERIALS_DENSITIES['Concrete']
 40
 41
 42class Brick(Material):
 43    """Brick material with predefined density."""
 44    _DENSITY = _MATERIALS_DENSITIES['Brick']
 45
 46
 47class Stone(Material):
 48    """Stone material with predefined density."""
 49    _DENSITY = _MATERIALS_DENSITIES['Stone']
 50
 51
 52class Wood(Material):
 53    """Wood material with predefined density."""
 54    _DENSITY = _MATERIALS_DENSITIES['Wood']
 55
 56
 57class Steel(Material):
 58    """Steel material with predefined density."""
 59    _DENSITY = _MATERIALS_DENSITIES['Steel']
 60
 61
 62class Factory:
 63    """Create and manage materials and alloys."""
 64
 65    _MATERIALS_CREATED = {
 66        'Concrete': Concrete,
 67        'Brick': Brick,
 68        'Stone': Stone,
 69        'Wood': Wood,
 70        'Steel': Steel,
 71    }
 72
 73    all_created_materials = []
 74
 75    def __init__(self):
 76        self.materials_created_by_instance = []
 77
 78    def __call__(self, *args, **kwargs):
 79        """Enable the factory instance to be called."""
 80        if args and kwargs:
 81            raise ValueError('One type of arguments are allowed.')
 82        elif (len(args), len(kwargs)) == (0, 0):
 83            raise ValueError('No arguments found.')
 84
 85        if len(args) > 0:
 86            return self.positional_call(*args)
 87        return self.keyword_call(**kwargs)
 88
 89    def positional_call(self, *args):
 90        """Handle creation of alloys from positional arguments."""
 91
 92        for material in args:
 93            material.validate()
 94            material.invalidate()
 95
 96        base_materials = []
 97        for material in args:
 98                base_materials.extend(material.get_base_materials())
 99
100        unique_base_materials = sorted(set(base_materials))
101
102        alloy_name = '_'.join(unique_base_materials)
103        alloy_density = sum(_MATERIALS_DENSITIES[material] for material in unique_base_materials) / len(unique_base_materials)
104        alloy_mass = sum(material.mass for material in args)
105
106        if alloy_name in self._MATERIALS_CREATED:
107            alloy_class = self._MATERIALS_CREATED[alloy_name]
108        else:
109            alloy_class = self.create_alloy_class(alloy_name, alloy_density, unique_base_materials)
110            
111        alloy_instance = alloy_class(alloy_mass)
112        self.materials_created_by_instance.append(alloy_instance)
113        Factory.all_created_materials.append(alloy_instance)
114
115        return alloy_instance
116
117    def create_alloy_class(self, alloy_name, alloy_density, base_materials):
118        """Dynamically create a class for an alloy."""
119        
120        alloy_class = type(
121            alloy_name,
122            (Material,),
123            {
124                '_DENSITY': alloy_density,
125                '_base_materials': base_materials,
126                'get_base_materials': lambda self: base_materials,
127            }
128        )
129
130        self._MATERIALS_CREATED[alloy_name] = alloy_class
131        _MATERIALS_DENSITIES[alloy_name] = alloy_density
132        return alloy_class
133
134    def keyword_call(self, **kwargs):
135        """Handle creation of materials from keyword arguments."""
136        material_instances = []
137        for material, mass in kwargs.items():
138            if material not in self._MATERIALS_CREATED:
139                raise ValueError('Not valid material found.')
140
141            material_instance = self._MATERIALS_CREATED[material](mass)
142            material_instances.append(material_instance)
143            self.materials_created_by_instance.append(material_instance) 
144            self.all_created_materials.append(material_instance)
145
146        return tuple(material_instances)
147
148    def can_build(self, target):
149        """Check if the factory's materials can build a wall of target volume."""
150        valid_materials = [
151            material for material in self.materials_created_by_instance if material._is_valid
152        ]
153        
154        volume_sum = sum(material.volume for material in valid_materials)
155        return volume_sum >= target
156
157    @classmethod
158    def can_build_together(cls, target):
159        """Check if all factories together can build a wall of target volume."""
160        valid_materials = [
161            material for material in cls.all_created_materials if material._is_valid
162        ]
163        
164        used_materials = set(
165            material for material in cls.all_created_materials if not material._is_valid
166        )
167       
168        final_valid_materials = [material for material in valid_materials if material not in used_materials]
169        total_volume = sum(material.volume for material in final_valid_materials)
170        return total_volume >= target