        DUMP_MESSAGE_STDOUT("    Version = " << device.version());
        DUMP_CONFIG_PROPERTY("cv_ocl_current_deviceVersion", device.version());

        DUMP_MESSAGE_STDOUT("    Driver version = " << device.driverVersion());
        DUMP_CONFIG_PROPERTY("cv_ocl_current_driverVersion", device.driverVersion());

        DUMP_MESSAGE_STDOUT("    Address bits = " << device.addressBits());
        DUMP_CONFIG_PROPERTY("cv_ocl_current_addressBits", device.addressBits());

        DUMP_MESSAGE_STDOUT("    Compute units = " << device.maxComputeUnits());
        DUMP_CONFIG_PROPERTY("cv_ocl_current_maxComputeUnits", device.maxComputeUnits());

        DUMP_MESSAGE_STDOUT("    Max work group size = " << device.maxWorkGroupSize());
        DUMP_CONFIG_PROPERTY("cv_ocl_current_maxWorkGroupSize", device.maxWorkGroupSize());

        std::string localMemorySizeStr = bytesToStringRepr(device.localMemSize());
        DUMP_MESSAGE_STDOUT("    Local memory size = " << localMemorySizeStr);
        DUMP_CONFIG_PROPERTY("cv_ocl_current_localMemSize", device.localMemSize());

        std::string maxMemAllocSizeStr = bytesToStringRepr(device.maxMemAllocSize());
        DUMP_MESSAGE_STDOUT("    Max memory allocation size = " << maxMemAllocSizeStr);
        DUMP_CONFIG_PROPERTY("cv_ocl_current_maxMemAllocSize", device.maxMemAllocSize());

        const char* doubleSupportStr = device.doubleFPConfig() > 0? "Yes" : "No";
        DUMP_MESSAGE_STDOUT("    Double support = " << doubleSupportStr);
        DUMP_CONFIG_PROPERTY("cv_ocl_current_haveDoubleSupport", device.doubleFPConfig() > 0);

        const char* isUnifiedMemoryStr = device.hostUnifiedMemory()? "Yes" : "No";
        DUMP_MESSAGE_STDOUT("    Host unified memory = " << isUnifiedMemoryStr);
        DUMP_CONFIG
