code: def lookup_symbols(self,
                         symbols,
                         as_of_date,
                         fuzzy=False,
                         country_code=None):
          
          if not symbols:
              return []
  
          multi_country = country_code is None
          if fuzzy:
              f = self._lookup_symbol_fuzzy
              mapping = self._choose_fuzzy_symbol_ownership_map(country_code)
          else:
              f = self._lookup_symbol_strict
              mapping = self._choose_symbol_ownership_map(country_code)
  
          if mapping is None:
              raise SymbolNotFound(symbol=symbols[0])
  
          memo = {}
          out = []
          append_output = out.append
          for sym in symbols:
              if sym in memo:
                  append_output(memo[sym])
              else:
                  equity = memo[sym] = f(
                      mapping,
                      multi_country,
                      sym,
                      as_of_date,
                  )
                  append_output(equity)
          return out
docs: Lookup a list of equities by symbol.
  
          Equivalent to::
  
              [finder.lookup_symbol(s, as_of, fuzzy) for s in symbols]
  
          but potentially faster because repeated lookups are memoized.
  
          Parameters
          ----------
          symbols : sequence[str]
              Sequence of ticker symbols to resolve.
          as_of_date : pd.Timestamp
              Forwarded to ``lookup_symbol``.
          fuzzy : bool, optional
              Forwarded to ``lookup_symbol``.
          country_code : str or None, optional
              The country to limit searches to. If not provided, the search will
              span all countries which increases the likelihood of an ambiguous
              lookup.
  
          Returns
          -------
          equities : list[Equity]