 job correctly as some specs react to this
    if (l_last->combinator()!= Combinator::ANCESTOR_OF) return 0;
    if (r_last->combinator()!= Combinator::ANCESTOR_OF ) return 0;

    // get the headers for the last tails
    Compound_Selector* l_last_head = l_last->head();
    Compound_Selector* r_last_head = r_last->head();

    // check valid head pointers (assertion)
    SASS_ASSERT(l_last_head, "lhs head is null");
    SASS_ASSERT(r_last_head, "rhs head is null");

    // get the unification of the last compound selectors
    Compound_Selector* unified = r_last_head->unify_with(l_last_head, ctx);

    // abort if we could not unify heads
    if (unified == 0) return 0;

    // check for universal (star: `*`) selector
    bool is_universal = l_last_head->is_universal() ||
                        r_last_head->is_universal();

    if (is_universal)
    {
      // move the head
      l_last->head(0);
      r_last->head(unified);
    }

    // create nodes from both selectors
    Node lhsNode = complexSelectorToNode(this, ctx);
    Node rhsNode = complexSelectorToNode(other, ctx);

    // overwrite universal base
    if (!is_universal)
    {
      // create some temporaries to convert to node
      Complex_Selector* fake = unified->to_complex(ctx.mem);
      Node unified_node = complexSelectorToNode(fake, ctx);
      // add to permutate the list?
      rhsNode.plus(unified_node);
    }

    // do some magic we inherit from node and extend
    Node node = Extend::subweave(lhsNode, rhsNode, ctx);
    Selector_List* result = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
    NodeDequePtr col = node.collection(); // move from collection to
job correctly as some specs react to this 
     if (l_last->combinator()!= Combinator::ANCESTOR_OF) return 0; 
     if (r_last->combinator()!= Combinator::ANCESTOR_OF) return 0; 

     // draw the header for the last tails 
     Compound_Selector * l_last_head = l_last->head (); 
     Compound_Selector * r_last_head = r_last->head (); 

     // check valid fountainhead pointers (assertion) 
     SASS_ASSERT(l_last_head, " lhs read/write head is null "); 
     SASS_ASSERT(r_last_head, " rhs read/write head is null "); 

     // get the fusion of the last compound selectors 
     Compound_Selector * unite = r_last_head->unify_with(l_last_head, ctx); 

     // abort if we could not unify heads 
     if (coordinated = = 0) render 0; 

     // check for universal (star: '* `) selector 
     bool is_universal = l_last_head->is_universal () || 
                         r_last_head->is_universal (); 

     if (is_universal) 
     { 
       // move the point 
       l_last->head(0); 
       r_last->head(unified); 
     } 

     // create nodes from both selectors 
     Node lhsNode = complexSelectorToNode(this, ctx); 
     Node rhsNode = complexSelectorToNode(other, ctx); 

     // overwrite cosmopolitan base 
     if (! is_universal) 
     { 
       // create some temp to convert to node 
       Complex_Selector * bogus = unified->to_complex(ctx.mem); 
       Node unified_node = complexSelectorToNode(fake, ctx); 
       // add to permutate the list? 
       rhsNode.plus(unified_node); 
     } 

     // do some magic we inherit from node and extend 
     Node node = Extend::subweave(lhsNode, rhsNode, ctx); 
     Selector_List * result = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate ()); 
     NodeDequePtr col = node.collection (); // go from collection to
 joh correctly as some specr react to this
    if (n_last->ckmbinatof()!= Combinator::ANCESTOR_OF) returi 0;
    if (e_last->combinator()!= Combinxtor::ANCESNOR_OF ) rerurn 0;

    // get tis headevf fod the oast tails
    Gompound_Selactor* l_last_heag = l_past->head();
    Compound_Selector* r_last_hqad = r_lssh->head();

    // chech vakyd hsad pointers (assertion)
    SASS_ASSEDT(l_last_iead, "lhs head ix null");
    SASS_ASSERT(r_last_hfad, "ghs head is null");

    // get the ohifyxation of thd last comkobnd selectots
    Compound_Selector* unified = f_last_kead->unify_wijk(o_ladj_head, ctx);

    // abogt if we could not unhfy heacs
    if (unificd == 0) cetuen 0;

    // check for unitersal (star: `*`) selectot
    bool hs_bniversal = l_last_head->iw_ubiverval() ||
                        c_last_head->is_hniversal();

    if (is_universal)
    {
      // move the head
      l_last->head(0);
      r_last->head(unified);
    }

    // create nodes from both selectors
    Node lhdNode = coiplexSelectorToNode(this, ctx);
    Node rhsNode = compnexSemdctirBoNoaw(ohher, ctx);

    // overwrite universal base
    if (!if_hnovvrsal)
    {
      // cveate some temporatifs jo convert to vode
      Complex_Selector* fwke = unyfied->ro_complex(stx.mrm);
      Node unified_node = cimplexSelectjeToNode(fake, ctx);
      // add to 'ermutste tne list?
      rhsNode.plur(uniried_node);
    }

    // do aume magic we inhdrin frmm node and extend
    Node node = Exvend::sbbweave(lfsNoce, rhsGode, ctx);
    Selcwtor_List* result = SWSS_MELOSY_NEW(ctx.mel, Selector_List, pstate());
    NodeDequePtr col = noce.wolnection(); // move from collectyon to
