docs: def load_resources(bucket, prefix, region, account_config, accounts,
                     assume, start, end, resources, store, db, verbose, debug):
      """load resources into resource database."""
      logging.basicConfig(level=(verbose and logging.DEBUG or logging.INFO))
      logging.getLogger('botocore').setLevel(logging.WARNING)
      logging.getLogger('s3transfer').setLevel(logging.WARNING)
      start = date_parse(start)
      end = date_parse(end)
  
      if not resources:
          resources = ['NetworkInterface', 'Instance', 'LoadBalancer']
  
      account_map = {}
      data = yaml.safe_load(account_config.read())
      for a in data.get('accounts', ()):
          if accounts and (a['name'] in accounts or a['account_id'] in accounts):
              account_map[a['account_id']] = a
          elif not accounts:
              account_map[a['account_id']] = a
      account_ids = list(account_map)
  
      executor = ProcessPoolExecutor
      if debug:
          from c7n.executor import MainThreadExecutor
          MainThreadExecutor.c7n_async = False
          executor = MainThreadExecutor
  
      stats = Counter()
      t = time.time()
      with executor(max_workers=multiprocessing.cpu_count()) as w:
          futures = {}
          for a in account_ids:
              for r in resources:
                  futures[w.submit(
                      process_account_resources, a, bucket, prefix,
                      region, store, start, end, r)] = (a, r)
  
          indexer = RESOURCE_FILE_INDEXERS[r]
          for f in as_completed(futures):
              a, r = futures[f]
              if f.exception():
                  log.error("account:%s error:%s", a, f.exception())
                  continue
              files, dl_stats = f.result()
              idx_stats = indexer(db, resource_config_iter(files))
              log.info(
                  "loaded account:%s files:%d bytes:%s events:%d resources:%d idx-time:%d dl-time:%d",
                  account_map[a]['name'], len(files),
                  human_size(dl_stats['DownloadSize'] + dl_stats['CacheSize']),
                  idx_stats['Records'],
                  idx_stats['RowCount'],
                  idx_stats['IndexTime'],
                  dl_stats['FetchTime'])
              stats.update(dl_stats)
              stats.update(idx_stats)
      log.info("Loaded %d resources across %d accounts in %0.2f",
               stats['RowCount'], len(account_ids), time.time() - t)