docs: def store_cases(self, addr, contents, conditions, fallback=None, add_constraints=None, endness=None, action=None):
          """
          Stores content into memory, conditional by case.
  
          :param addr:            A claripy expression representing the address to store at.
          :param contents:        A list of bitvectors, not necessarily of the same size. Use None to denote an empty
                                  write.
          :param conditions:      A list of conditions. Must be equal in length to contents.
  
          The following parameters are optional.
  
          :param fallback:        A claripy expression representing what the write should resolve to if all conditions
                                  evaluate to false (default: whatever was there before).
          :param add_constraints: Add constraints resulting from the merge (default: True)
          :param endness:         The endianness for contents as well as fallback.
          :param action:          A SimActionData to fill out with the final written value and constraints.
          :type action:           SimActionData
          """
  
          if fallback is None and all(c is None for c in contents):
              l.debug("Avoiding an empty write.")
              return
  
          addr_e = _raw_ast(addr)
          contents_e = _raw_ast(contents)
          conditions_e = _raw_ast(conditions)
          fallback_e = _raw_ast(fallback)
  
          max_bits = max(c.length for c in contents_e if isinstance(c, claripy.ast.Bits)) \
              if fallback is None else fallback.length
  
          # if fallback is not provided by user, load it from memory
          # remember to specify the endianness!
          fallback_e = self.load(addr, max_bits//self.state.arch.byte_width, add_constraints=add_constraints, endness=endness) \
              if fallback_e is None else fallback_e
  
          req = self._store_cases(addr_e, contents_e, conditions_e, fallback_e, endness=endness)
          add_constraints = self.state._inspect_getattr('address_concretization_add_constraints', add_constraints)
          if add_constraints:
              self.state.add_constraints(*req.constraints)
  
          if req.completed and o.AUTO_REFS in self.state.options and action is None:
              region_type = self.category
              if region_type == 'file':
                  # Special handling for files to keep compatibility
                  # We may use some refactoring later
                  region_type = self.id
              action = SimActionData(self.state, region_type, 'write', addr=addr_e, data=req.stored_values[-1],
                                     size=max_bits, condition=self.state.solver.Or(*conditions), fallback=fallback
                                     )
              self.state.history.add_action(action)
  
          if req.completed and action is not None:
              action.actual_addrs = req.actual_addresses
              action.actual_value = action._make_object(req.stored_values[-1])
              action.added_constraints = action._make_object(self.state.solver.And(*req.constraints)
                                                             if len(req.constraints) > 0 else self.state.solver.true)