docs: def find_files(self, ignore_policies=True):
          """ Search shared and private assemblies and return a list of files.
          
          If any files are not found, return an empty list.
          
          IMPORTANT NOTE: For the purpose of getting the dependent assembly 
          files of an executable, the publisher configuration (aka policy)
          should be ignored (which is the default). Setting ignore_policies=False 
          is only useful to find out which files are actually loaded at
          runtime.
          
          """
          
          # Shared Assemblies:
          # http://msdn.microsoft.com/en-us/library/aa375996%28VS.85%29.aspx
          #
          # Private Assemblies:
          # http://msdn.microsoft.com/en-us/library/aa375674%28VS.85%29.aspx
          #
          # Assembly Searching Sequence:
          # http://msdn.microsoft.com/en-us/library/aa374224%28VS.85%29.aspx
          #
          # NOTE:
          # Multilanguage User Interface (MUI) support not yet implemented
          
          files = []
          
          languages = []
          if self.language not in (None, "", "*", "neutral"):
              languages.append(self.getlanguage())
              if "-" in self.language:
                  # language-culture syntax, e.g. en-us
                  # Add only the language part
                  languages.append(self.language.split("-")[0])
              if self.language not in ("en-us", "en"):
                  languages.append("en-us")
              if self.language != "en":
                  languages.append("en")
          languages.append(self.getlanguage("*"))
          
          winsxs = os.path.join(compat.getenv("SystemRoot"), "WinSxS")
          if not os.path.isdir(winsxs):
              logger.warn("No such dir %s", winsxs)
          manifests = os.path.join(winsxs, "Manifests")
          if not os.path.isdir(manifests):
              logger.warn("No such dir %s", manifests)
          if not ignore_policies and self.version:
              if sys.getwindowsversion() < (6, ):
                  # Windows XP
                  pcfiles = os.path.join(winsxs, "Policies")
                  if not os.path.isdir(pcfiles):
                      logger.warn("No such dir %s", pcfiles)
              else:
                  # Vista or later
                  pcfiles = manifests
          
          for language in languages:
              version = self.version
              
              # Search for publisher configuration
              if not ignore_policies and version:
                  # Publisher Configuration (aka policy)
                  # A publisher configuration file globally redirects 
                  # applications and assemblies having a dependence on one 
                  # version of a side-by-side assembly to use another version of 
                  # the same assembly. This enables applications and assemblies 
                  # to use the updated assembly without having to rebuild all of 
                  # the affected applications.
                  # http://msdn.microsoft.com/en-us/library/aa375680%28VS.85%29.aspx
                  #
                  # Under Windows XP and 2003, policies are stored as 
                  # <version>.policy files inside 
                  # %SystemRoot%\WinSxS\Policies\<name>
                  # Under Vista and later, policies are stored as 
                  # <name>.manifest files inside %SystemRoot%\winsxs\Manifests
                  redirected = False
                  if os.path.isdir(pcfiles):
                      logger.info("Searching for publisher configuration %s ...",
                                  self.getpolicyid(True, language=language))
                      if sys.getwindowsversion() < (6, ):
                          # Windows XP
                          policies = os.path.join(pcfiles, 
                                                  self.getpolicyid(True,
                                                                   language=language) + 
                                                  ".policy")
                      else:
                          # Vista or later
                          policies = os.path.join(pcfiles, 
                                                  self.getpolicyid(True,
                                                                   language=language) + 
                                                  ".manifest")
                      for manifestpth in glob(policies):
                          if not os.path.isfile(manifestpth):
                              logger.warn("Not a file %s", manifestpth)
                              continue
                          logger.info("Found %s", manifestpth)
                          try:
                              policy = ManifestFromXMLFile(manifestpth)
                          except Exception, exc:
                              logger.error("Could not parse file %s", manifestpth)
                              logger.exception(exc)
                          else:
                              logger.info("Checking publisher policy for "
                                          "binding redirects")
                              for assembly in policy.dependentAssemblies:
                                  if (not assembly.same_id(self, True) or
                                      assembly.optional):
                                      continue
                                  for redirect in assembly.bindingRedirects:
                                      if logger.isEnabledFor(logging.INFO):
                                          old = "-".join([".".join([str(i) 
                                                                    for i in 
                                                                    part]) 
                                                          for part in 
                                                          redirect[0]])
                                          new = ".".join([str(i) 
                                                          for i in
                                                          redirect[1]])
                                          logger.info("Found redirect for "
                                                      "version(s) %s -> %n",
                                                      old, new)
                                      if (version >= redirect[0][0] and
                                          version <= redirect[0][-1] and
                                          version != redirect[1]):
                                          logger.info("Applying redirect "
                                                      "%s -> %s",
                                                      ".".join([str(i) 
                                                                for i in
                                                                version]),
                                                      new)
                                          version = redirect[1]
                                          redirected = True
                      if not redirected:
                          logger.info("Publisher configuration not used")
              
              # Search for assemblies according to assembly searching sequence
              paths = []
              if os.path.isdir(manifests):
                  # Add winsxs search paths
                  paths.extend(glob(os.path.join(manifests, 
                                                 self.getid(language=language, 
                                                            version=version) + 
                                                 "_*.manifest")))
              if self.filename:
                  # Add private assembly search paths
                  dirnm = os.path.dirname(self.filename)
                  if language in (LANGUAGE_NEUTRAL_NT5, 
                                  LANGUAGE_NEUTRAL_NT6):
                      for ext in (".dll", ".manifest"):
                          paths.extend(glob(os.path.join(dirnm, self.name + ext)))
                          paths.extend(glob(os.path.join(dirnm, self.name, 
                                                         self.name + ext)))
                  else:
                      for ext in (".dll", ".manifest"):
                          paths.extend(glob(os.path.join(dirnm, language, 
                                                         self.name + ext)))
                      for ext in (".dll", ".manifest"):
                          paths.extend(glob(os.path.join(dirnm, language, 
                                                         self.name, 
                                                         self.name + ext)))
              logger.info("Searching for assembly %s ...",
                          self.getid(language=language, version=version))
              for manifestpth in paths:
                  if not os.path.isfile(manifestpth):
                      logger.warn("Not a file %s", manifestpth)
                      continue
                  assemblynm = os.path.basename(
                      os.path.splitext(manifestpth)[0])
                  try:
                      if manifestpth.endswith(".dll"):
                          logger.info("Found manifest in %s", manifestpth)
                          manifest = ManifestFromResFile(manifestpth, [1])
                      else:
                          logger.info("Found manifest %s", manifestpth)
                          manifest = ManifestFromXMLFile(manifestpth)
                  except Exception, exc:
                      logger.error("Could not parse manifest %s", manifestpth)
                      logger.exception(exc)
                  else:
                      if manifestpth.startswith(winsxs):
                          assemblydir = os.path.join(winsxs, assemblynm)
                          if not os.path.isdir(assemblydir):
                              logger.warn("No such dir %s", assemblydir)
                              logger.warn("Assembly incomplete")
                              return []
                      else:
                          assemblydir = os.path.dirname(manifestpth)
                      files.append(manifestpth)
                      for file_ in self.files or manifest.files:
                          fn = file_.find(assemblydir)
                          if fn:
                              files.append(fn)
                          else:
                              # If any of our files does not exist,
                              # the assembly is incomplete
                              logger.warn("Assembly incomplete")
                              return []
                  return files
  
          logger.warn("Assembly not found")
          return []