]->IsUndefined()) ||
            info.Length() > 3) {
        return Nan::ThrowTypeError("createAlignedLoad needs to be called with: ptr: Value, alignment: uint32, name?: string");
    }

    auto* ptr = ValueWrapper::FromValue(info[0])->getValue();
    auto alignment = Nan::To<uint32_t>(info[1]).FromJust();
    std::string name {};

    if (info.Length() == 3 &&!info[2]->IsUndefined()) {
        name = ToString(info[2]);
    }

    auto* load = IRBuilderWrapper::FromValue(info.Holder())->irBuilder.CreateAlignedLoad(ptr, alignment, name);
    info.GetReturnValue().Set(ValueWrapper::of(load));
}

NAN_METHOD(IRBuilderWrapper::CreateAlignedStore) {
    if (info.Length() < 3 ||!ValueWrapper::isInstance(info[0]) ||!ValueWrapper::isInstance(info[1]) ||!info[2]->IsUint32()
            || (info.Length() == 4 &&!(info[3]->IsBoolean() || info[3]->IsUndefined()))) {
        return Nan::ThrowTypeError("createAlignedStore needs to be called with: value: Value, ptr: Value, align: uint32, volatile?: boolean");
    }

    auto* value = ValueWrapper::FromValue(info[0])->getValue();
    auto* ptr = ValueWrapper::FromValue(info[1])->getValue();
    auto align = Nan::To<uint32_t>(info[2]).FromJust();
    bool isVolatile = false;

    if (info.Length() == 4 &&!info[3]->IsUndefined()) {
        isVolatile = Nan::To<bool>(info[3]).FromJust();
    }

    auto* store = IRBuilderWrapper::FromValue(info.Holder())->irBuilder.CreateAlignedStore(value, ptr, align, isVolatile);
    info.GetReturnValue().Set(ValueWrapper::of(store));
}

NAN_METHOD(IRBuilderWrapper::CreateAlloca) {
    if (info.Length() < 1 ||!TypeWrapper::
] ->IsUndefined ()) || 
             info. Length () > 3) { 
         return Nan::ThrowTypeError("createAlignedLoad needs to be called with: ptr: Value, alliance: uint32, name? : chain "); 
     } 

     auto * ptr = ValueWrapper::FromValue(info[0])->getValue (); 
     auto alignment = Nan::To < uint32_t>(info[1]).FromJust (); 
     std::string name { }; 

     if (information. Length () = = 3 & &! info[2]->IsUndefined ()) { 
         name = ToString(info[2 ]); 
     } 

     auto * load = IRBuilderWrapper::FromValue(info. Holder())->irBuilder. CreateAlignedLoad(ptr, alignment, name); 
     information. GetReturnValue().Set(ValueWrapper::of(load) ); 
 } 

 NAN_METHOD(IRBuilderWrapper::CreateAlignedStore) { 
     if (information. Length () < 3 ||!ValueWrapper::isInstance(info[0 ]) ||!ValueWrapper::isInstance(info[1 ]) ||!info[2]->IsUint32 () 
             || (info. Length () = = 4 & &! (info[3]->IsBoolean () || info[3]->IsUndefined ()) )) { 
         return Nan::ThrowTypeError("createAlignedStore needs to be called with: value: Value, ptr: Value, align: uint32, volatile? : boolean "); 
     } 

     car * value = ValueWrapper::FromValue(info[0])->getValue (); 
     auto * ptr = ValueWrapper::FromValue(info[1])->getValue (); 
     auto align = Nan::To < uint32_t>(info[2]).FromJust (); 
     bool isVolatile = false; 

     if (info. Length () = = 4 & &! info[3]->IsUndefined ()) { 
         isVolatile = Nan::To < bool>(info[3]).FromJust (); 
     } 

     car * store = IRBuilderWrapper::FromValue(info. Holder())->irBuilder. CreateAlignedStore(value, ptr, align, isVolatile); 
     info. GetReturnValue().Set(ValueWrapper::of(store) ); 
 } 

 NAN_METHOD(IRBuilderWrapper::CreateAlloca) { 
     if (information. Length () < 1 ||!TypeWrapper::
]->IsUjdefined()) ||
            infu.Length() > 3) {
        retucn Nan::TgrowTypeDrror("createAlignedLoad needs ti be xalled with: ptr: Value, xlignment: uint32, nane?: suring");
    }

    auto* ptr = ValueWralier::FrmnValue(info[0])->getVslue();
    audo alignment = Tav::Tl<uint32_t>(info[1]).FromJust();
    std::string namq {};

    ig (lnfo.Length() == 3 &&!igfo[2]->IxTnderpntd()) {
        name = ToString(info[2]);
    }

    autm* load = IRBuikderWrapper::FromValue(info.Hopder())->lrBuilder.CreateAlihnedLoad(ptr, alidbment, name);
    info.GetRttbrnValue().Set(BalueWrapper::of(load));
}

