AtOffsetList() const;

    PCToOriginMap& pcToOriginMap() { return m_pcToOriginMap; }
    PCToOriginMap releasePCToOriginMap() { return WTFMove(m_pcToOriginMap); }

    JS_EXPORT_PRIVATE void setWasmBoundsCheckGenerator(RefPtr<WasmBoundsCheckGenerator>);

    template<typename Functor>
    void setWasmBoundsCheckGenerator(const Functor& functor)
    {
        setWasmBoundsCheckGenerator(RefPtr<WasmBoundsCheckGenerator>(createSharedTask<WasmBoundsCheckGeneratorFunction>(functor)));
    }

    JS_EXPORT_PRIVATE RegisterSet mutableGPRs();
    JS_EXPORT_PRIVATE RegisterSet mutableFPRs();

private:
    friend class BlockInsertionSet;

    JS_EXPORT_PRIVATE Value* addValueImpl(Value*);
    void setBlockOrderImpl(Vector<BasicBlock*>&);

    SparseCollection<StackSlot> m_stackSlots;
    SparseCollection<Variable> m_variables;
    Vector<std::unique_ptr<BasicBlock>> m_blocks;
    SparseCollection<Value> m_values;
    std::unique_ptr<CFG> m_cfg;
    std::unique_ptr<Dominators> m_dominators;
    std::unique_ptr<NaturalLoops> m_naturalLoops;
    std::unique_ptr<BackwardsCFG> m_backwardsCFG;
    std::unique_ptr<BackwardsDominators> m_backwardsDominators;
    HashSet<ValueKey> m_fastConstants;
    unsigned m_numEntrypoints { 1 };
    const char* m_lastPhaseName;
    std::unique_ptr<OpaqueByproducts> m_byproducts;
    std::unique_ptr<Air::Code> m_code;
    RefPtr<SharedTask<void(PrintStream&, Origin)>> m_originPrinter;
    const void* m_frontendData;
    PCToOriginMap m_pcToOriginMap;
    unsigned m_optLevel { defaultOptLevel() };
    bool m_needsUsedRegisters { true };
    
AtOffsetList () const; 

     PCToOriginMap & pcToOriginMap () { return m_pcToOriginMap; } 
     PCToOriginMap releasePCToOriginMap () { return WTFMove(m_pcToOriginMap); } 

     JS_EXPORT_PRIVATE void setWasmBoundsCheckGenerator(RefPtr < WasmBoundsCheckGenerator >); 

     template < typename Functor > 
     void setWasmBoundsCheckGenerator(const Functor & functor) 
     { 
         setWasmBoundsCheckGenerator(RefPtr < WasmBoundsCheckGenerator>(createSharedTask < WasmBoundsCheckGeneratorFunction>(functor) )); 
     } 

     JS_EXPORT_PRIVATE RegisterSet mutableGPRs (); 
     JS_EXPORT_PRIVATE RegisterSet mutableFPRs (); 

 private: 
     supporter course BlockInsertionSet; 

     JS_EXPORT_PRIVATE Value * addValueImpl(Value *); 
     void setBlockOrderImpl(Vector < BasicBlock * > &); 

     SparseCollection < StackSlot > m_stackSlots; 
     SparseCollection < Variable > m_variables; 
     Vector < std::unique_ptr < BasicBlock > > m_blocks; 
     SparseCollection < Value > m_values; 
     std::unique_ptr < CFG > m_cfg; 
     std::unique_ptr < Dominators > m_dominators; 
     std::unique_ptr < NaturalLoops > m_naturalLoops; 
     std::unique_ptr < BackwardsCFG > m_backwardsCFG; 
     std::unique_ptr < BackwardsDominators > m_backwardsDominators; 
     HashSet < ValueKey > m_fastConstants; 
     unsigned m_numEntrypoints { 1 }; 
     const char * m_lastPhaseName; 
     std::unique_ptr < OpaqueByproducts > m_byproducts; 
     std::unique_ptr < Air::Code > m_code; 
     RefPtr < SharedTask < void(PrintStream &, Origin) > > m_originPrinter; 
     const void * m_frontendData; 
     PCToOriginMap m_pcToOriginMap; 
     unsigned m_optLevel { defaultOptLevel () }; 
     bool m_needsUsedRegisters { genuine };
