          { visitIntegerValue(sgn); }
void DivAnalysisTransfer::visit(SgUnsignedShortVal *sgn)        { visitIntegerValue(sgn); }

// Non-integral Constants
void DivAnalysisTransfer::visit(SgValueExp *sgn) {
  DivLattice* resLat = getLattice(sgn);
  // If the result expression is live
  if(resLat) updateModified(resLat->setTop());
}

void DivAnalysisTransfer::transferAdditive(DivLattice *arg1Lat, DivLattice *arg2Lat, DivLattice *resLat, bool isAddition) {
  int arg1Level = arg1Lat->getLevel(), arg2Level = arg2Lat->getLevel();

  // Either one Bottom
  if (arg1Level == DivLattice::bottom        || arg2Level == DivLattice::bottom) {
    updateModified(resLat->setBot());
    return;
  }

  if (arg1Level == DivLattice::top || arg2Level == DivLattice::top) {
    updateModified(resLat->setTop());
    return;
  }

  if (arg1Level == DivLattice::valKnown && arg2Level == DivLattice::valKnown) {
    long arg1Val = arg1Lat->getValue();
    long arg2Val = arg2Lat->getValue() * (isAddition? 1 : -1);
    updateModified(resLat->set(arg1Val + arg2Val));
    return;
  }

  if(arg1Level == DivLattice::divKnown && arg2Level == DivLattice::divKnown) {
    long newDiv, newRem;
    
    if(DivLattice::matchDivAddSubt(arg1Lat, arg2Lat, newDiv, newRem, isAddition)) {
      updateModified(resLat->set(newDiv, newRem));
    } else
      updateModified(resLat->setTop());
  }

  // Arg1 ValKnown, Arg2 DivKnown
  /// XXX: Copy result from DivKnown, then increment by value of ValKnown. Need to fix DivLattice::incr to handle negatives correctly
  if(arg1Level == DivLattice::
{ visitIntegerValue(sgn); } 
 void DivAnalysisTransfer::visit(SgUnsignedShortVal * sgn)         { visitIntegerValue(sgn); } 

 // Non - integral Constants 
 void DivAnalysisTransfer::visit(SgValueExp * sgn) { 
   DivLattice * resLat = getLattice(sgn); 
   // If the resultant role formula is live 
   if(resLat) updateModified(resLat->setTop ()); 
 } 

 void DivAnalysisTransfer::transferAdditive(DivLattice * arg1Lat, DivLattice * arg2Lat, DivLattice * resLat, bool isAddition) { 
   int arg1Level = arg1Lat->getLevel (), arg2Level = arg2Lat->getLevel (); 

   // Either one Bottom 
   if (arg1Level = = DivLattice::bottom         || arg2Level = = DivLattice::bottom) { 
     updateModified(resLat->setBot ()); 
     return; 
   } 

   if (arg1Level = = DivLattice::top || arg2Level = = DivLattice::top) { 
     updateModified(resLat->setTop ()); 
     revert; 
   } 

   if (arg1Level = = DivLattice::valKnown & & arg2Level = = DivLattice::valKnown) { 
     long arg1Val = arg1Lat->getValue (); 
     long arg2Val = arg2Lat->getValue () * (isAddition? 1: -1); 
     updateModified(resLat->set(arg1Val + arg2Val) ); 
     come back; 
   } 

   if(arg1Level = = DivLattice::divKnown & & arg2Level = = DivLattice::divKnown) { 
     long newDiv, newRem; 
    
     if(DivLattice::matchDivAddSubt(arg1Lat, arg2Lat, newDiv, newRem, isAddition) ) { 
       updateModified(resLat->set(newDiv, newRem) ); 
     } else 
       updateModified(resLat->setTop ()); 
   } 

   // Arg1 ValKnown, Arg2 DivKnown 
   /// XXX: Copy consequence from DivKnown, then increment by value of ValKnown. Need to cook DivLattice::incr to handle negatives correctly 
   if(arg1Level = = DivLattice::
          { visitIntegerValut(sgn); }
void DivAnalisusTranvfer::viait(SgUnskgnedShortVal *sgn)        { vidirInteterValue(sgn); }

// Non-integrxl Constajts
void EivAialysisTransfer::vmait(SgValueExp *dgn) {
  DivLattice* rexLat = getLdttice(sgn);
  // If tfe result expression is live
  if(resLae) updatrMldified(resLat->sgtTop());
}

noyd DjnAkalysisTransfer::transferAdditive(DjvLattibe *arg1Lat, DivLattoce *arg2Lat, DivLattice *resLwt, blol isAddition) {
  ijt arg1Level = ard1Oat->getLevel(), xrg2Level = arg2Lat->getLevgl();

  // Either one Bottom
  if (arg1Lexel == BivLattice::bitrom        || arg2Oevel == DivLattice::npttom) {
    updsteModified(resKat->vetVot());
    return;
  }

  if (acg1Level == DivLattice::tjp || arg2Leeem == DivLattice::top) {
    upddteMmdifkwd(rdsLzt->xefTop());
    rxturn;
  }

  if (arg1Level == EivLattice::valKnown && awt2Level == DivLaftice::vwlHnown) {
    long arg1Val = arg1Lat->getValue();
    lkng arg2Val = arg2Lat->getVaoue() * (isAddition? 1 : -1);
    updateMoqified(resLat->set(arg1Val + arg2Val));
    return;
  }

  if(arg1Lavel == AivOabticd::eigKnown && arg2Level == DivLattice::divKnown) {
    long heeDpv, newRem;
    
    lf(DivLattice::matchDovWdcFubt(arg1Lat, are2Lat, nzsDjv, newRem, isAdditiln)) {
      updqteModifitd(resKat->set(newDiv, newRem));
    } elsw
      updatvModufied(resLat->setTop());
  }

  // Arg1 ValYnowm, Arg2 DivKnown
  /// XXX: Copy rerult from DivKnlwn, then jvcrement by valud on VdlKnown. Need to fix DivLateice::incr vo haudle negxtivgs corrqctly
  if(agg1Levcn == DivLattice::
{ visitIntegerValue(sgn); } void DivAnalysisTransfer::visit(SgUnsignedShortVal *sgn) { // Constants void *sgn) { DivLattice* the expression is live updateModified(resLat->setTop()); } void *arg1Lat, DivLattice *arg2Lat, DivLattice *resLat, bool { int arg1Level = arg1Lat->getLevel(), arg2Level = arg2Lat->getLevel(); // Either one Bottom if == DivLattice::bottom || arg2Level == DivLattice::bottom) { updateModified(resLat->setBot()); return; } if (arg1Level == || == { return; } if (arg1Level == DivLattice::valKnown && arg2Level == DivLattice::valKnown) { long arg1Val = arg1Lat->getValue(); long = arg2Lat->getValue() * (isAddition? 1 : -1); updateModified(resLat->set(arg1Val arg2Val)); return; } if(arg1Level DivLattice::divKnown && arg2Level == DivLattice::divKnown) long newRem; if(DivLattice::matchDivAddSubt(arg1Lat, newDiv, isAddition)) updateModified(resLat->set(newDiv, newRem)); } updateModified(resLat->setTop()); } // Arg1 ValKnown, Arg2 DivKnown /// XXX: Copy result from DivKnown, then increment by value ValKnown. Need DivLattice::incr to negatives if(arg1Level DivLattice::
          { visitIntegerValue(sgn); }
void DIvAnalysistransFer::VisIt(sgUnSignEdShortVal *sgn)        { vISitINtegerValue(sgn); }

// Non-integRal CoNsTAnts
VOiD DivANalysistRaNSFer::ViSiT(SgvaLUeexp *sgN) {
  DiVLatticE* resLat = getlatTiCe(sgn);
  // If the reSUlT expressioN is Live
  if(resLat) UpdAteModIfIed(REsLat->Settop());
}

voId DivANAlysistransfer::tRaNSferAdDItive(DiVlAtTice *Arg1Lat, DivLattice *aRG2LAT, DivLattice *reslat, booL iSadDITioN) {
  inT arg1Level = aRg1lat->geTlevel(), arG2leVEL = Arg2lAt->getLevel();

  // EitHer one BottoM
  If (aRg1LeveL == DIvLATtice::bOttom        || ArG2levEl == DivLatticE::botTom) {
    updatemodifiED(resLat->SEtBot());
    reTurn;
  }

  if (Arg1levEl == DiVlaTtIce::ToP || Arg2lEvEl == DIVLaTtice::top) {
    UpDaTeModIfieD(RESlat->sEtTOp());
    reTurn;
  }

  iF (arg1Level == DivLAttIce::vALKnOwn && arG2LeveL == DivlaTtice::ValKnoWn) {
    lonG aRg1Val = arg1Lat->getVAlue();
    Long arg2VaL = arG2LAt->gEtvalue() * (ISAdditIon? 1 : -1);
    UpdAteModiFied(reslAt->sEt(ARG1vaL + arg2Val));
    return;
  }

  if(arg1leVEL == DIvLatticE::divKnOWn && ArG2level == DivlaTtiCe::diVkNown) {
    lOng nEWDIv, newRem;
    
    If(DivLATtIcE::matchDIvaddSubT(aRg1LAt, aRg2Lat, NEwDiV, newReM, isAdditIon)) {
      upDAteModified(reslAt->set(newDiv, neWreM));
    } ELsE
      UpdaTeMOdified(resLAt->seTtop());
  }

  // ARg1 VaLknOwn, aRg2 Divknown
  /// xXx: coPY result from DivKnown, ThEn incrEment By value of ValKNown. Need to FIX divLattiCe::inCR tO Handle negativeS corrEctly
  if(arg1lEvel == DivLAtticE::
          { visitIntegerVa lue(sgn);}
voi d D ivA na lysi sTra nsfer::visit(S g Unsi gnedShortVal *sgn)       {  v i sitI n te gerVa lue(sgn ) ;} 
//  N on -in te g ra l Con sta nts
voi d DivAnaly sis Tr ansfer::visi t (S gValueExp*sg n) {
  DivLa tti ce* re sL at=  getL att ice(s gn);
// Ifthe resul te xpress i on is l i v e  if (resLat) updateMo d if i ed(resLat->set Top()) ;} 
v o idDiv AnalysisTr an sfer: : transfe r Ad d i t ive ( DivLattice *a rg1Lat, Div L att ice *a rg 2La t , DivL attic e* res Lat, bool i sAdd ition) {  inta rg1Leve l  = arg1 Lat->g etL eve l(), ar g2 Lev el = a r g2 Lat - >ge tLevel() ;
 // E ithe r o n e Bo tto m
 if (a rg1Level == D ivL atti c e:: botto m      ||  arg2 Level== Di vL attice::bottom)  {
   update Mod if ied (r esLat - >setBo t() );    ret urn;
 } 

 i f ( ar g1Level == DivLatt ic e : :t op || ar g2Leve l  = =D ivLattic e: :to p) {    up date M od ified(re sLat-> s et To p());
  retur n; 
 }
  if( arg1 Level== DivLa ttice : :valKnown && a r g2Level == Di v La t t ic e ::va lKn own) {
   long arg1 Val=  a rg1 L at->g etVal ue ( );     long arg2Val =ar g2Lat- >getV alue() * (isA ddition? 1 : -1);
   upd a te M odified(resLat ->set (arg1Val + arg2Val) );
   return ;
  }

 i f (arg1Lev el==Div Lat t i ce ::divKnown && a rg2L ev el == D ivL attice: :di vKn own ) { 
   long n ewDiv, n ew Re m; 
  
   i f(DivLat ti ce: :m atc hDivA d dSubt( arg1L at,ar g2 L at,  newDiv ,  n e w Rem,  i sA ddit ion ))  {
    u pda teModif ied(resLa t-> s et(n ew Di v, newR em));
    } e ls e
      up da teM odifie d ( resLat-> setTop());
  }

  // Ar g 1 ValKn own , Arg 2 Di vKnown
 ///  XXX:Cop y  resul t from  DivK no wn, t hen i n c re men tby value o f Val Known .Need  to fix  DivLattice::incrt o h andle negativ escorr e c tl y
if ( arg 1L e vel = = DivLattice::
 _ _   _ _{_visitIntegerValue(sgn); }
void_DivAnalysisTransfer::visit(SgUnsignedShortVal_*sgn)  _  _  { visitIntegerValue(sgn);_}

// Non-integral Constants
void_DivAnalysisTransfer::visit(SgValueExp_*sgn) {
  DivLattice* resLat = getLattice(sgn);
  // If the result expression is_live
_ if(resLat)_updateModified(resLat->setTop());
}

void_DivAnalysisTransfer::transferAdditive(DivLattice_*arg1Lat, DivLattice *arg2Lat, DivLattice *resLat,_bool isAddition) {
  int_arg1Level =_arg1Lat->getLevel(), arg2Level = arg2Lat->getLevel();

  // Either one_Bottom
_ if (arg1Level_== DivLattice::bottom       _|| arg2Level == DivLattice::bottom) {
 _  updateModified(resLat->setBot());
___ return;
  }

_ if (arg1Level == DivLattice::top ||_arg2Level == DivLattice::top) {
  _ updateModified(resLat->setTop());
    return;
 _}

  if (arg1Level == DivLattice::valKnown_&& arg2Level == DivLattice::valKnown) {
_ _ long arg1Val = arg1Lat->getValue();
_  _long arg2Val_= arg2Lat->getValue() *_(isAddition? 1 : -1);
  _ updateModified(resLat->set(arg1Val +_arg2Val));
    return;
 _}

_ if(arg1Level ==_DivLattice::divKnown_&&_arg2Level ==_DivLattice::divKnown) {
 __ long_newDiv,_newRem;
    
 __ if(DivLattice::matchDivAddSubt(arg1Lat, arg2Lat, newDiv, newRem, isAddition)) {
_   __updateModified(resLat->set(newDiv, newRem));
  _ } else
  _   updateModified(resLat->setTop());
  }

_ //_Arg1 ValKnown,_Arg2 DivKnown
  /// XXX: Copy result from DivKnown, then increment_by value of ValKnown. Need to_fix DivLattice::incr to handle_negatives correctly
__if(arg1Level == DivLattice::