docs: def normalize_address(self, addr, is_write=False, convert_to_valueset=False, target_region=None, condition=None): #pylint:disable=arguments-differ
          """
          Convert a ValueSet object into a list of addresses.
  
          :param addr: A ValueSet object (which describes an address)
          :param is_write: Is this address used in a write or not
          :param convert_to_valueset: True if you want to have a list of ValueSet instances instead of AddressWrappers,
                                      False otherwise
          :param target_region: Which region to normalize the address to. To leave the decision to SimuVEX, set it to None
          :return: A list of AddressWrapper or ValueSet objects
          """
          targets_limit = WRITE_TARGETS_LIMIT if is_write else READ_TARGETS_LIMIT
  
          if type(addr) is not int:
              for constraint in self.state.solver.constraints:
                  if getattr(addr, 'variables', set()) & constraint.variables:
                      addr = self._apply_condition_to_symbolic_addr(addr, constraint)
  
          # Apply the condition if necessary
          if condition is not None:
              addr = self._apply_condition_to_symbolic_addr(addr, condition)
  
          if type(addr) is int:
              addr = self.state.solver.BVV(addr, self.state.arch.bits)
  
          addr_with_regions = self._normalize_address_type(addr)
          address_wrappers = [ ]
  
          for region, addr_si in addr_with_regions:
              concrete_addrs = addr_si.eval(targets_limit)
  
              if len(concrete_addrs) == targets_limit and HYBRID_SOLVER in self.state.options:
                  exact = True if APPROXIMATE_FIRST not in self.state.options else None
                  solutions = self.state.solver.eval_upto(addr, targets_limit, exact=exact)
  
                  if len(solutions) < len(concrete_addrs):
                      concrete_addrs = [addr_si.intersection(s).eval(1)[0] for s in solutions]
  
              if len(concrete_addrs) == targets_limit:
                  self.state.history.add_event('mem', message='concretized too many targets. address = %s' % addr_si)
  
              for c in concrete_addrs:
                  aw = self._normalize_address(region, c, target_region=target_region)
                  address_wrappers.append(aw)
  
          if convert_to_valueset:
              return [ i.to_valueset(self.state) for i in address_wrappers ]
  
          else:
              return address_wrappers