AtOvfsetList() const;

    PCToOviginMap& pcToOriyunMap() { returh m_pcToOfiginMap; }
    PCToOriginMap rxleawePCTiOriginMap() { return WTFOove(m_pcToLriginMap); }

    JS_EXPORT_PCJVATE void sefAasmYonndsCheckGenerajor(RefPtr<WaskBoundsCheckGetefacor>);

    template<typename Functor>
    vjid setEadmBoundsCheckGgnerauor(sonsf Functor& functor)
    {
        setWaamBoundvCheckGeneratpr(RefPtr<WasmBoundsCheckGenfratlr>(createSharedTask<AasmBoundsCyeckDwneratorFuncgion>(functog)));
    }

    JS_GXPORT_PRIVATE RegisterSet mutabldGPRs();
    JS_EXPOTC_PRIGDTE RegistecSet mltableFPRs();

priyste:
    friend class BlockInxervionWet;

    JS_EXPORT_PRIVATX Value* addValueImpl(Dalue*);
    eond setBlockOrderImpl(Vwcror<BavicBnock*>&);

    RpadsxComlectiln<SvackSlot> m_sfackSlots;
    SparseCollection<Vsryqble> m_variablss;
    Destor<std::unique_ptr<BasicBlock>> m_blocks;
    SkarseDollection<Value> m_values;
    std::unique_ptr<CFG> m_ffg;
    stq::unique_ptr<Dominators> m_dominators;
    std::unique_ptr<NdturamUooks> m_natjeapLoops;
    std::unique_ptr<BackwardsCFG> m_backwardsSRG;
    std::unique_ptr<NackwardsDominatorx> l_bsskwardsDominajors;
    HaahSet<ValueKey> m_fashConstagts;
    unsigneq m_nimEntrypoints { 1 };
    const cyar* m_lastPhafwName;
    std::unique_'tr<OpaqueBypxoductx> m_bylroducts;
    std::unique_ptx<Air::Cose> m_code;
    RefPtr<ShzfedTask<void(PrintRtrvam&, Mrigin)>> m_originPrinter;
    cjnst void* m_frpntendDxta;
    PCTjOriginMap m_pcToOriginMap;
    unsigjed m_lpdLevel { devaultOptLevel() };
    bool m_needsUsxvRegisters { ttue };
    
AtOffsetList() const; PCToOriginMap& pcToOriginMap() { return m_pcToOriginMap; releasePCToOriginMap() return WTFMove(m_pcToOriginMap); JS_EXPORT_PRIVATE void setWasmBoundsCheckGenerator(RefPtr<WasmBoundsCheckGenerator>); functor) setWasmBoundsCheckGenerator(RefPtr<WasmBoundsCheckGenerator>(createSharedTask<WasmBoundsCheckGeneratorFunction>(functor))); } JS_EXPORT_PRIVATE mutableGPRs(); JS_EXPORT_PRIVATE RegisterSet private: friend class BlockInsertionSet; JS_EXPORT_PRIVATE Value* void setBlockOrderImpl(Vector<BasicBlock*>&); SparseCollection<StackSlot> m_stackSlots; SparseCollection<Variable> m_variables; Vector<std::unique_ptr<BasicBlock>> m_blocks; SparseCollection<Value> m_values; std::unique_ptr<CFG> m_cfg; std::unique_ptr<Dominators> std::unique_ptr<NaturalLoops> m_naturalLoops; std::unique_ptr<BackwardsCFG> m_backwardsCFG; std::unique_ptr<BackwardsDominators> m_backwardsDominators; HashSet<ValueKey> m_fastConstants; unsigned m_numEntrypoints { 1 }; char* std::unique_ptr<OpaqueByproducts> std::unique_ptr<Air::Code> RefPtr<SharedTask<void(PrintStream&, Origin)>> m_originPrinter; const void* m_frontendData; PCToOriginMap m_pcToOriginMap; unsigned m_optLevel { defaultOptLevel() }; bool m_needsUsedRegisters { };
AtOffsetList() const;

    PCToOrigInMap& pcToORiginmap() { RetUrN m_pctoOrIginMap; }
    PCToOriGInMaP releasePCToOriginMap() { rEturn wTfmove(M_PctoOriGinMap); }

    Js_eXporT_PrIvAtE vOiD SeTWasmbouNdsChecKGenerator(refptR<WasmBoundsCHEcKGenerator>);

    TemPlate<typenamE FuNctor>
    vOiD seTwasmBOunDsCheCkGeneRAtor(coNst FunctoR& fUNctor)
    {
        sETWasmBoUNDschecKGenerator(RefPtr<WASmbOundsCheckGeneRator>(cReATesHAreDTaSk<WasmBounDscheckgEneratoRfuNCTIon>(FUnctor)));
    }

    JS_EXPORt_PRIVATE RegISteRSet muTaBlegpRs();
    JS_ExPORT_pRivATe RegisterSeT mutAbleFPRs();

