// Copyright © 2015, Peter Atashian
// Licensed under the MIT License <LICENSE.md>
//! FFI bindings to oleaut32.
#![cfg(windows)]
extern crate winapi;
use winapi::*;
extern "system" {
    pub fn SysAllocString(psz: *const OLECHAR) -> BSTR;
    pub fn SysReAllocString(pbstr: *mut BSTR, psz: *const OLECHAR) -> INT;
    pub fn SysAllocStringLen(strIn: *const OLECHAR, ui: UINT) -> BSTR;
    pub fn SysReAllocStringLen(pbstr: *mut BSTR, psz: *const OLECHAR, len: c_uint) -> INT;
    pub fn SysFreeString(bstrString: BSTR);
    pub fn SysStringLen(pbstr: BSTR) -> UINT;
    pub fn SysStringByteLen(bstr: BSTR) -> UINT;
    pub fn SysAllocStringByteLen(psz: LPCSTR, len: UINT) -> BSTR;
    pub fn DosDateTimeToVariantTime(
        wDosDate: USHORT, wDosTime: USHORT, pvtime: *mut DOUBLE
    ) -> INT;
    pub fn VariantTimeToDosDateTime(
        vtime: DOUBLE, pwDosDate: *mut USHORT, pwDosTime: *mut USHORT
    ) -> INT;
    pub fn SystemTimeToVariantTime(lpSystemTime: LPSYSTEMTIME, pvtime: *mut DOUBLE) -> INT;
    pub fn VariantTimeToSystemTime(vtime: DOUBLE, lpSystemTime: LPSYSTEMTIME) -> INT;
    // pub fn SafeArrayAllocDescriptor(cDims: UINT, ppsaOut: *mut SAFEARRAY);
    // pub fn SafeArrayAllocDescriptorEx(vt: VARTYPE, cDims: UINT, ppsaOut: *mut SAFEARRAY);
    // pub fn SafeArrayAllocData(psa: *mut SAFEARRAY);
    // pub fn SafeArrayCreate(
    //     vt: VARTYPE, cDims: UINT, rgsabound: *mut SAFEARRAYBOUND
    // ) -> *mut SAFEARRAY;
    // pub fn SafeArrayCreateEx(
    //     vt: VARTYPE, cDims: UINT, rgsabound: *mut SAFEARRAYBOUND, pvExtra: PVOID
    // ) -> *mut SAFEARRAY;
    // pub fn SafeArrayCopyData(psaSource: *mut SAFEARRAY, psaTarget: *mut SAFEARRAY);
    // pub fn SafeArrayDestroyDescriptor(psa: *mut SAFEARRAY);
    // pub fn SafeArrayDestroyData(psa: *mut SAFEARRAY);
    // pub fn SafeArrayDestroy(psa: *mut SAFEARRAY);
    // pub fn SafeArrayRedim(psa: *mut SAFEARRAY, psaboundNew: *mut SAFEARRAYBOUND);
    // pub fn SafeArrayGetDim(psa: *mut SAFEARRAY) -> UINT;
    // pub fn SafeArrayGetElemsize(psa: *mut SAFEARRAY) ->  UINT;
    // pub fn SafeArrayGetUBound(psa: *mut SAFEARRAY, nDim: UINT, plUbound: *mut LONG);
    // pub fn SafeArrayGetLBound(psa: *mut SAFEARRAY, nDim: UINT, plLbound: *mut LONG);
    // pub fn SafeArrayLock(psa: *mut SAFEARRAY);
    // pub fn SafeArrayUnlock(psa: *mut SAFEARRAY);
    // pub fn SafeArrayAccessData(psa: *mut SAFEARRAY, ppvData: *mut *mut c_void);
    // pub fn SafeArrayUnaccessData(psa: *mut SAFEARRAY);
    // pub fn SafeArrayGetElement(psa: *mut SAFEARRAY, rgIndices: *mut LONG, pv: *mut c_void);
    // pub fn SafeArrayPutElement(psa: *mut SAFEARRAY, rgIndices: *mut LONG, pv: *mut c_void);
    // pub fn SafeArrayCopy(psa: *mut SAFEARRAY, ppsaOut: *mut SAFEARRAY);
    // pub fn SafeArrayPtrOfIndex(
    //     psa: *mut SAFEARRAY, rgIndices: *mut LONG, ppvData: *mut *mut c_void
    // );
    // pub fn SafeArraySetRecordInfo(psa: *mut SAFEARRAY, prinfo: *mut IRecordInfo);
    // pub fn SafeArrayGetRecordInfo(psa: *mut SAFEARRAY, prinfo: *mut IRecordInfo);
    // pub fn SafeArraySetIID(psa: *mut SAFEARRAY, guid: REFGUID);
    // pub fn SafeArrayGetIID(psa: *mut SAFEARRAY, pguid: *mut GUID);
    // pub fn SafeArrayGetVartype(psa: *mut SAFEARRAY, pvt: *mut VARTYPE);
    // pub fn SafeArrayCreateVector(
    //     vt: VARTYPE, lLbound: LONG, cElements: ULONG
    // ) -> *mut SAFEARRAY;
    // pub fn SafeArrayCreateVectorEx(
    //     vt: VARTYPE, lLbound: LONG, cElements: ULONG, pvExtra: PVOID
    // ) -> *mut SAFEARRAY;
    // pub fn VariantInit(pvarg: *mut VARIANTARG);
    // pub fn VariantClear(pvarg: *mut VARIANTARG);
    // pub fn VariantCopy(pvargDest: *mut VARIANTARG,pvargSrc: *const VARIANTARG);
    // pub fn VariantCopyInd(pvarDest: *mut VARIANT,pvargSrc: *const VARIANTARG);
    // pub fn VariantChangeType();
    // pub fn VariantChangeTypeEx();
    // pub fn VectorFromBstr(bstr: BSTR, ppsa: *mut SAFEARRAY);
    // pub fn BstrFromVector(psa: *mut SAFEARRAY, pbstr: *mut BSTR);
    pub fn VarUI1FromI2(sIn: SHORT, pbOut: *mut BYTE);
    pub fn VarUI1FromI4(lIn: LONG, pbOut: *mut BYTE);
    pub fn VarUI1FromI8(i64In: LONG64, pbOut: *mut BYTE);
    pub fn VarUI1FromR4(fltIn: FLOAT, pbOut: *mut BYTE);
    pub fn VarUI1FromR8(dblIn: DOUBLE, pbOut: *mut BYTE);
    //pub fn VarUI1FromCy(cyIn: CY, pbOut: *mut BYTE);
    pub fn VarUI1FromDate(dateIn: DATE, pbOut: *mut BYTE);
    pub fn VarUI1FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pbOut: *mut BYTE);
    // pub fn VarUI1FromDisp(pdispIn: *mut IDispatch, lcid: LCID, pbOut: *mut BYTE);
    // pub fn VarUI1FromBool(VARIANT_boolIn: BOOL, pbOut: *mut BYTE);
    pub fn VarUI1FromI1(cIn: CHAR, pbOut: *mut BYTE);
    pub fn VarUI1FromUI2(uiIn: USHORT, pbOut: *mut BYTE);
    pub fn VarUI1FromUI4(ulIn: ULONG, pbOut: *mut BYTE);
    pub fn VarUI1FromUI8(ui64In: ULONG64, pbOut: *mut BYTE);
    pub fn VarUI1FromDec(pdecIn: *const DECIMAL, pbOut: *mut BYTE);
    pub fn VarI2FromUI1(bIn: BYTE, psOut: *mut SHORT);
    pub fn VarI2FromI4(lIn: LONG, psOut: *mut SHORT);
    pub fn VarI2FromI8(i64In: LONG64, psOut: *mut SHORT);
    pub fn VarI2FromR4(fltIn: FLOAT, psOut: *mut SHORT);
    pub fn VarI2FromR8(dblIn: DOUBLE, psOut: *mut SHORT);
    //pub fn VarI2FromCy(cyIn: CY, psOut: *mut SHORT);
    pub fn VarI2FromDate(dateIn: DATE, psOut: *mut SHORT);
    pub fn VarI2FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, psOut: *mut SHORT);
    // pub fn VarI2FromDisp(pdispIn: *mut IDispatch, lcid: LCID, psOut: *mut SHORT);
    // pub fn VarI2FromBool(VARIANT_boolIn: BOOL, psOut: *mut SHORT);
    pub fn VarI2FromI1(cIn: CHAR, psOut: *mut SHORT);
    pub fn VarI2FromUI2(uiIn: USHORT, psOut: *mut SHORT);
    pub fn VarI2FromUI4(ulIn: ULONG, psOut: *mut SHORT);
    pub fn VarI2FromUI8(ui64In: ULONG64, psOut: *mut SHORT);
    pub fn VarI2FromDec(pdecIn: *const DECIMAL, psOut: *mut SHORT);
    pub fn VarI4FromUI1(bIn: BYTE, plOut: *mut LONG);
    pub fn VarI4FromI2(sIn: SHORT, plOut: *mut LONG);
    pub fn VarI4FromI8(i64In: LONG64, plOut: *mut LONG);
    pub fn VarI4FromR4(fltIn: FLOAT, plOut: *mut LONG);
    pub fn VarI4FromR8(dblIn: DOUBLE, plOut: *mut LONG);
    // pub fn VarI4FromCy(cyIn: CY, plOut: *mut LONG);
    pub fn VarI4FromDate(dateIn: DATE, plOut: *mut LONG);
    pub fn VarI4FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, plOut: *mut LONG);
    // pub fn VarI4FromDisp(pdispIn: *mut IDispatch, lcid: LCID, plOut: *mut LONG);
    // pub fn VarI4FromBool(VARIANT_boolIn: BOOL, plOut: *mut LONG);
    pub fn VarI4FromI1(cIn: CHAR, plOut: *mut LONG);
    pub fn VarI4FromUI2(uiIn: USHORT, plOut: *mut LONG);
    pub fn VarI4FromUI4(ulIn: ULONG, plOut: *mut LONG);
    pub fn VarI4FromUI8(ui64In: ULONG64, plOut: *mut LONG);
    pub fn VarI4FromDec(pdecIn: *const DECIMAL, plOut: *mut LONG);
    pub fn VarI8FromUI1(bIn: BYTE, pi64Out: *mut LONG64);
    pub fn VarI8FromI2(sIn: SHORT, pi64Out: *mut LONG64);
    pub fn VarI8FromR4(fltIn: FLOAT, pi64Out: *mut LONG64);
    pub fn VarI8FromR8(dblIn: DOUBLE, pi64Out: *mut LONG64);
    // pub fn VarI8FromCy(cyIn: CY, pi64Out: *mut LONG64);
    pub fn VarI8FromDate(dateIn: DATE, pi64Out: *mut LONG64);
    pub fn VarI8FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pi64Out: *mut LONG64);
    // pub fn VarI8FromDisp(pdispIn: *mut IDispatch, lcid: LCID, pi64Out: *mut LONG64);
    // pub fn VarI8FromBool(VARIANT_boolIn: BOOL, pi64Out: *mut LONG64);
    pub fn VarI8FromI1(cIn: CHAR, pi64Out: *mut LONG64);
    pub fn VarI8FromUI2(uiIn: USHORT, pi64Out: *mut LONG64);
    pub fn VarI8FromUI4(ulIn: ULONG, pi64Out: *mut LONG64);
    pub fn VarI8FromUI8(ui64In: ULONG64, pi64Out: *mut LONG64);
    pub fn VarI8FromDec(pdecIn: *const DECIMAL, pi64Out: *mut LONG64);
    pub fn VarR4FromUI1(bIn: BYTE, pfltOut: *mut FLOAT);
    pub fn VarR4FromI2(sIn: SHORT, pfltOut: *mut FLOAT);
    pub fn VarR4FromI4(lIn: LONG, pfltOut: *mut FLOAT);
    pub fn VarR4FromI8(i64In: LONG64, pfltOut: *mut FLOAT);
    pub fn VarR4FromR8(dblIn: DOUBLE, pfltOut: *mut FLOAT);
    // pub fn VarR4FromCy(cyIn: CY, pfltOut: *mut FLOAT);
    pub fn VarR4FromDate(dateIn: DATE, pfltOut: *mut FLOAT);
    pub fn VarR4FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pfltOut: *mut FLOAT);
    // pub fn VarR4FromDisp(pdispIn: *mut IDispatch, lcid: LCID, pfltOut: *mut FLOAT);
    // pub fn VarR4FromBool(VARIANT_boolIn: BOOL, pfltOut: *mut FLOAT);
    pub fn VarR4FromI1(cIn: CHAR, pfltOut: *mut FLOAT);
    pub fn VarR4FromUI2(uiIn: USHORT, pfltOut: *mut FLOAT);
    pub fn VarR4FromUI4(ulIn: ULONG, pfltOut: *mut FLOAT);
    pub fn VarR4FromUI8(ui64In: ULONG64, pfltOut: *mut FLOAT);
    pub fn VarR4FromDec(pdecIn: *const DECIMAL, pfltOut: *mut FLOAT);
    pub fn VarR8FromUI1(bIn: BYTE, pdblOut: *mut DOUBLE);
    pub fn VarR8FromI2(sIn: SHORT, pdblOut: *mut DOUBLE);
    pub fn VarR8FromI4(lIn: LONG, pdblOut: *mut DOUBLE);
    pub fn VarR8FromI8(i64In: LONG64, pdblOut: *mut DOUBLE);
    pub fn VarR8FromR4(fltIn: FLOAT, pdblOut: *mut DOUBLE);
    // pub fn VarR8FromCy(cyIn: CY, pdblOut: *mut DOUBLE);
    pub fn VarR8FromDate(dateIn: DATE, pdblOut: *mut DOUBLE);
    pub fn VarR8FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pdblOut: *mut DOUBLE);
    // pub fn VarR8FromDisp(pdispIn: *mut IDispatch, lcid: LCID, pdblOut: *mut DOUBLE);
    // pub fn VarR8FromBool(VARIANT_boolIn: BOOL, pdblOut: *mut DOUBLE);
    pub fn VarR8FromI1(cIn: CHAR, pdblOut: *mut DOUBLE);
    pub fn VarR8FromUI2(uiIn: USHORT, pdblOut: *mut DOUBLE);
    pub fn VarR8FromUI4(ulIn: ULONG, pdblOut: *mut DOUBLE);
    pub fn VarR8FromUI8(ui64In: ULONG64, pdblOut: *mut DOUBLE);
    pub fn VarR8FromDec(pdecIn: *const DECIMAL, pdblOut: *mut DOUBLE);
    pub fn VarDateFromUI1(bIn: BYTE, pdateOut: *mut DATE);
    pub fn VarDateFromI2(sIn: SHORT, pdateOut: *mut DATE);
    pub fn VarDateFromI4(lIn: LONG, pdateOut: *mut DATE);
    pub fn VarDateFromI8(i64In: LONG64, pdateOut: *mut DATE);
    pub fn VarDateFromR4(fltIn: FLOAT, pdateOut: *mut DATE);
    pub fn VarDateFromR8(dblIn: DOUBLE, pdateOut: *mut DATE);
    // pub fn VarDateFromCy(cyIn: CY, pdateOut: *mut DATE);
    pub fn VarDateFromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pdateOut: *mut DATE);
    // pub fn VarDateFromDisp(pdispIn: *mut IDispatch, lcid: LCID, pdateOut: *mut DATE);
    // pub fn VarDateFromBool(VARIANT_boolIn: BOOL, pdateOut: *mut DATE);
    pub fn VarDateFromI1(cIn: CHAR, pdateOut: *mut DATE);
    pub fn VarDateFromUI2(uiIn: USHORT, pdateOut: *mut DATE);
    pub fn VarDateFromUI4(ulIn: ULONG, pdateOut: *mut DATE);
    pub fn VarDateFromUI8(ui64In: ULONG64, pdateOut: *mut DATE);
    pub fn VarDateFromDec(pdecIn: *const DECIMAL, pdateOut: *mut DATE);
    // pub fn VarCyFromUI1(bIn: BYTE, pcyOut: *mut CY);
    // pub fn VarCyFromI2(sIn: SHORT, pcyOut: *mut CY);
    // pub fn VarCyFromI4(lIn: LONG, pcyOut: *mut CY);
    // pub fn VarCyFromI8(i64In: LONG64, pcyOut: *mut CY);
    // pub fn VarCyFromR4(fltIn: FLOAT, pcyOut: *mut CY);
    // pub fn VarCyFromR8(dblIn: DOUBLE, pcyOut: *mut CY);
    // pub fn VarCyFromDate(dateIn: DATE, pcyOut: *mut CY);
    // pub fn VarCyFromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pcyOut: *mut CY);
    // pub fn VarCyFromDisp(pdispIn: *mut IDispatch, lcid: LCID, pcyOut: *mut CY);
    // pub fn VarCyFromBool(VARIANT_boolIn: BOOL, pcyOut: *mut CY);
    // pub fn VarCyFromI1(cIn: CHAR, pcyOut: *mut CY);
    // pub fn VarCyFromUI2(uiIn: USHORT, pcyOut: *mut CY);
    // pub fn VarCyFromUI4(ulIn: ULONG, pcyOut: *mut CY);
    // pub fn VarCyFromUI8(ui64In: ULONG64, pcyOut: *mut CY);
    // pub fn VarCyFromDec(pdecIn: *const DECIMAL, pcyOut: *mut CY);
    pub fn VarBstrFromUI1(bVal: BYTE, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromI2(iVal: SHORT, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromI4(lIn: LONG, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromI8(i64In: LONG64, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromR4(fltIn: FLOAT, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromR8(dblIn: DOUBLE, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    // pub fn VarBstrFromCy(cyIn: CY, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromDate(dateIn: DATE, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    // pub fn VarBstrFromDisp(
    //     pdispIn: *mut IDispatch, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR
    // );
    // pub fn VarBstrFromBool(
    //     VARIANT_boolIn: BOOL, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR
    // );
    pub fn VarBstrFromI1(cIn: CHAR, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromUI2(uiIn: USHORT, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromUI4(ulIn: ULONG, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromUI8(ui64In: ULONG64, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR);
    pub fn VarBstrFromDec(
        pdecIn: *const DECIMAL, lcid: LCID, dwFlags: ULONG, pbstrOut: *mut BSTR
    );
    // pub fn VarBoolFromUI1(bIn: BYTE, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromI2(sIn: SHORT, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromI4(lIn: LONG, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromI8(i64In: LONG64, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromR4(fltIn: FLOAT, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromR8(dblIn: DOUBLE, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromDate(dateIn: DATE, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromCy(cyIn: CY, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromStr(
    //     strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, VARIANT_pboolOut: *mut BOOL
    // );
    // pub fn VarBoolFromDisp(pdispIn: *mut IDispatch, lcid: LCID, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromI1(cIn: CHAR, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromUI2(uiIn: USHORT, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromUI4(ulIn: ULONG, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromUI8(i64In: ULONG64, VARIANT_pboolOut: *mut BOOL);
    // pub fn VarBoolFromDec(pdecIn: *const DECIMAL, VARIANT_pboolOut: *mut BOOL);
    pub fn VarUI2FromUI1(bIn: BYTE, puiOut: *mut USHORT);
    pub fn VarUI2FromI2(uiIn: SHORT, puiOut: *mut USHORT);
    pub fn VarUI2FromI4(lIn: LONG, puiOut: *mut USHORT);
    pub fn VarUI2FromI8(i64In: LONG64, puiOut: *mut USHORT);
    pub fn VarUI2FromR4(fltIn: FLOAT, puiOut: *mut USHORT);
    pub fn VarUI2FromR8(dblIn: DOUBLE, puiOut: *mut USHORT);
    pub fn VarUI2FromDate(dateIn: DATE, puiOut: *mut USHORT);
    // pub fn VarUI2FromCy(cyIn: CY, puiOut: *mut USHORT);
    pub fn VarUI2FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, puiOut: *mut USHORT);
    // pub fn VarUI2FromDisp(pdispIn: *mut IDispatch, lcid: LCID, puiOut: *mut USHORT);
    // pub fn VarUI2FromBool(VARIANT_boolIn: BOOL, puiOut: *mut USHORT);
    pub fn VarUI2FromI1(cIn: CHAR, puiOut: *mut USHORT);
    pub fn VarUI2FromUI4(ulIn: ULONG, puiOut: *mut USHORT);
    pub fn VarUI2FromUI8(i64In: ULONG64, puiOut: *mut USHORT);
    pub fn VarUI2FromDec(pdecIn: *const DECIMAL, puiOut: *mut USHORT);
    pub fn VarUI4FromUI1(bIn: BYTE, pulOut: *mut ULONG);
    pub fn VarUI4FromI2(uiIn: SHORT, pulOut: *mut ULONG);
    pub fn VarUI4FromI4(lIn: LONG, pulOut: *mut ULONG);
    pub fn VarUI4FromI8(i64In: LONG64, plOut: *mut ULONG);
    pub fn VarUI4FromR4(fltIn: FLOAT, pulOut: *mut ULONG);
    pub fn VarUI4FromR8(dblIn: DOUBLE, pulOut: *mut ULONG);
    pub fn VarUI4FromDate(dateIn: DATE, pulOut: *mut ULONG);
    // pub fn VarUI4FromCy(cyIn: CY, pulOut: *mut ULONG);
    pub fn VarUI4FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pulOut: *mut ULONG);
    // pub fn VarUI4FromDisp(pdispIn: *mut IDispatch, lcid: LCID, pulOut: *mut ULONG);
    // pub fn VarUI4FromBool(VARIANT_boolIn: BOOL, pulOut: *mut ULONG);
    pub fn VarUI4FromI1(cIn: CHAR, pulOut: *mut ULONG);
    pub fn VarUI4FromUI2(uiIn: USHORT, pulOut: *mut ULONG);
    pub fn VarUI4FromUI8(ui64In: ULONG64, plOut: *mut ULONG);
    pub fn VarUI4FromDec(pdecIn: *const DECIMAL, pulOut: *mut ULONG);
    pub fn VarUI8FromUI1(bIn: BYTE, pi64Out: *mut ULONG64);
    pub fn VarUI8FromI2(sIn: SHORT, pi64Out: *mut ULONG64);
    pub fn VarUI8FromI4(lIn: LONG, pi64Out: *mut ULONG64);
    pub fn VarUI8FromI8(ui64In: LONG64, pi64Out: *mut ULONG64);
    pub fn VarUI8FromR4(fltIn: FLOAT, pi64Out: *mut ULONG64);
    pub fn VarUI8FromR8(dblIn: DOUBLE, pi64Out: *mut ULONG64);
    // pub fn VarUI8FromCy(cyIn: CY, pi64Out: *mut ULONG64);
    pub fn VarUI8FromDate(dateIn: DATE, pi64Out: *mut ULONG64);
    pub fn VarUI8FromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pi64Out: *mut ULONG64);
    // pub fn VarUI8FromDisp(pdispIn: *mut IDispatch, lcid: LCID, pi64Out: *mut ULONG64);
    // pub fn VarUI8FromBool(VARIANT_boolIn: BOOL, pi64Out: *mut ULONG64);
    pub fn VarUI8FromI1(cIn: CHAR, pi64Out: *mut ULONG64);
    pub fn VarUI8FromUI2(uiIn: USHORT, pi64Out: *mut ULONG64);
    pub fn VarUI8FromUI4(ulIn: ULONG, pi64Out: *mut ULONG64);
    pub fn VarUI8FromDec(pdecIn: *const DECIMAL, pi64Out: *mut ULONG64);
    pub fn VarDecFromUI1(bIn: BYTE, pdecOut: *mut DECIMAL);
    pub fn VarDecFromI2(uiIn: SHORT, pdecOut: *mut DECIMAL);
    pub fn VarDecFromI4(lIn: LONG, pdecOut: *mut DECIMAL);
    pub fn VarDecFromI8(i64In: LONG64, pdecOut: *mut DECIMAL);
    pub fn VarDecFromR4(fltIn: FLOAT, pdecOut: *mut DECIMAL);
    pub fn VarDecFromR8(dblIn: DOUBLE, pdecOut: *mut DECIMAL);
    pub fn VarDecFromDate(dateIn: DATE, pdecOut: *mut DECIMAL);
    // pub fn VarDecFromCy(cyIn: CY, pdecOut: *mut DECIMAL);
    pub fn VarDecFromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG, pdecOut: *mut DECIMAL);
    // pub fn VarDecFromDisp(pdispIn: *mut IDispatch, lcid: LCID, pdecOut: *mut DECIMAL);
    // pub fn VarDecFromBool(VARIANT_boolIn: BOOL, pdecOut: *mut DECIMAL);
    pub fn VarDecFromI1(cIn: CHAR, pdecOut: *mut DECIMAL);
    pub fn VarDecFromUI2(uiIn: USHORT, pdecOut: *mut DECIMAL);
    pub fn VarDecFromUI4(ulIn: ULONG, pdecOut: *mut DECIMAL);
    pub fn VarDecFromUI8(ui64In: ULONG64, pdecOut: *mut DECIMAL);
    // pub fn VarParseNumFromStr(strIn: LPCOLESTR, lcid: LCID, dwFlags: ULONG,
    // pub fn VarNumFromParseNum(pnumprs: *mut NUMPARSE, rgbDig: *mut BYTE,
    // pub fn VarAdd(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarAnd(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarCat(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarDiv(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarEqv(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarIdiv(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarImp(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarMod(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarMul(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarOr(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarPow(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarSub(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarXor(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarAbs(pvarIn: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarFix(pvarIn: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarInt(pvarIn: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarNeg(pvarIn: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarNot(pvarIn: LPVARIANT, pvarResult: LPVARIANT);
    // pub fn VarRound(pvarIn: LPVARIANT, cDecimals: c_int, pvarResult: LPVARIANT);
    // pub fn VarCmp(pvarLeft: LPVARIANT, pvarRight: LPVARIANT, lcid: LCID, dwFlags: ULONG);

    pub fn VarDecAdd(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecDiv(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecMul(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecSub(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecAbs(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecFix(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecInt(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecNeg(pdecIn: LPDECIMAL, pdecResult: LPDECIMAL);
    pub fn VarDecRound(pdecIn: LPDECIMAL, cDecimals: c_int, pdecResult: LPDECIMAL);
    pub fn VarDecCmp(pdecLeft: LPDECIMAL, pdecRight: LPDECIMAL);
    pub fn VarDecCmpR8(pdecLeft: LPDECIMAL, dblRight: c_double);
    // pub fn VarCyAdd(cyLeft: CY, cyRight: CY, pcyResult: LPCY);
    // pub fn VarCyMul(cyLeft: CY, cyRight: CY, pcyResult: LPCY);
    // pub fn VarCyMulI4(cyLeft: CY, lRight: LONG, pcyResult: LPCY);
    // pub fn VarCyMulI8(cyLeft: CY, lRight: LONG64, pcyResult: LPCY);
    // pub fn VarCySub(cyLeft: CY, cyRight: CY, pcyResult: LPCY);
    // pub fn VarCyAbs(cyIn: CY, pcyResult: LPCY);
    // pub fn VarCyFix(cyIn: CY, pcyResult: LPCY);
    // pub fn VarCyInt(cyIn: CY, pcyResult: LPCY);
    // pub fn VarCyNeg(cyIn: CY, pcyResult: LPCY);
    // pub fn VarCyRound(cyIn: CY, cDecimals: c_int, pcyResult: LPCY);
    // pub fn VarCyCmp(cyLeft: CY, cyRight: CY);
    // pub fn VarCyCmpR8(cyLeft: CY, dblRight: c_double);
    pub fn VarBstrCat(bstrLeft: BSTR, bstrRight: BSTR, pbstrResult: LPBSTR);
    pub fn VarBstrCmp(bstrLeft: BSTR, bstrRight: BSTR, lcid: LCID, dwFlags: ULONG);
    pub fn VarR8Pow(dblLeft: c_double, dblRight: c_double, pdblResult: *mut c_double);
    pub fn VarR4CmpR8(fltLeft: c_float, dblRight: c_double);
    pub fn VarR8Round(dblIn: c_double, cDecimals: c_int, pdblResult: *mut c_double);
    // pub fn VarDateFromUdate(pudateIn: *mut UDATE, dwFlags: ULONG, pdateOut: *mut DATE);
    // pub fn VarDateFromUdateEx(
    //     pudateIn: *mut UDATE, lcid: LCID, dwFlags: ULONG, pdateOut: *mut DATE
    // );
    // pub fn VarUdateFromDate(dateIn: DATE, dwFlags: ULONG, pudateOut: *mut UDATE);
    pub fn GetAltMonthNames(lcid: LCID, prgp: *mut LPOLESTR);
    // pub fn VarFormat();
    // pub fn VarFormatDateTime();
    // pub fn VarFormatNumber();
    // pub fn VarFormatPercent();
    // pub fn VarFormatCurrency();
    // pub fn VarWeekdayName();
    // pub fn VarMonthName();
    // pub fn VarFormatFromTokens();
    // pub fn VarTokenizeFormatString();
    // pub fn LHashValOfNameSysA();
    // pub fn LoadTypeLib(szFile: LPCOLESTR, pptlib: *mut ITypeLib);
    // pub fn LoadTypeLibEx();
    // pub fn LoadRegTypeLib();
    // pub fn QueryPathOfRegTypeLib();
    // pub fn RegisterTypeLib();
    // pub fn UnRegisterTypeLib();
    // pub fn RegisterTypeLibForUser();
    // pub fn UnRegisterTypeLibForUser();
    // pub fn CreateTypeLib();
    // pub fn CreateTypeLib2();
    // pub fn DispGetParam();
    // pub fn DispGetIDsOfNames();
    // pub fn DispInvoke();
    // pub fn CreateDispTypeInfo();
    // pub fn CreateStdDispatch();
    // pub fn DispCallFunc();
    // pub fn RegisterActiveObject();
    pub fn RevokeActiveObject(dwRegister: DWORD, pvReserved: *mut c_void);
    // pub fn GetActiveObject();
    // pub fn SetErrorInfo(dwReserved: ULONG, perrinfo: *mut IErrorInfo);
    // pub fn GetErrorInfo(dwReserved: ULONG, pperrinfo: *mut IErrorInfo);
    // pub fn CreateErrorInfo(pperrinfo: *mut ICreateErrorInfo);
    // pub fn GetRecordInfoFromTypeInfo();
    // pub fn GetRecordInfoFromGuids();
    pub fn OaBuildVersion() -> ULONG;
    // pub fn ClearCustData(pCustData: LPCUSTDATA);
    pub fn OaEnablePerUserTLibRegistration();
}