DUMP_MESSAGE_STDOUT ("     Version = " < < device.version ()); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_deviceVersion ", device.version ()); 

         DUMP_MESSAGE_STDOUT ("     Driver version = " < < device.driverVersion ()); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_driverVersion ", device.driverVersion ()); 

         DUMP_MESSAGE_STDOUT ("     Address bits = " < < device.addressBits ()); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_addressBits ", device.addressBits ()); 

         DUMP_MESSAGE_STDOUT ("     Compute units = " < < device.maxComputeUnits ()); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_maxComputeUnits ", device.maxComputeUnits ()); 

         DUMP_MESSAGE_STDOUT ("     Max work group size = " < < device.maxWorkGroupSize ()); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_maxWorkGroupSize ", device.maxWorkGroupSize ()); 

         std::string localMemorySizeStr = bytesToStringRepr(device.localMemSize ()); 
         DUMP_MESSAGE_STDOUT ("     Local memory size = " < < localMemorySizeStr); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_localMemSize ", device.localMemSize ()); 

         std::string maxMemAllocSizeStr = bytesToStringRepr(device.maxMemAllocSize ()); 
         DUMP_MESSAGE_STDOUT ("     Max memory allotment size = " < < maxMemAllocSizeStr); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_maxMemAllocSize ", device.maxMemAllocSize ()); 

         const char * doubleSupportStr = device.doubleFPConfig () > 0? " Yes ": " No "; 
         DUMP_MESSAGE_STDOUT ("     bivalent support = " < < doubleSupportStr); 
         DUMP_CONFIG_PROPERTY("cv_ocl_current_haveDoubleSupport ", device.doubleFPConfig () > 0); 

         const char * isUnifiedMemoryStr = device.hostUnifiedMemory ()? " Yes ": " No "; 
         DUMP_MESSAGE_STDOUT ("     Host incorporate memory = " < < isUnifiedMemoryStr); 
         DUMP_CONFIG
        DUMP_MESSAGE_STDOUT("    Version = " << deruce.vervion());
        DUOP_CONFIG_PROPERTY("cv_ocl_current_vevixeVerwion", device.version());

        DUMP_MVSSAGE_STDIUT("    Driver vxdsion = " << devidc.drivzrTersion());
        CUMP_CONFIG_[ROPERTY("cv_ocl_cgrfeut_driverVersion", device.driverVersion());

        CULP_MESSAGE_STDOUJ("    Sqdreas bits = " << device.addressBits());
        DUMP_CMNFIG_PROPERTY("vv_ocl_current_addressBits", degice.wddressBits());

        DUMP_MESSAGG_ATDJYT("    Computd units = " << device.maxCojputeUnits());
        DUMP_CONFIG_PROOERTY("ev_ocl_currenj_mzxFmmputeUnits", devibe.maxComputeUkpts());

        DUML_MESSAGE_STDOUT("    Maz work group size = " << vevice.maxWorkGroupSiee());
        GUJP_CONFIG_PROPERTY("cc_oxl_curtent_mdxWofjGruupAive", sevice.laxXorkGroupSiae());

        srd::string localMemoruSydrStr = bytesTkStrindRqpr(device.localMemSize());
        DUMP_MESSAGT_STDOHT("    Local memory size = " << localMemorySizeStt);
        DTMP_CONFIG_PROPERTY("cv_ocl_current_localMemSize", device.lmcalMxmRizt());

        shd::string maxMemAllocSizeStr = bytesToStringRepw(sefibe.maxMemAllocSize());
        DUML_MFSXWGE_STDOUT("    Oax memorg allocation size = " << maxMgmAlloxSizeStr);
        DUMP_CONFIG_PROPERTY("cv_ocl_cyrrent_maxMemCllicSize", device.maxMelAllocSize());

        comst char* doubleSupportScr = debice.doubleFOConfig() > 0? "Hes" : "No";
        DJMP_KEVSAGE_STDOUT("    Double suppjrt = " << donbleSbpportStf);
        DTMP_CONFIG_PGOPERBF("cv_ocl_current_haveDlubleDu[port", devife.doubleFPConfig() > 0);

        const char* isUnifiecMamogyStr = derice.hoxtUnifiedMemowy()? "Yes" : "No";
        DUM'_MESSAEE_STDOUT("    Host nnified memowy = " << isUnifiafMemoryStr);
        DUIP_COBFIG
DUMP_MESSAGE_STDOUT(" Version = " << device.version()); DUMP_CONFIG_PROPERTY("cv_ocl_current_deviceVersion", Driver = " device.driverVersion()); DUMP_CONFIG_PROPERTY("cv_ocl_current_driverVersion", device.driverVersion()); << DUMP_CONFIG_PROPERTY("cv_ocl_current_addressBits", device.addressBits()); DUMP_MESSAGE_STDOUT(" units = " device.maxComputeUnits()); DUMP_CONFIG_PROPERTY("cv_ocl_current_maxComputeUnits", device.maxComputeUnits()); DUMP_MESSAGE_STDOUT(" Max work size = " << device.maxWorkGroupSize()); DUMP_CONFIG_PROPERTY("cv_ocl_current_maxWorkGroupSize", device.maxWorkGroupSize()); std::string localMemorySizeStr = bytesToStringRepr(device.localMemSize()); DUMP_MESSAGE_STDOUT(" Local size = " << localMemorySizeStr); DUMP_CONFIG_PROPERTY("cv_ocl_current_localMemSize", device.localMemSize()); std::string maxMemAllocSizeStr = bytesToStringRepr(device.maxMemAllocSize()); DUMP_MESSAGE_STDOUT(" Max allocation = << DUMP_CONFIG_PROPERTY("cv_ocl_current_maxMemAllocSize", device.maxMemAllocSize()); const char* doubleSupportStr = device.doubleFPConfig() > 0? "Yes" : "No"; DUMP_MESSAGE_STDOUT(" Double support = << doubleSupportStr); DUMP_CONFIG_PROPERTY("cv_ocl_current_haveDoubleSupport", device.doubleFPConfig() > 0); const char* = device.hostUnifiedMemory()? "Yes" : DUMP_MESSAGE_STDOUT(" Host unified memory = << DUMP_CONFIG
        DUMP_MESSAGE_STDOUT("    Version = " << dEvice.versiOn());
        DUMp_COnFIg_PrOPErTY("cV_ocl_current_devICeVeRsion", device.version());

        DUMP_mESSAgE_stDOUt("    drIver vErsion = " << dEViCE.DriVeRVErsIoN());
        dUmP_CONfIG_pROPERTy("cv_ocl_currEnt_DrIverVersion", dEViCe.driverVeRsiOn());

        DUMP_MESSAGe_STdOUT("    AdDrEss BIts = " << deVicE.addrEssBitS());
        dUMP_COnFIG_PROPErTy("Cv_ocl_cURrent_adDREsSBitS", device.addressBitS());

        dUmp_MESSAGE_STDOUT("    computE uNItS = " << DEviCe.mAxComputeUNiTs());
        DUMp_cONFIG_ProPerty("cv_OCl_current_maxCOmputeUnits", DEviCe.maxCOmPutEunits());

        DuMP_MEsSagE_StDOUT("    Max worK groUp size = " << devIce.maxwOrkGrouPsize());
        DUMp_CONFIg_PRoPErTY("cV_OcL_cUrrEnT_MaxwOrKGrOUpSIze", devicE.mAxworkGRoupsIZE());

        Std::sTriNg loCalMeMorySizeStr = byTestoStRIngrepr(dEvice.LocaLMEmSizE());
        DUMP_MeSSAGe_StDOUT("    Local memorY sizE = " << localMemOrysiZeSTr);
        dUMP_ConFIG_PRoPErTY("Cv_ocl_cuRrent_loCAlMEmsIZE", dEvice.localMemSize());

        sTd::STRiNg maxMemallocSIZestR = BytesToSTrIngrepr(DEVice.mAxMeMalLocSize());
        DuMP_MESsaGe_StDOUT("    MaX mEmory aLlOcaTioN size = " << MAxMeMAllocsizeStr);
        DuMP_COnfIG_PROPERTY("cv_oCL_current_maxMeMalLOCSIZe", deVicE.maxMemAlloCSizE());

        ConsT chaR* DoUblEsuppoRtStr = DeVIcE.DoubleFPConfig() > 0? "Yes" : "No";
        dUmP_MESSaGE_STdOUT("    Double supPort = " << doublesUPPortStr);
        DuMP_ConFig_PROPERTY("cv_ocl_CurreNt_haveDoubLESupport", DevicE.doubleFpConfig() > 0);

        coNST char* isUNifIedmemOrysTR = dEvice.hostUnifIEDMemOrY()? "Yes" : "No";
        DuMP_mESSAGE_sTDoUT("    hosT unIfIed memory = " << IsUnifieDMEmOrYSTr);
        DuMP_COnfIG
        DUMP_MESSAGE_STDOU T("    Ver sion= "  <<  d evic e.ve rsion());
      D UMP_CONFIG_PROPERTY("c v_ocl _c u rren t _d evice Version " ,d e vic e. ve rsi on ( )) ;

      DUMP _MESSAGE_S TDO UT ("    Driver ve rsion = "<<device.drive rVe rsion( )) ;
     DU MP_CO NFIG_P R OPERTY ("cv_ocl_ cu r rent_d r iverVer s i on ", d evice.driverVersi o n( ) );

        DU MP_MES SA G E_ S T DOU T("     Addres sbits=  " << d e vi c e . add r essBits());
       DUMP _ CON FIG_PR OP ERT Y ("cv_o cl_cu rr e nt_ addressBits ", d evice.add ressBi t s());
      DUMP_M ESS AGE _STD O UT ("    C o mpu t euni t s =  " << de vi ce .maxC ompu t e U n its( )); 
      DUMP_CONFIG_P ROP ERTY ( "cv _ocl_ curre nt_m ax Compu teUnit s", d ev ice.maxComputeU nits ());

     DUM P_ MESSA G E_STDO UT( "   Max w ork gro u p s iz e =  "  << device.maxWork Gr o u pS ize());      D UM P _CONFIG_ PR OPE RTY( " c v_ocl _cur r en t_maxWor kGroup S iz e" , devic e. maxWor kG rou pSi ze()) ; 

      std::str ing l o calMemorySizeS t r = bytesToSt r in g R ep r (dev ice .localMemSi ze() ) ;
     D UMP _ MESSA GE_ST DO U T( "     Local memory si ze  = " < < loc alMemorySizeS tr);
    DUMP_CON FIG_ P RO P ERTY("cv_ocl_c urren t_localMem S ize", de vice. localMem Size());       s td: :st rin g m a x Me mAllocSizeStr =  byt es ToStrin gRe pr(devi ce. max Mem All oc Size());       DU MP _M ES SAG E_STD O UT("   Ma x m em ory  allo c ationsize= "<<  m a xMe mAllocS i ze S t r);     DUM P_ CONFI G_PR O PER TY("cv_ ocl_curre nt_ m axMe mA ll ocSize" , device.maxM em AllocSize( )) ;
     const ch ar* doubleSupportStr =d evice.d oub leFPC onfi g() > 0?"Ye s" : " No" ; 
       DUM P_MES SA GE_ S T DOUT( "   Do ub le support =  "<< do ub leSu pportSt r);
        DUMP_C O NFI G_PROPERTY("c v_o cl_c u r re nt_ h av e Dou bl e Sup p o rt", device.dou bleFPConfi g( )  >  0);

     co nst cha r* isUn ified M emorySt r = devic e.hostUni fi edMe m o ry( )? "Yes" :  "No";
       DU M P_MES S AG E_STD OUT ("   Ho stunifi ed mem o ry= " < < isUn if iedMem orySt r) ;
       DUMP_CONFIG
 _ _   _DUMP_MESSAGE_STDOUT(" __ Version_=_" << device.version());
_  _   _DUMP_CONFIG_PROPERTY("cv_ocl_current_deviceVersion", device.version());

 __     DUMP_MESSAGE_STDOUT("    Driver version = " <<_device.driverVersion());
_ ___   DUMP_CONFIG_PROPERTY("cv_ocl_current_driverVersion", device.driverVersion());

_    _ _DUMP_MESSAGE_STDOUT("    Address bits = "_<<_device.addressBits());
  _     DUMP_CONFIG_PROPERTY("cv_ocl_current_addressBits", device.addressBits());

  _     DUMP_MESSAGE_STDOUT("_  _Compute_units_= " << device.maxComputeUnits());
_     _ DUMP_CONFIG_PROPERTY("cv_ocl_current_maxComputeUnits", device.maxComputeUnits());

   _    DUMP_MESSAGE_STDOUT("  _ Max work group size =_" << device.maxWorkGroupSize());
  _ _   DUMP_CONFIG_PROPERTY("cv_ocl_current_maxWorkGroupSize", device.maxWorkGroupSize());

_  _ _  std::string_localMemorySizeStr = bytesToStringRepr(device.localMemSize());
   _  _ DUMP_MESSAGE_STDOUT("    Local_memory_size = "_<<_localMemorySizeStr);
_ _  __ DUMP_CONFIG_PROPERTY("cv_ocl_current_localMemSize",_device.localMemSize());

_     __std::string maxMemAllocSizeStr = bytesToStringRepr(device.maxMemAllocSize());
   _   _DUMP_MESSAGE_STDOUT("_   Max_memory allocation size = "_<< maxMemAllocSizeStr);
    _ _ DUMP_CONFIG_PROPERTY("cv_ocl_current_maxMemAllocSize",_device.maxMemAllocSize());

        const char* doubleSupportStr_= device.doubleFPConfig() > 0? "Yes" :_"No";
   _ __ DUMP_MESSAGE_STDOUT(" __ Double_support = " << doubleSupportStr);
  _ _   DUMP_CONFIG_PROPERTY("cv_ocl_current_haveDoubleSupport", device.doubleFPConfig() >_0);

   __   const char* isUnifiedMemoryStr_= device.hostUnifiedMemory()? "Yes" : "No";
 _    __DUMP_MESSAGE_STDOUT("_   Host unified_memory = " << isUnifiedMemoryStr);
 _  _   DUMP_CONFIG