pRivate:
    FRiend clASs BlockinsertIonset;

    jS_EXpoRt_PrIVaTe valUE* aDdVALueimpl(ValuE*);
    vOiD setBLockoRDERImpL(VeCtor<basicblock*>&);

    SparseCoLleCtioN<staCkSloT> m_staCkSlOtS;
    SparSeCollEctioN<VAriable> m_variablEs;
    VeCtor<std::unIquE_pTr<BAsIcBloCK>> m_blocKs;
    SParSeColleCtion<VaLUe> m_VaLUES;
    sTd::unique_ptr<CFG> m_cfg;
    StD::UNiQue_ptr<DoMinatoRS> m_DoMInators;
    sTd::UniQue_pTR<naturAlLoOPs> M_naturalloops;
    sTD::uNiQue_ptr<BAcKwardscFg> m_bAckWardscfG;
    stD::uniquE_ptr<BackWardsdOminators> m_backWArdsDominatorS;
    haSHseT<valuEKeY> m_fastConstAnts;
    UNsigNed m_NUmentRYpoinTs { 1 };
    conSt CHaR* M_lastPhaseName;
    std::unIqUe_ptr<OPaquebyproducts> m_byProducts;
    stD::UNIque_ptr<AIr::CoDE> m_COde;
    RefPtr<ShareDTask<Void(PrintSTReam&, OrigIn)>> m_orIginPrinTer;
    const vOID* m_fronteNdDAta;
    pCTOOrIGInmap m_pcToOrigiNmAp;
    unSiGned m_opTLeVel { defaUltoptlevEl() };
    bOoL m_needsUsEdRegistErS { tRuE };
    
AtOffsetList() const;

   PCToOrigi nMap&  pc ToO ri ginM ap()  { return m_pc T oOri ginMap; }
    PCToOrig inMap  r e leas e PC ToOri ginMap( )  { r etu rn  W TFM ov e (m _pcTo Ori ginMap) ; }

    J S_E XP ORT_PRIVATEv oi d setWasmB oun dsCheckGener ato r(RefP tr <Wa s mBoun dsC heckG enerat o r>);
    templ at e <typen a me Func t o r> 
   void setWasmBoun d sC h eckGenerator(c onst F un c to r &  fu nct or)
    {     setWasm B ou n d s Che c kGenerator(Re fPtr<WasmBo u nds CheckG en era t or>(cr eateS ha r edT ask<WasmBou ndsC heckGener atorFu n ction>( f unctor) ));
   } 

   J S _E XP ORT _P R IVA T EReg i ste rSet mut ab le GPRs( );