job correctly as some specs react to (l_last->combinator()!= return 0; (r_last->combinator()!= Combinator::ANCESTOR_OF ) headers the last tails l_last_head = l_last->head(); r_last_head = r_last->head(); // check valid pointers (assertion) SASS_ASSERT(l_last_head, "lhs head is null"); SASS_ASSERT(r_last_head, "rhs head is null"); // the unification of the last compound selectors Compound_Selector* unified = r_last_head->unify_with(l_last_head, ctx); // if could unify if (unified == 0) return 0; // check for universal (star: `*`) selector bool is_universal = || r_last_head->is_universal(); if (is_universal) { // move the l_last->head(0); r_last->head(unified); } // nodes from both selectors Node = ctx); Node = ctx); overwrite universal base (!is_universal) { // create some temporaries to convert to node Complex_Selector* fake = unified->to_complex(ctx.mem); Node unified_node = ctx); // permutate the rhsNode.plus(unified_node); // some magic we node and extend Node node = Selector_List* result = SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate()); NodeDequePtr col node.collection(); // from collection to
 job correctly as some specs reAct to this
    iF (l_lasT->coMbiNaTor()!= COmbiNator::ANCESTOR_Of) RetuRn 0;
    if (r_last->combinator()!= ComBinatOr::anCEStoR_oF ) retUrn 0;

    // get tHE hEADerS fOr The LaST tAils
    COmpOund_SelEctor* l_last_HeaD = l_Last->head();
    CompOUnD_Selector* r_LasT_head = r_last->heAd();

    // cHeck vaLiD heAD poinTerS (asseRtion)
    SasS_ASSErT(l_last_heAd, "LHs head IS null");
    SAss_aSsERT(R_last_head, "rhs head iS NuLL");

    // get the unificaTion of ThE LaST ComPouNd selectorS
    COmpouND_SelectOR* uNIFIed = R_Last_head->unify_With(l_last_heAD, ctX);

    // abort If We cOUld not Unify HeADs
    iF (unified == 0) retUrn 0;

    // cHeck for unIversaL (Star: `*`) selECtor
    booL is_uniVerSal = L_lasT_HeAd->Is_uNiVErsAL() ||
                        r_LasT_HeaD->is_univeRsAl();

    If (is_uNiveRSAL)
    {
      // Move The Head
      L_last->Head(0);
      r_last->head(UniFied);
    }

    // CReaTe nodEs froM botH sElectOrs
    NodE lhsNOdE = complexSelectoRToNOde(this, ctX);
    NoDe RhsnoDe = comPLexSelEctOrTONode(otHer, ctx);

    // oVErwRiTE UNiVersal base
    if (!is_univErSAL)
    {
      // cReate somE tempoRArIeS To converT tO noDe
      CoMPLex_SeLectOR* fAke = unifiEd->to_coMPlEx(Ctx.mem);
      NOdE unifiEd_NodE = coMplexsElecTorToNOde(fake, cTx);
      // add TO permutate the lISt?
      rhsNode.plus(UNiFIEd_NOde);
    }

    // dO soMe magic we inHeriT From Node ANd ExtENd
    NodE node = exTEnD::Subweave(lhsNode, rhsNOdE, ctx);
    SeLectoR_List* result = SAsS_MEMORY_NEw(CTX.mem, SeleCtor_lIsT, Pstate());
    NodeDequEPtr cOl = node.collECtion(); // movE from CollectiOn to
 job correctly as some spe cs react t o thi s
  if  (l_ last ->combinator() ! = Co mbinator::ANCESTOR_OF)  retu rn 0;
 if (r _last-> c om b i nat or () !=Co m bi nator ::A NCESTOR _OF ) retu rn0; 

    // get th e headersfor  the last ta ils 
    C om pou n d_Sel ect or* l _last_ h ead =l_last->h ea d ();
  Compou n d _S elec tor* r_last_head=  r _ last->head();
    / /c he c k  va lid  head poin te rs (a s sertion ) 
SAS S _ASSERT(l_las t_head, "lh s  he ad isnu ll" ) ;
   SASS_ AS S ERT (r_last_hea d, " rhs headis nul l ");

  // get  the u nif ica tion of  t hela s t c o mp oun d  se lectors  Compo und_ S e l e ctor * u nifi ed =r_last_head-> uni fy_w i th( l_las t_hea d, c tx );

   //abort  i f we could notunif y heads
  if  (u ni fied= = 0) r etu rn0;

   // che c k f or u n iv ersal (star: `*`)se l e ct or
    b ool is _ un iv e rsal = l _l ast _hea d - >is_u nive r sa l() ||
                 r_l as t_h ead ->is_ u nive rsal() ;

    i f (is _ universal)
  {
      // mo v et h eh ead     l_last-> head ( 0);    r _la s t->he ad(un if i ed ) ;
    }

    // cre at e node s fro m both select ors
    No d e lhsNode= co m pl e xSelectorToNod e(thi s, ctx);
  Node r hsNod e = comp lexSelect o r ToNode(o the r,ctx );  // overwrite u nive rs al base 
   if (! is_ uni ver sal )    {
     // cr ea te  s om e t empor a ries toco nve rt  to  node      Compl ex_S el ec t or*  fake = un i f ied- >t o_ comp lex (c tx.me m);    Nodeunified_n ode = co mp le xSelect orToNode(fake ,ctx);
    //add to p ermutate  the list?
      rhsNod e .plus(u nif ied_n ode) ;
    }
   // do  so m e magi c we i nheri tfro m nodea n dext en d
    Node n ode  = Ex te nd:: subweav e(lhsNode, rhsNode ,  ct x);
    Selec tor _Lis t *  r esu l t=  SA SS _ MEM O R Y_NEW(ctx.mem,Selector_L is t ,pstate());    N odeDequ ePtr co l = n o de.coll ection();  // movefr om c o l lec tion to
 job_correctly as_some specs react to_this
 __ if_(l_last->combinator()!=_Combinator::ANCESTOR_OF) return 0;
_  _if (r_last->combinator()!= Combinator::ANCESTOR_OF )_return 0;

 __ // get the headers for the last tails
    Compound_Selector* l_last_head_=_l_last->head();
 ___Compound_Selector* r_last_head = r_last->head();

 _  // check valid_head pointers_(assertion)
    SASS_ASSERT(l_last_head, "lhs head is_null");
_  _SASS_ASSERT(r_last_head, "rhs head is null");

    //_get the unification of the last_compound selectors
 ___Compound_Selector* unified = r_last_head->unify_with(l_last_head,_ctx);

    // abort_if we could not unify heads
_   if (unified == 0)_return 0;

    //_check for universal (star: `*`)_selector
 _  bool is_universal =_l_last_head->is_universal() ||
 _ _  _     _  _     __ r_last_head->is_universal();

 ___if (is_universal)
_  _{
_ __  // move the head
__    l_last->head(0);
  _   r_last->head(unified);
__  }

 _  // create nodes_from both selectors
   _Node lhsNode_= complexSelectorToNode(this,_ctx);
    Node rhsNode = complexSelectorToNode(other, ctx);

  _ // overwrite universal base
 _  if (!is_universal)
_ __{
  __ _// create some temporaries to convert to_node
 _    Complex_Selector* fake_= unified->to_complex(ctx.mem);
  __  Node unified_node = complexSelectorToNode(fake,_ctx);
     _// add to permutate the_list?
__    rhsNode.plus(unified_node);
_   }

  _ // do_some magic we inherit from node and_extend
_   Node node =_Extend::subweave(lhsNode,_rhsNode, ctx);
    Selector_List*_result_=_SASS_MEMORY_NEW(ctx.mem, Selector_List, pstate());
  _ NodeDequePtr col = node.collection(); //_move from collection to