code: def largestNativeBiClique(self, chain_imbalance=0, max_chain_length=None):
          
          def f(x):
              return x.largestNativeBiClique(chain_imbalance=chain_imbalance,
                                             max_chain_length=max_chain_length)
          objective = self._objective_bestscore
          emb = self._map_to_processors(f, objective)
          return self._translate_partitioned(emb)
docs: Returns a native embedding for the complete bipartite graph :math:`K_{n,m}`
          for `n <= m`; where `n` is as large as possible and `m` is as large as
          possible subject to `n`.  The native embedding of a complete bipartite
          graph is a set of horizontally-aligned qubits connected in lines
          together with an equal-sized set of vertically-aligned qubits
          connected in lines.
  
          INPUTS:
              chain_imbalance: how big of a difference to allow between the
              chain lengths on the two sides of the bipartition. If ``None``,
              then we allow an arbitrary imbalance.  (default: ``0``)
  
              max_chain_length: longest chain length to consider or None if chain
              lengths are allowed to be unbounded.  (default: ``None``)
  
          OUTPUT:
              embedding (tuple): a tuple of two lists containing lists of qubits.
              If ``embedding = (A_side, B_side)``, the lists found in ``A_side`` and
              ``B_side`` are chains of qubits. These lists of qubits are arranged so that
  
              >>> [zip(chain,chain[1:]) for chain in A_side]
  
              and
  
              >>> [zip(chain,chain[1:]) for chain in B_side]
  
              are lists of valid couplers.