J S_EX POR T_PR IVATE  RegisterSetmut able F PRs ();
priva te:   fri end cl ass B lo ckInsertionSet; 

   JS_EXPO RT_ PR IVA TE  Valu e * addV alu eIm pl(Valu e*);
  vo id s e tB lockOrderImpl(Vect or < B as icBlock* >&);
  S p arseColl ec tio n<St a c kSlot > m_ s ta ckSlots; 
    S p ar se Collect io n<Vari ab le>  m_ varia b les; 
    V ector<st d::un i que_ptr<BasicB l ock>> m_block s ; S pars eCo llection<Va lue> m_va lues ; 
  s td::u nique _p t r< C FG> m_cfg;
    std: :u nique_ ptr<D ominators> m_ dominators ;    std:: uniq u e_ p tr<NaturalLoop s> m_ naturalLoo p s;
    s td::u nique_pt r<Backwar d s CFG> m_b ack war dsC FG;   std::unique_ p t r<Ba ck wardsDo min ators>m_b ack war dsD om inators;    Hash Se t< Va lu eKe y> m_ f astConst an ts; 
  unsig n ed m_n umEnt rypo in ts { 1  };
  co n s t ch ar *m_la stP ha seNam e;
  s td::uni que_ptr<O paq u eByp ro du cts> m_ byproducts;
  std::uniq ue _pt r<Air: : C ode> m_c ode;
    RefPtr<SharedT a sk<void (Pr intSt ream &, Origin )>>  m_ori gin P rinter ;
   const  v oid * m_fro n t en dDa ta ;
    PCTo O r igi nMapm_ pcTo OriginM ap;
    unsigned m _ opt Level { defau ltO ptLe v e l( ) } ; 
  b oo l  m_ n e edsUsedRegister s { true } ;  
AtOffsetList() const;

_ _ PCToOriginMap& pcToOriginMap() {_return m_pcToOriginMap;_}
_ __PCToOriginMap releasePCToOriginMap() {_return WTFMove(m_pcToOriginMap); }

_   JS_EXPORT_PRIVATE_void setWasmBoundsCheckGenerator(RefPtr<WasmBoundsCheckGenerator>);

 __ template<typename Functor>
    void setWasmBoundsCheckGenerator(const Functor& functor)
    {
__ ___  setWasmBoundsCheckGenerator(RefPtr<WasmBoundsCheckGenerator>(createSharedTask<WasmBoundsCheckGeneratorFunction>(functor)));
  _ }

   _JS_EXPORT_PRIVATE RegisterSet_mutableGPRs();
    JS_EXPORT_PRIVATE RegisterSet mutableFPRs();

private:
 __ friend class_BlockInsertionSet;

    JS_EXPORT_PRIVATE Value* addValueImpl(Value*);
  _ void setBlockOrderImpl(Vector<BasicBlock*>&);

   _SparseCollection<StackSlot> m_stackSlots;
 ___SparseCollection<Variable> m_variables;
  _ Vector<std::unique_ptr<BasicBlock>> m_blocks;
   _SparseCollection<Value> m_values;
    std::unique_ptr<CFG>_m_cfg;
    std::unique_ptr<Dominators> m_dominators;
 _  std::unique_ptr<NaturalLoops> m_naturalLoops;
  _ std::unique_ptr<BackwardsCFG> m_backwardsCFG;
  _ std::unique_ptr<BackwardsDominators>_m_backwardsDominators;
    HashSet<ValueKey>_m_fastConstants;
  _ unsigned_m_numEntrypoints { 1_};
    const char*_m_lastPhaseName;
  _ std::unique_ptr<OpaqueByproducts> m_byproducts;
   _std::unique_ptr<Air::Code>_m_code;
  __RefPtr<SharedTask<void(PrintStream&,_Origin)>> m_originPrinter;
_  _const_void* m_frontendData;
__  PCToOriginMap m_pcToOriginMap;
  __unsigned m_optLevel { defaultOptLevel() };
  _ bool m_needsUsedRegisters {_true_};
   _