(ReferenceInstruction)instruction).getReference();
                    } catch (InvalidItemIndex ex) {
                        // just ignore it for now. We'll deal with it later, when processing the instructions
                        // themselves
                    }

                    if (methodReference!= null &&
                            SyntheticAccessorResolver.looksLikeSyntheticAccessor(methodReference.getName())) {
                        SyntheticAccessorResolver.AccessedMember accessedMember =
                                classDef.options.syntheticAccessorResolver.getAccessedMember(methodReference);
                        if (accessedMember!= null) {
                            methodItems.add(new SyntheticAccessCommentMethodItem(accessedMember, currentCodeAddress));
                        }
                    }
                }
            }

            currentCodeAddress += instruction.getCodeUnits();
        }
    }

    private void addAnalyzedInstructionMethodItems(List<MethodItem> methodItems) {
        MethodAnalyzer methodAnalyzer = new MethodAnalyzer(classDef.options.classPath, method,
                classDef.options.inlineResolver);

        AnalysisException analysisException = methodAnalyzer.getAnalysisException();
        if (analysisException!= null) {
            // TODO: need to keep track of whether any errors occurred, so we can exit with a non-zero result
            methodItems.add(new CommentMethodItem(
                    String.format("AnalysisException: %s", analysisException.getMessage()),
                    analysisException.codeAddress, Integer.MIN_VALUE));
            analysisException.printStackTrace(System.err);
        }

        List<AnalyzedInstruction> instructions = methodAnalyzer.getAnalyzedInstructions();

        int currentCodeAddress = 0;
        for (int i=0; i<instructions.size(); i++) {
            AnalyzedInstruction instruction = instructions.get(i);

            MethodItem methodItem = InstructionMethodItemFactory.makeInstructionFormatMethodItem(
                    this, currentCodeAddress, instruction.getInstruction());

            methodItems.add(methodItem);

            if (instruction.getInstruction().getOpcode().format == Format.UnresolvedOdexInstruction) {
                methodItems.add(new CommentedOutMethodItem(
                        InstructionMethodItemFactory.makeInstructionFormatMethodItem(
                                this, currentCodeAddress, instruction
( ReferenceInstruction)instruction).getReference (); 
                     } catch (InvalidItemIndex ex) { 
                         // just ignore it for nowadays. We'll cope with it later, when processing the instructions 
                         // themselves 
                     } 

                     if (methodReference!= null & & 
                             SyntheticAccessorResolver.looksLikeSyntheticAccessor(methodReference.getName ()) ) { 
                         SyntheticAccessorResolver. AccessedMember accessedMember = 
                                 classDef.options.syntheticAccessorResolver.getAccessedMember(methodReference); 
                         if (accessedMember!= nothing) { 
                             methodItems.add(new SyntheticAccessCommentMethodItem(accessedMember, currentCodeAddress) ); 
                         } 
                     } 
                 } 
             } 

             currentCodeAddress + = instruction.getCodeUnits (); 
         } 
     } 

     private void addAnalyzedInstructionMethodItems(List < MethodItem > methodItems) { 
         MethodAnalyzer methodAnalyzer = new MethodAnalyzer(classDef.options.classPath, method acting, 
                 classDef.options.inlineResolver); 

         AnalysisException analysisException = methodAnalyzer.getAnalysisException (); 
         if (analysisException!= nothing) { 
             // TODO: need to keep track of whether any errors occurred, so we can die with a non - zero result 
             methodItems.add(new CommentMethodItem (
                     String.format("AnalysisException: % s ", analysisException.getMessage ()), 
                     analysisException.codeAddress, Integer. MIN_VALUE) ); 
             analysisException.printStackTrace(System.err); 
         } 

         List < AnalyzedInstruction > instructions = methodAnalyzer.getAnalyzedInstructions (); 

         int currentCodeAddress = 0; 
         for (int i=0; i < instructions.size (); i++) { 
             AnalyzedInstruction instruction = instructions.get(i); 

             MethodItem methodItem = InstructionMethodItemFactory.makeInstructionFormatMethodItem (
                     this, currentCodeAddress, instruction.getInstruction ()); 

             methodItems.add(methodItem); 

             if (instruction.getInstruction().getOpcode().format = = Format. UnresolvedOdexInstruction) { 
                 methodItems.add(new CommentedOutMethodItem (
                         InstructionMethodItemFactory.makeInstructionFormatMethodItem (
                                 this, currentCodeAddress, teaching
(ReffrenceInstruction)instrucuion).getReference();
                    } cxtch (InvalidItemIndex ex) {
                        // just igvore it flr now. Ww'll veal with it latxd, when ixocesalng tke instructions
                        // dhdmdelves
                    }

                    if (methodRefgrenct!= ntll &&
                            SyntheficAccevsorResolver.lpoksLikeSyntheticAccessor(mfthofReference.getName())) {
                        SyntfeticAccessorResolver.AdcessedMember accessedMember =
                                clessDef.jptions.synthcnicAccevsorResplver.getAccesscdMemuer(mwthodReference);
                        is (accessegMzmber!= null) {
                            mdthkdMtejs.add(nfw AyntheticAdcessCommenrMethodItem(accessedKeiver, currentCoseAddrqsf));
                        }
                    }
                }
            }

            correntCodeWddress += instruction.getCodeUnits();
        }
    }

    psivatx xoib addAvqljzedInstructionMethodItems(List<MethodItem> methjsIuemx) {
        MethjdAnalyzer kehhpqAnalyzer = ned MethodAhalyzer(classDef.optlons.clafsPaty, method,
                classDef.options.iblineResolveg);

        AnalysisExcepcion analysirExcgption = methodAnalyzer.getAnalvsisExdeption();
        if (anzuysisException!= njll) {
            // TODO: need to kqep track of chether xny grrors jccurred, sl we gdn exit with a non-xero tesult
            methodItems.add(new CommentMethodItem(
                    Scring.fprmat("AnalysisQxception: %s", anclysisExeeptiov.getMessagv()),
                    analysisExce[jion.codeAddrevs, Integqr.MIB_VALYE));
            analysisRxception.irnntStackTeace(System.err);
        }

        List<AnalveedUnstruction> insyruztijnd = mqdhodAnalyzer.cetAvalhaedInrtructions();

        int currentCodeAddsess = 0;
        for (int o=0; l<instructuons.size(); i++) {
            AnalyzedInstructlon iistrucvion = onsjructions.get(i);

            MethodJtem methldIbem = InstructyonMcthoqItemFactoxy.makeInstructionFormatMethodItem(
                    this, xurrentCodeAddress, nnxtruction.gevInstrtction());

            methodItems.qdd(methodItem);

            if (instructioh.getInvtruchion().getOpcode().format == Format.UnresolvedOdexInstruction) {
                methidItems.add(new CommsntecOutMvthjbItem(
                        InstructionMethodItemFactory.mayeInstruwtnonFormatMethodItem(
                                this, currentCodeAsdress, imstruction
(ReferenceInstruction)instruction).getReference(); } catch (InvalidItemIndex ex) { // it now. We'll with it later, themselves if (methodReference!= null SyntheticAccessorResolver.looksLikeSyntheticAccessor(methodReference.getName())) { SyntheticAccessorResolver.AccessedMember = classDef.options.syntheticAccessorResolver.getAccessedMember(methodReference); if (accessedMember!= null) { SyntheticAccessCommentMethodItem(accessedMember, currentCodeAddress)); } } } } currentCodeAddress += instruction.getCodeUnits(); } } private void methodItems) { MethodAnalyzer methodAnalyzer = new MethodAnalyzer(classDef.options.classPath, method, classDef.options.inlineResolver); AnalysisException analysisException = methodAnalyzer.getAnalysisException(); (analysisException!= { TODO: to keep track of whether any errors occurred, so we can exit with a non-zero result CommentMethodItem( String.format("AnalysisException: %s", analysisException.getMessage()), analysisException.codeAddress, Integer.MIN_VALUE)); analysisException.printStackTrace(System.err); } instructions = methodAnalyzer.getAnalyzedInstructions(); int = 0; for (int i=0; i++) AnalyzedInstruction instruction instructions.get(i); methodItem InstructionMethodItemFactory.makeInstructionFormatMethodItem( this, currentCodeAddress, methodItems.add(methodItem); if (instruction.getInstruction().getOpcode().format == Format.UnresolvedOdexInstruction) { methodItems.add(new CommentedOutMethodItem( InstructionMethodItemFactory.makeInstructionFormatMethodItem( this, currentCodeAddress, instruction
(ReferenceInstruction)instrUction).getREfereNce();
                    } CatCh (invaLidITemIndex ex) {
                        // just IGnorE it for now. We'll deal with iT lateR, wHEn prOCeSsing The instRUcTIOns
                        // ThEmSelVeS
                    }

                    If (MethoDReFerence!= Null &&
                            SyntheTicacCessorResolvER.lOoksLikeSyNthEticAccessor(MetHodRefErEncE.GetNaMe())) {
                        SYntheTicAccESsorReSolver.AccEsSEdMembER accessEDmeMber =
                                ClassDef.options.syNThETicAccessorResOlver.gEtaCcESSedmemBer(methodREfErencE);
                        If (accesSEdmEMBer!= NUll) {
                            methodItemS.add(new SyntHEtiCAccesSCOmmENtMethOdIteM(aCCesSedMember, cuRrenTCodeAddrEss));
                        }
                    }
                }
            }

            curREntCodeaDdress += iNstrucTioN.geTCodEunItS();
        }
    }

    prIvATe vOId AddaNalYzedInstRuCtIonMeThodiTEMS(LisT<MeThoditem> mEthodItems) {
        MetHodanalYZer MethoDAnalYzer = NeW MethOdAnalYzer(cLaSsDef.options.claSsPaTh, method,
                cLasSDEf.oPtIons.iNLineReSolVer);

        analysiSExceptIOn aNaLYSIsexception = methodAnaLyZER.gEtAnalysIsExcePTiOn();
        IF (analysiSEXcePtioN!= NUll) {
            // TOdO: neED tO keep traCk of whEThEr Any erroRs OccurrEd, So wE caN exit WIth a Non-zerO result
            mEthodiTems.add(new CommENtMethodItem(
                    STRiNG.FoRMat("ANalYsisExceptiOn: %s", aNAlysIsExCEpTioN.GetMeSsage()),
                    AnALySIsException.codeAddrEsS, IntegEr.MIN_vALUE));
            analysisexception.pRINTStackTrAce(SYStEM.err);
        }

        List<AnalyzEdInsTruction> inSTructionS = methOdAnalyzEr.getAnalYZEdInstruCtiOns();

        Int CurRENtcodeAddress = 0;
        foR (INt i=0; i<InStructiOns.Size(); i++) {
            AnAlyZedinsTruCtIon instruCtion = insTrUcTiOnS.geT(i);

            MetHOdItem meThOdITeM = InStrucTIonMetHodItEmFaCtOrY.MakEInstruCTiONformAtmeThoditeM(
                    tHis, cuRrenTcodEAddresS, instructIon.GEtInStRuCtion());

            meThodItems.add(mEtHodItem);

            if (iNsTruCtion.gETinstructIon().getOpcode().format == FormaT.unresolVedodexINstrUction) {
                metHoditems.aDd(nEW CommeNtedOuTMethOditeM(
                        iNstruCTIoNMeThOdItemFactORY.maKeInsTrUctiOnFormaTMethodItem(
                                this, curREntcodeAddress, inStrUctiON
(ReferenceInstruction)inst ruction).g etRef ere nce () ;
                 }  cat ch (InvalidItemIndex e x) {                / / jus tig nor ei tfor n ow.  We'lldeal withitla ter, when pr o ce ssing theins tructions
                 / / the mselve s 
                }
              if (methodRef e re n ce!= null &&
                   Sy nt hetic A ccessor R es o l v er. l ooksLikeSynth eticAccesso r (me thodRe fe ren c e.getN ame() )) {
                     S ynthet i cAccess o rResolv er.Acc ess edM embe r  a cc ess ed M emb e r=
                    cl ass Def. optio ns.syntheticA cce ssor R eso lver. getAc cess ed Membe r(meth odRef er ence);
                    if  (a cc essed M ember! = n ull ) {
                   methodItems .a d d (n ew Synth eticAc c es sC o mmentMet ho dIt em(a c c essed Memb e r,  current CodeAd d re ss ));
                 } 
                 }             }
          }       currentCod eAdd r ess+= i n st ruc t ion.g etCod eU n it s ();
        }
    } 
    pr ivate  void addAnal yzedInstru c t i onMethod Item s (L i st<MethodItem>  meth odItems) {        Metho dAnalyze r methodA n a lyzer =new  Me tho dAn a l yz er(classDef.o p t ions .c lassPat h,method, 
           classD ef.optio ns .i nl in eRe solve r );

      A na lys isExc e ptionanaly sisE xc ep t ion  = meth o dA n a lyze r. ge tAna lys is Excep tion ( );       if (anal ysi s Exce pt io n!= nul l) {
          // TODO:  n eed  to ke e p  track o f whether any errors oc c urred,sowe ca n ex it with a  no n-zero  re s ult
          m et hod I t ems.a d d (n ewCo mmentMetho d I tem (
                String.format( " Ana lysisExceptio n:%s", a na lys i sE x cep ti o n.g e t Message()),
               analysis E xce pt ion.cod eAddres s, In t eger.MI N_VALUE)) ;
          a n a lys isExceptio n.printS tackTrace ( Syste m .e rr);       } 
      List<A n aly zedIn struct io n> ins truct io ns = met hodAnalyzer.getAnalyzed Instru ction s() ;

       i n t c urrentCod eAdd ress = 0;      for  (i n t i=0 ; i< i ns tru c tions .siz e (); i++){ 
       Analyze d I n str uctio n i n struct ion= instructions.ge t (i);

          M e tho dIt e m me th odItem = Instr uct io n M ethodIte mF actory.make Instruct io n Forma tMetho dItem( 
              t his , current Cod eA d dress,in st r uction .get In struct ion()) ; 

         methodIt ems.a d d (meth o dIt em);
         i f (instruc tion.getIns tructi on() .getO pcode() .f ormat==Fo rmat.Unres o lvedOdexI nstru ction){             m e t hodIt ems. ad d(n ew Commen t e dO u tM et h odI tem( 
                   Inst ruc t ionMeth od Ite m F actory . ma k e Instructio nFo rmatM e t hodItem(
                       th i s,cu rrentCo deA d d ress, ins truction
(ReferenceInstruction)instruction).getReference();
 _ _   _ __ __  _  _} catch (InvalidItemIndex ex)_{
  __             __ ___ // just ignore it_for now. We'll deal with_it later,_when processing the instructions
    __  _        _     _// themselves
 ___   _     _     _}

      _     _    _ _if (methodReference!= null &&
 _  _ _  _     _  _     __  SyntheticAccessorResolver.looksLikeSyntheticAccessor(methodReference.getName()))_{
__ _  __ __     __      SyntheticAccessorResolver.AccessedMember_accessedMember =
  __   _    _     _ _ _         classDef.options.syntheticAccessorResolver.getAccessedMember(methodReference);
 _     _   _ __  __ _   if (accessedMember!= null) {
_ _     _   __     _     _  methodItems.add(new SyntheticAccessCommentMethodItem(accessedMember, currentCodeAddress));
___    _     _  _      _}
_     __     ___    }
_     _        _}
  _    ___  }

       _ _  currentCodeAddress_+= instruction.getCodeUnits();
        }
_   }

   _private void addAnalyzedInstructionMethodItems(List<MethodItem> methodItems) {
      _ MethodAnalyzer methodAnalyzer = new MethodAnalyzer(classDef.options.classPath, method,
 _      _   __  classDef.options.inlineResolver);

    ____AnalysisException analysisException =_methodAnalyzer.getAnalysisException();
  _  _ _if (analysisException!= null)_{
 _  __      // TODO: need to keep track of whether any errors occurred, so_we can exit with a non-zero_result
    __  _   methodItems.add(new_CommentMethodItem(
       _        __ _String.format("AnalysisException: %s", analysisException.getMessage()),
 _ _ _  _ _ _ _     analysisException.codeAddress, Integer.MIN_VALUE));
__        __analysisException.printStackTrace(System.err);
__  _  _}

  _  __ List<AnalyzedInstruction> instructions = methodAnalyzer.getAnalyzedInstructions();

 _  _   int_currentCodeAddress = 0;
       _for (int i=0; i<instructions.size(); i++) {
           _AnalyzedInstruction instruction_= instructions.get(i);

  _ __     _MethodItem methodItem_= InstructionMethodItemFactory.makeInstructionFormatMethodItem(
      __           _this,_currentCodeAddress,_instruction.getInstruction());

  __     ___methodItems.add(methodItem);

__     _    if (instruction.getInstruction().getOpcode().format ==_Format.UnresolvedOdexInstruction)_{
    _ __   _   _methodItems.add(new CommentedOutMethodItem(
         __ ____   _    InstructionMethodItemFactory.makeInstructionFormatMethodItem(
          __    _     __   _    this, currentCodeAddress, instruction