code: def espresso_tts(*tts):
      
      for f in tts:
          if not isinstance(f, TruthTable):
              raise ValueError("expected a TruthTable instance")
  
      support = frozenset.union(*[f.support for f in tts])
      inputs = sorted(support)
  
      ninputs = len(inputs)
      noutputs = len(tts)
  
      cover = set()
      for i, point in enumerate(boolfunc.iter_points(inputs)):
          invec = [2 if point[v] else 1 for v in inputs]
          outvec = list()
          for f in tts:
              val = f.pcdata[i]
              if val == PC_ZERO:
                  outvec.append(0)
              elif val == PC_ONE:
                  outvec.append(1)
              elif val == PC_DC:
                  outvec.append(2)
              else:
                  raise ValueError("expected truth table entry in {0, 1, -}")
          cover.add((tuple(invec), tuple(outvec)))
  
      set_config(**CONFIG)
  
      cover = espresso(ninputs, noutputs, cover, intype=FTYPE|DTYPE|RTYPE)
      inputs = [exprvar(v.names, v.indices) for v in inputs]
      return _cover2exprs(inputs, noutputs, cover)
docs: Return a tuple of expressions optimized using Espresso.
  
      The variadic *tts* argument is a sequence of truth tables.
  
      For example::
  
         >>> from pyeda.boolalg.bfarray import exprvars
         >>> from pyeda.boolalg.table import truthtable
         >>> X = exprvars('x', 4)
         >>> f1 = truthtable(X, "0000011111------")
         >>> f2 = truthtable(X, "0001111100------")
         >>> f1m, f2m = espresso_tts(f1, f2)
         >>> f1m.equivalent(X[3] | X[0] & X[2] | X[1] & X[2])
         True
         >>> f2m.equivalent(X[2] | X[0] & X[1])
         True