docs: def performSearch(emails=[], nThreads=16, secondsBeforeTimeout=5):
      """
      Method to perform the mail verification process.
  
      Args:
      -----
          emails: list of emails to be verified.
          platforms: list of strings representing the wrappers to be used.
          nThreads: the number of threads to be used. Default: 16 threads.
          secondsBeforeTimeout: number of seconds to wait before raising a
              timeout. Default: 5 seconds.
  
      Returns:
      --------
          The results collected.
      """
      # Getting starting time
      _startTime = time.time()
  
      def hasRunOutOfTime(oldEpoch):
          """
          Function that checks if a given time has passed.
  
          It verifies whether the oldEpoch has passed or not by checking if the
          seconds passed are greater.
  
          Arguments
          ---------
              oldepoch: Seconds passed since 1970 as returned by `time.time()`.
  
          Returns
          -------
              A boolean representing whether it has run out of time.
          """
          now = time.time()
          return now - oldEpoch >= secondsBeforeTimeout
  
      results = []
  
      args = []
  
      # Grabbing all the emails that would be validated
      for e in emails:
          if weCanCheckTheseDomains(e):
              args.append((e))
  
      # Returning None if no valid domain has been returned
      if len(args) == 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(args):
          nThreads = len(args)
  
      # 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):
              """
              Callback to log the results by apply_async
              """
              poolResults.append(result)
  
          for m in emails:
              parameters = ( m, )
              res = pool.apply_async(pool_function, args=parameters, callback=log_result)
              try:
                  res.get(3)
              except TimeoutError as e:
                  general.warning("\n[!] Process timeouted for '{}'.\n".format(parameters))
          pool.close()
      except KeyboardInterrupt:
          print(general.warning("\n[!] Process manually stopped by the user. Terminating workers.\n"))
          pool.terminate()
  
          pending = ""
  
          print(general.warning("[!] The following email providers were not processed:"))
          for m in emails:
              processed = False
              for result in poolResults:
                  if str(m) in json.dumps(result["data"]):
                      processed = True
                      break
              if not processed:
                  print("\t- " + str(p))
                  pending += " " + str(m)
  
          print("\n")
          print(general.warning("If you want to relaunch the app with these platforms you can always run the command with: "))
          print("\t mailfy.py ... -p " + general.emphasis(pending))
          print("\n")
          print(general.warning("If you prefer to avoid these platforms you can manually evade them for whatever reason with: "))
          print("\t mailfy.py ... -x " + general.emphasis(pending))
          print("\n")
      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)
  
      pool.close()
  
      return results