docs: def performSearch(domains=[], nThreads=16, launchWhois=False):
      """
      Method to perform the mail verification process.
  
      Arguments
      ---------
          domains: List of domains to check.
          nThreads: Number of threads to use.
          launchWhois: Sets if whois queries will be launched.
  
      Returns
      -------
          list: A list containing the results as i3visio entities.
      """
      results = []
  
      # Using threads in a pool if we are not running the program in main
      args = []
  
      # Returning None if no valid domain has been returned
      if len(domains) == 0:
          return results
  
      # If the process is executed by the current app, we use the Processes. It is faster than pools.
      if nThreads <= 0 or nThreads > len(domains):
          nThreads = len(domains)
  
      # Launching the Pool
      # ------------------
      # Example catched from: https://stackoverflow.com/questions/11312525/catch-ctrlc-sigint-and-exit-multiprocesses-gracefully-in-python
      try:
          original_sigint_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
          pool = Pool(nThreads)
          signal.signal(signal.SIGINT, original_sigint_handler)
      except ValueError:
          # To avoid: ValueError: signal only works in main thread
          pool = Pool(nThreads)
  
      poolResults = []
      try:
          def log_result(result):
              # This is called whenever foo_pool(i) returns a result.
              # result_list is modified only by the main process, not the pool workers.
              poolResults.append(result)
  
          for d in domains:
              # We need to create all the arguments that will be needed
              parameters = (d, launchWhois,)
              pool.apply_async(pool_function, args=parameters, callback=log_result )
  
          # Waiting for results to be finished
          while len(poolResults) < len(domains):
              pass
          # Closing normal termination
          pool.close()
      except KeyboardInterrupt:
          print(general.warning("\nProcess manually stopped by the user. Terminating workers.\n"))
          pool.terminate()
          print(general.warning("The following domains were not processed:"))
          pending_tld = ""
          for d in domains:
              processed = False
              for processedDomain in poolResults:
                  if str(d) == processedDomain["platform"]:
                      processed = True
                      break
              if not processed:
                  print(general.warning("\t- " + str(d["domain"])))
                  pending_tld += " " + str(d["tld"])
          print(general.warning("[!] If you want to relaunch the app with these domains you can always run the command with: "))
          print(general.warning("\t domainfy ... -t none -u " + pending_tld))
          print(general.warning("[!] If you prefer to avoid these platforms you can manually evade them for whatever reason with: "))
          print(general.warning("\t domainfy ... -x " + pending_tld))
      pool.join()
  
      # Processing the results
      # ----------------------
      for serArray in poolResults:
          data = serArray["data"]
          # We need to recover the results and check if they are not an empty json or None
          if data != None and data != {}:
              results.append(data)
      return results