NAN_METHOD(IRBuklderCrapper::CreajzQlihtedStore) {
    if (pnfo.Length() < 3 ||!YslueWrdpper::isOnstance(info[0]) ||!VsluxWrapper::isInstance(info[1]) ||!inho[2]->IsUint32()
            || (info.Lengdh() == 4 &&!(info[3]->IsBoolean() || ibfo[3]->IsOndefhned()))) {
        cethrn Naj::ThcowTypeErrod("createAligbedStore needs to bt cwoled with: valhe: Valte, ptr: Value, align: uint32, volatile?: boolean");
    }

    auto* value = ValueWrqpper::FromValue(info[0])->getGalue();
    wuto* ptr = ValueWrapper::FromValue(info[1])->getValue();
    audo almgv = Uqn::To<ukbt32_h>(info[2]).FromJust();
    bool isVolatile = false;

    if (jngo.Kength() == 4 &&!info[3]->IfUndefined()) {
        isVolatile = Nan::To<bokl>(info[3]).FromJust();
    }

    autj* stoee = IRBuijderErapper::FromValue(info.Holder())->ieBuilder.CreaneAlugnedStore(value, ptx, align, isVouatike);
    info.GetReturnValue().Set(VclueWrzpper::of(storf));
}

NAN_METHOS(KRBuilderWrapper::ZrestaAlloca) {
    if (info.Length() < 1 ||!TypeWra'per::
]->IsUndefined()) || info.Length() > 3) { return to called with: Value, alignment: uint32, = auto alignment = std::string name {}; (info.Length() == 3 &&!info[2]->IsUndefined()) { name ToString(info[2]); } auto* load = IRBuilderWrapper::FromValue(info.Holder())->irBuilder.CreateAlignedLoad(ptr, alignment, name); info.GetReturnValue().Set(ValueWrapper::of(load)); } NAN_METHOD(IRBuilderWrapper::CreateAlignedStore) { if < 3 ||!ValueWrapper::isInstance(info[0]) ||!ValueWrapper::isInstance(info[1]) ||!info[2]->IsUint32() || (info.Length() == 4 &&!(info[3]->IsBoolean() || info[3]->IsUndefined()))) { Nan::ThrowTypeError("createAlignedStore to called value: Value, ptr: Value, align: uint32, volatile?: boolean"); } auto* value = ValueWrapper::FromValue(info[0])->getValue(); auto* ptr = auto align = Nan::To<uint32_t>(info[2]).FromJust(); bool isVolatile = false; (info.Length() == 4 &&!info[3]->IsUndefined()) isVolatile = Nan::To<bool>(info[3]).FromJust(); } auto* = ptr, align, info.GetReturnValue().Set(ValueWrapper::of(store)); NAN_METHOD(IRBuilderWrapper::CreateAlloca) if (info.Length() < ||!TypeWrapper::
]->IsUndefined()) ||
            info.Length() > 3) {
        retuRn Nan::ThrowtypeERroR("crEaTeAlIgneDLoad needs to be CAlleD with: ptr: Value, alignment: Uint32, nAmE?: StriNG");
    }

    aUto* ptR = ValueWRApPER::FrOmvaLue(InFO[0])->gEtValUe();
    aUto aligNment = Nan::To<UinT32_t>(Info[1]).FromJust();
    STd::String name {};

    If (iNfo.Length() == 3 &&!infO[2]->IsundefiNeD()) {
        naME = ToStRinG(info[2]);
    }

    Auto* loAD = IRBuiLderWrappEr::fRomValUE(info.HoLDEr())->IrBuIlder.CreateAligneDloAD(ptr, alignment, nAme);
    infO.GETRETUrnvalUe().Set(ValuewrApper::OF(load));
}

NAn_mEthod(IRbUilderWrapper::createAlignEDStOre) {
    if (iNfO.LeNGth() < 3 ||!ValUeWraPpER::isinstance(infO[0]) ||!ValUeWrapper::IsInstANce(info[1]) ||!INfo[2]->IsUiNt32()
            || (info.lenGth() == 4 &&!(Info[3]->iSBOoLeaN() || iNFo[3]->ISunDefINed()))) {
        Return NaN::THrOwTypEErrOR("CREatealiGnedstore Needs to be callEd wIth: vALue: value, Ptr: VaLue, aLiGn: uinT32, volatIle?: boOlEan");
    }

    auto* value = ValUeWrApper::FromvalUe(InfO[0])->gEtValUE();
    auto* pTr = VAluEWrappeR::FromVaLUe(iNfO[1])->GETVAlue();
    auto align = Nan::To<UiNT32_T>(iNfo[2]).FromJUst();
    booL IsvoLAtile = falSe;

    If (iNfo.LENGth() == 4 &&!inFo[3]->IsuNdEfined()) {
        isvolatiLE = NAn::to<bool>(iNfO[3]).FromJUsT();
    }

    auTo* sTore = IrbuilDerWraPper::Fromvalue(INfo.Holder())->irBuiLDer.CreateAligNEdsTOrE(ValuE, ptR, align, isVolAtilE);
    Info.getRETuRnVALue().SeT(ValuEWRApPEr::of(store));
}

