          pipexe.extend(["install", "-qq", "--no-cache-dir"])
          # install as user to solve perm restriction
          if not self.env.is_admin and not self.env.is_virtualenv:
              pipexe.append("--user")
          if package.startswith("dlib"):
              if not self.env.enable_cuda:
                  pipexe.extend(["--install-option=--no", "--install-option=DLIB_USE_CUDA"])
              if self.env.os_version[0] == "Windows":
                  pipexe.extend(["--global-option=-G", "--global-option=Visual Studio 14 2015"])
              msg = ("Compiling {}. This will take a while...\n"
                     "Please ignore the following UserWarning: "
                     "'Disabling all use of wheels...'".format(package))
          else:
              msg = "Installing {}".format(package)
          self.output.info(msg)
          pipexe.append(package)
          try:
              run(pipexe, check=True)
          except CalledProcessError:
 
</s> remove             "2b. If you do not want to use Anaconda, or if you wish to compile DLIB with GPU\n"
            "support you will need to manually install CUDA and cuDNN:\n"
 </s> add             "2b. If you do not want to use Anaconda you will need to manually install CUDA and "
            "cuDNN:\n" </s> remove     def check_system_dependencies(self):
        """ Check that system applications are installed """
        self.output.info("Checking System Dependencies...")
        self.cmake_check()
        if self.env.os_version[0] == "Windows":
            self.visual_studio_check()
            self.check_cplus_plus()
        if self.env.os_version[0] == "Linux":
            self.gcc_check()
            self.gpp_check()

    def gcc_check(self):
        """ Check installed gcc version for linux """
        chk = Popen("gcc --version", shell=True, stdout=PIPE, stderr=PIPE)
        stdout, stderr = chk.communicate()
        if stderr:
            self.output.error("gcc not installed. Please install gcc for your distribution")
            return
        gcc = [re.sub(" +", " ", line.strip())
               for line in stdout.decode(self.env.encoding).splitlines()
               if line.lower().strip().startswith("gcc")][0]
        version = gcc[gcc.rfind(" ") + 1:]
        self.output.info("gcc version: {}".format(version))

    def gpp_check(self):
        """ Check installed g++ version for linux """
        chk = Popen("g++ --version", shell=True, stdout=PIPE, stderr=PIPE)
        stdout, stderr = chk.communicate()
        if stderr:
            self.output.error("g++ not installed. Please install g++ for your distribution")
            return
        gpp = [re.sub(" +", " ", line.strip())
               for line in stdout.decode(self.env.encoding).splitlines()
               if line.lower().strip().startswith("g++")][0]
        version = gpp[gpp.rfind(" ") + 1:]
        self.output.info("g++ version: {}".format(version))

    def cmake_check(self):
        """ Check CMake is installed """
        chk = Popen("cmake --version", shell=True, stdout=PIPE, stderr=PIPE)
        stdout, stderr = chk.communicate()
        stdout = stdout.decode(self.env.encoding)
        if stderr and self.env.os_version[0] == "Windows":
            stdout, stderr = self.cmake_check_windows()
        if stderr:
            self.output.error("CMake could not be found. See "
                              "https://github.com/deepfakes/faceswap/blob/master/INSTALL.md#cmake "
                              "for instructions")
            return
        cmake = [re.sub(" +", " ", line.strip())
                 for line in stdout.splitlines()
                 if line.lower().strip().startswith("cmake")][0]
        version = cmake[cmake.rfind(" ") + 1:]
        self.output.info("CMake version: {}".format(version))

    def cmake_check_windows(self):
        """ Additional checks for cmake on Windows """
        chk = Popen("wmic product where \"name = 'cmake'\" get installlocation,version",
                    shell=True, stdout=PIPE, stderr=PIPE)
        stdout, stderr = chk.communicate()
        if stderr:
            return False, stderr
        lines = [re.sub(" +", " ", line.strip())
                 for line in stdout.decode(self.env.encoding).splitlines()
                 if line.strip()]
        stdout = lines[1]
        location = stdout[:stdout.rfind(" ")] + "bin"
        self.output.info("CMake not found in %PATH%. Temporarily adding: \"{}\"".format(location))
        os.environ["PATH"] += ";{}".format(location)
        stdout = "cmake {}".format(stdout)
        return stdout, False

    def visual_studio_check(self):
        """ Check Visual Studio 2015 is installed for Windows

            Somewhat hacky solution which checks for the existence
            of the VS2015 Performance Report
        """
        chk = Popen("reg query HKLM\\SOFTWARE\\Microsoft\\VisualStudio\\14.0\\VSPerf",
                    shell=True, stdout=PIPE, stderr=PIPE)
        _, stderr = chk.communicate()
        if stderr:
            self.output.error("Visual Studio 2015 could not be found. See "
                              "https://github.com/deepfakes/faceswap/blob/master/"
                              "INSTALL.md#microsoft-visual-studio-2015 for instructions")
            return
        self.output.info("Visual Studio 2015 version: 14.0")

    def check_cplus_plus(self):
        """ Check Visual C++ Redistributable 2015 is instlled for Windows """
        keys = (
            "HKLM\\SOFTWARE\\Classes\\Installer\\Dependencies\\"
            "{d992c12e-cab2-426f-bde3-fb8c53950b0d}",
            "HKLM\\SOFTWARE\\WOW6432Node\\Microsoft\\VisualStudio\\14.0\\VC\\Runtimes\\x64")
        for key in keys:
            chk = Popen("reg query {}".format(key), shell=True, stdout=PIPE, stderr=PIPE)
            stdout, stderr = chk.communicate()
            if stdout:
                break
        if stderr:
            self.output.error("Visual C++ 2015 could not be found. Make sure you have selected "
                              "'Visual C++' in Visual Studio 2015 Configuration or download the "
                              "Visual C++ 2015 Redistributable from: "
                              "https://www.microsoft.com/en-us/download/details.aspx?id=48145")
            return
        vscpp = [re.sub(" +", " ", line.strip())
                 for line in stdout.decode(self.env.encoding).splitlines()
                 if line.lower().strip().startswith(("displayname", "version"))][0]
        version = vscpp[vscpp.find("REG_SZ") + 7:]
        self.output.info("Visual Studio C++ version: {}".format(version))

 </s> add  </s> remove                     except TypeError:
                        score = float("inf")
                    except ZeroDivisionError:
 </s> add                     except (TypeError, ValueError, ZeroDivisionError): </s> remove                 ExecWait "$\"$dirTemp\Miniconda3.exe$\" ${flagsConda}" $0
 </s> add                 ExecDos::exec /NOUNLOAD /ASYNC /DETAILED "$\"$dirTemp\Miniconda3.exe$\" ${flagsConda}"
                pop $0
                ExecDos::wait $0
                pop $0
        msg = "Installing {}".format(package)
          pipexe.extend(["install", "-qq", "--no-cache-dir"])
          # install as user to solve perm restriction
          if not self.env.is_admin and not self.env.is_virtualenv:
              pipexe.append("--user")
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
        msg = "Installing {}".format(package)
          self.output.info(msg)
          pipexe.append(package)
          try:
              run(pipexe, check=True)
          except CalledProcessError:
keep keep keep keep replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Remove dlib (#725)

* Sort to vgg_face. Remove Face Recognition requirements

* Remove dlib components from setup.py

* Remove dlib from Windows Installer script

* Remove dlib and cmake from requirements.txt

* Update INSTALL.md to remove all dlib requirements

* Remove dlib and cmake from dockerfiles

* Windows installer. Output cli to details Window. Setup.py bugfix

* Skip FaceFilter if invalid paths passed in 
setup.py