code: def maximum_ell_bundle(self, ell):
          
          (x0, x1, y0, y1) = ell
          hlines = self.maximum_hline_bundle(y0, x0, x1)
          vlines = self.maximum_vline_bundle(x0, y0, y1)
  
          if self.random_bundles:
              shuffle(hlines)
              shuffle(vlines)
  
          return [v + h for h, v in zip(hlines, vlines)]
docs: Return a maximum ell bundle in the rectangle bounded by
  
              :math:`\{x0,x1\} \\times \{y0,y1\}`
  
          with vertical component
  
              :math:`(x0,y0) ... (x0,y1) = {x0} \\times \{y0,...,y1\}`
  
          and horizontal component
  
              :math:`(x0,y0) ... (x1,y0) = \{x0,...,x1\} \\times \{y0\}`.
  
          Note that we don't require :math:`x0 \leq x1` or :math:`y0 \leq y1`.  We go
          through some shenanigans so that the qubits we return
          are all in a path.  A nice side-effect of this is that
  
              >>> chains = maximum_ell_bundle(...)
              >>> edges = [zip(path,path[:-1]) for path in chains]
  
          where ``edges`` will be a list of lists of chain edges.
  
          INPUTS::
              ell: a tuple of 4 integers defining the ell, ``(x0, x1, y0, y1)``
  
          OUTPUT::
              chains: list of lists of qubits
  
          Note: this function only to be called to construct a
          native clique embedding *after* the block embedding has
          been constructed.  Using this to evaluate the goodness
          of an ell block will be slow.