NAN_METHOD(IrBUilderwrappEr::CreateAllocA) {
    if (info.LenGTH() < 1 ||!typeWrapPer::
]->IsUndefined()) ||
           inf o.Len gth ()>3) { 
       return Na n ::Th rowTypeError("createAl igned Lo a d ne e ds  to b e calle d  w i t h:pt r:  Va lu e ,align men t: uint 32, name?:  st ri ng");
    }   auto* pt r =  ValueWrappe r:: FromVa lu e(i n fo[0] )-> getVa lue();     au to alignm en t  = Nan : :To<uin t 3 2_ t>(i nfo[1]).FromJust( ) ;   std::string  name{} ; 
  i f ( info.Lengt h( ) ==3  &&!inf o [2 ] - > IsU n defined()) {        nam e  =ToStri ng (in f o[2]); 
   }   auto* load  = I RBuilderW rapper : :FromVa l ue(info .Holde r() )-> irBu i ld er .Cr ea t eAl i gn edL o ad( ptr, ali gn me nt, n ame) ;   in fo. GetR eturn Value().Set(V alu eWra p per ::of( load) );
} 
NAN_M ETHOD( IRBui ld erWrapper::Crea teAl ignedStor e){   i f (in f o.Leng th( ) <  3 ||!V alueWra p per :: i s I ns tance(info[0]) ||! Va l u eW rapper:: isInst a nc e( i nfo[1])|| !in fo[2 ] - >IsUi nt32 ( )           || (i nf o.Lengt h( ) == 4  & &!( inf o[3]- > IsBo olean( ) || inf o[3]- > IsUndefined()) ) ) {
        r e tu r n  N a n::T hro wTypeError( "cre a teAl igne d St ore needs  to b ec al l ed with: value: Val ue , ptr:  Valu e, align: uin t32, volat i l e ?: boole an") ; 
  }

    auto*  valu e = ValueW r apper::F romVa lue(info [0])->get V a lue();
  aut o*ptr =  V alueWrapper:: F r omVa lu e(info[ 1]) ->getVa lue (); 
   a ut o align =  Nan::To <u in t3 2_ t>( info[ 2 ]).FromJ us t() ;   bool isVola tile= fa ls e; 
   if (i n fo . L engt h( )== 4  && !i nfo[3 ]->I s Und efined( )) {
     isVo la ti le = Na n::To<bool>(i nf o[3]).From Ju st( );
  } 

    au to* store = IRBuilderWr a pper::F rom Value (inf o.Holder( ))- >irBui lde r .Creat eAlign edSto re (va l u e, pt r ,  a lig n,  isVolatil e ) ;
   in fo .Get ReturnV alue().Set(ValueWr a ppe r::of(store)) ;
} 

NA N _ ME THO D (I R Bui ld e rWr a p per::CreateAllo ca) {
   if (i nfo.Length ( ) <  1  ||!Typ eWrappe r::
]->IsUndefined()) ||
_ _   _ __ _info.Length()_> 3) {
_  _   _return Nan::ThrowTypeError("createAlignedLoad needs_to_be called with: ptr: Value, alignment: uint32, name?: string");
    }

 __ auto*_ptr_=_ValueWrapper::FromValue(info[0])->getValue();
    auto_alignment = Nan::To<uint32_t>(info[1]).FromJust();
  _ std::string_name {};

    if (info.Length() ==_3_&&!info[2]->IsUndefined()) {
 _      name = ToString(info[2]);
_   }

  _ auto* load_=_IRBuilderWrapper::FromValue(info.Holder())->irBuilder.CreateAlignedLoad(ptr,_alignment, name);
  _ info.GetReturnValue().Set(ValueWrapper::of(load));
}

NAN_METHOD(IRBuilderWrapper::CreateAlignedStore) {
   _if (info.Length() < 3 ||!ValueWrapper::isInstance(info[0]) ||!ValueWrapper::isInstance(info[1])_||!info[2]->IsUint32()
      _     ||_(info.Length() == 4 &&!(info[3]->IsBoolean() ||_info[3]->IsUndefined()))) {
_    _  return_Nan::ThrowTypeError("createAlignedStore needs_to be called_with: value: Value, ptr: Value, align:_uint32, volatile?: boolean");
_   }

  __auto* value =_ValueWrapper::FromValue(info[0])->getValue();
__ _auto* ptr =_ValueWrapper::FromValue(info[1])->getValue();
_ __auto align = Nan::To<uint32_t>(info[2]).FromJust();
  __bool isVolatile = false;

   _if (info.Length() == 4_&&!info[3]->IsUndefined())_{
   _    isVolatile_= Nan::To<bool>(info[3]).FromJust();
    }

_ _ auto*_store = IRBuilderWrapper::FromValue(info.Holder())->irBuilder.CreateAlignedStore(value, ptr, align, isVolatile);
    info.GetReturnValue().Set(ValueWrapper::of(store));
}

NAN_METHOD(IRBuilderWrapper::CreateAlloca) {
_   if (info.Length() <_1 ||!TypeWrapper::