def METHOD_NAME(workers, use_cloud_pickle=False):
    try:
        from concurrent.futures import ProcessPoolExecutor, as_completed
    except ImportError:
        return None
    def mk_submitter(pool, use_cloud_pickle):
        def submit_direct(func, *args, **kwargs):
            return pool.submit(func, *args, **kwargs)
        def submit_cloud_pickle(func, *args, **kwargs):
            from cloudpickle import dumps
            return pool.submit(_run_cloud_pickled_function, dumps(func), *args, **kwargs)
        return submit_cloud_pickle if use_cloud_pickle else submit_direct
    class MultiprocessingExecutor(object):
        def __init__(self, pool, use_cloud_pickle):
            self._pool = pool
            self._submitter = mk_submitter(pool, use_cloud_pickle)
        def __repr__(self):
            max_workers = self._pool.__dict__.get('_max_workers', '??')
            return 'Multiprocessing ({})'.format(max_workers)
        def submit(self, func, *args, **kwargs):
            return self._submitter(func, *args, **kwargs)
        def map(self, func, iterable):
            return [self.submit(func, data) for data in iterable]
        @staticmethod
        def get_ready(futures):
            completed = []
            failed = []
            pending = []
            for f in futures:
                if f.done():
                    if f.exception():
                        failed.append(f)
                    else:
                        completed.append(f)
                else:
                    pending.append(f)
            return completed, failed, pending
        @staticmethod
        def as_completed(futures):
            return as_completed(futures)
        @classmethod
        def next_completed(cls, futures, default):
            results = list(futures)
            if not results:
                return default, results
            result = next(cls.as_completed(results), default)
            results.remove(result)
            return result, results
        @staticmethod
        def results(futures):
            return [future.result() for future in futures]
        @staticmethod
        def result(future):
            return future.result()
        @staticmethod
        def release(future):
            pass
    if workers <= 0:
        return None
    return MultiprocessingExecutor(ProcessPoolExecutor(workers), use_cloud_pickle)