"""
This file was auto-generated by the script:
https://github.com/usnistgov/REFPROP-wrappers/wrappers/python/ctypes/build_wrapper.py
on 20 Dec 2024 09:25:22.  This interface was written by Ian Bell. 

If you have any problems, please file an issue at:
https://github.com/usnistgov/REFPROP-wrappers/issues/
"""


from __future__ import print_function
import ctypes as ct
import sys, os, glob
from collections import namedtuple
import functools
import array
import warnings
from pathlib import Path

# In Python 2.x, the array.array function cannot accept the bytearray(x) as an argument, and 
# therefore, we just pass a copy, which is slower in python 2.7, but seems like the best that
# can be done
if sys.version_info > (2,0) and sys.version_info < (3,0):
    f_bytearray = lambda x: x
else:
    f_bytearray = bytearray

def to_double_array(l):
    """
    Convert an object with a buffer interface containing doubles to an array.array of double type
    """
    return array.array('d',f_bytearray(l))

def to_int_array(l):
    """
    Convert an object with a buffer interface containing integers to an array.array of int type
    """
    return array.array('i',f_bytearray(l))

def trim(s):
    return s.replace(b'\x00',b'').strip().decode('utf-8')

def get_default_DLL_extension():
    """
    Get the default file extension for a shared library
    """
    if sys.platform.startswith('win'):
        shared_extension = 'dll'
    elif sys.platform.startswith('darwin'):
        shared_extension = 'dylib'
    else:
        shared_extension = 'so'
    return shared_extension

class REFPROPLibraryManager(object):

    def __init__(self, manager_shared_library):
        """
        Parameters
        ==========
        manager_shared_library : str
            The absolute path to the REFPROP manager that should be used (see https://github.com/usnistgov/REFPROP-manager)
        """

        if sys.platform.startswith('win'):
            loader_fcn = ct.WinDLL
        else:
            loader_fcn = ct.CDLL

        if not os.path.isfile(manager_shared_library):
            raise ValueError("Absolute path to manager DLL is invalid")
        else:
            # Load the manager DLL!
            self.manager = loader_fcn(manager_shared_library)

    def get_instance(self, path, shared_library_filename):
        """
        You can either provide a path to a directory, in which case it will search 
        for the necessary DLL in that directory, or an absolute path to a shared library

        Parameters
        ==========
        name : str 
            The name, either of a folder or a file
        shared_extension : str
            The extension that should be queried when searching for shared libraries.  
            Uses the architecture-specific file extension by default
        """
        
        # Get the handle to the construct_handle function
        construct_handle = getattr(self.manager, "construct_handle")

        # Construct the arguments
        c_path = ct.create_string_buffer(path.encode('utf-8'))
        c_shared_library_filename = ct.create_string_buffer(shared_library_filename.encode('utf-8'))
        c_errcode = ct.c_int(0)
        c_errstr = ct.create_string_buffer(255)

        # Get the handle (hopefully)
        managed_handle = construct_handle(c_path, c_shared_library_filename, ct.byref(c_errcode), c_errstr, 255)

        # Check if it worked properly
        if c_errcode.value != 0:
            raise ValueError("Unable to get instance with error message:"+trim(c_errstr.raw))
        return REFPROPInstance(self.manager, managed_handle)
        
    def free_instance(self, instance):
        free_handle = getattr(self.manager, "free_handle")
        c_errcode = ct.c_int(0)
        c_errstr = ct.create_string_buffer(255)

        free_handle(instance.managed_handle, ct.byref(c_errcode), c_errstr, 255)
        
        # Check if it worked properly
        if c_errcode.value != 0:
            raise ValueError("Unable to free instance with error message:"+trim(c_errstr.raw))

def REFPROPFunctionLibrary(name, shared_extension = None):

    """
    You can either provide a path to a directory, in which case it will search 
    for the necessary DLL in that directory, or an absolute path to a shared library

    Parameters
    ==========
    name : str 
        The name, either of a folder or a file
    shared_extension : str
        The extension that should be queried when searching for shared libraries.  
        Uses the architecture-specific file extension by default
    """

    if sys.platform.startswith('win'):
        loader_fcn = ct.WinDLL
    else:
        loader_fcn = ct.CDLL

    # An absolute path to a file was provided, we will use it
    if os.path.isfile(name):
        full_path = name
        root_dir = os.path.dirname(full_path)
    # If the provided string is a path, then we use it to find any shared libraries
    elif os.path.isdir(name):
        root_dir = name
        # Determine the shared library extension
        if shared_extension is None:
            shared_extension = get_default_DLL_extension()

        sos = [f for f in glob.glob(os.path.join(name, '*.' + shared_extension)) if 'ISOCHR' not in f and '_thunk_pcwin64' not in f]
        if len(sos) == 0:
            raise ValueError('No shared libraries were found in the folder "{name:s}" with the extension ".{ext:s}"'.format(ext=shared_extension,name=name))
        elif len(sos) == 1:
            full_path = sos[0]
        else:
            good_so = []
            
            from pathlib import Path
            for so in sos:

                p = Path(so)
                # Skip symbolic links
                # the two dll generated by REFPROP-cmake have one symlinking to the other one,
                # so help the user by skipping the one that is a symlink
                if p.is_symlink() and p.exists():
                    warnings.warn(f'symbolic link shared library has been skipped: {so}')
                    continue

                try:
                    trash = loader_fcn(so)
                    good_so.append(so)
                    del trash
                except BaseException as BE:
                    pass # do nothing, we just won't keep this shared library
            if len(good_so) == 0:
                raise ValueError('No shared libraries were found in the folder "{name:s}" with the extension ".{ext:s}"'.format(ext=shared_extension,name=name))
            elif len(good_so) == 1:
                full_path = good_so[0]
            else:
                raise ValueError('Too many loadable shared libraries were found in the folder "{name:s}"; obtained libraries were: {libs:s}.  You must provide an absolute path to the shared library you would like to load'.format(name=name, libs=str(list(good_so))))
    else:
        raise ValueError('"{name:s}" is neither a directory nor a file'.format(name=name))

    # Now load the library
    dll = loader_fcn(full_path)

    managed_handle = None # Not part of the manager, we are creating a standalone instance of REFPROP
    return REFPROPInstance(dll, managed_handle)

class REFPROPInstance(object):

    class ManagedFunctionCall(object):
        """ 
        A wrapper class that decorates the call to the managed DLL so that the argument 
        handling is the same as for "normal" DLL 
        """
        def __init__(self, f, managed_handle):
            self.f = f
            self.managed_handle = managed_handle

        def __call__(self, *args, **kwargs):
            handle = ct.c_int(self.managed_handle)
            errcode = ct.c_int(0)
            # Call the function, forwarding all arguments to the relevant function from the DLL
            self.f(handle, ct.byref(errcode), *args, **kwargs)
            # If it was not possible to get the handle, that is a terminal python-level error
            # Otherwise, error handling is done by the REFPROP DLL itself
            if errcode.value != 0:
                raise ValueError("Unable to access the handle, error code was: " + str(errcode.value))

    def _getfcn(self, DLL, fname):
        """
        Try to obtain a function pointer to the function in the shared library.  
        If you cannot attach the function, return None.  
        """
        
        if self.managed_handle:
            try:
                # Get the function from the DLL
                func = getattr(DLL, fname)
                # Return a managed function call so that all the remaining arguments will be after the handle
                # The remaining arguments will be the "normal" arguments to the method
                return self.ManagedFunctionCall(func, self.managed_handle)
            except BaseException as BE:
                # print(BE) # Uncomment to see why the call failed
                return None
        else:
            try:
                return getattr(DLL, fname)
            except BaseException as BE:
                return None

    def __init__(self, dll, managed_handle = None):
        """
        Parameters
        ==========
        dll : 
            The instance of the DLL/SO/DYLIB generated by the REFPROPFunctionLibrary factory function
            for by the manager class
        managed_handle : int, optional
            The integer handle of the copy of REFPROP being managed by the REFPROPLibraryManager
        """
        self.dll = dll
        self.managed_handle = managed_handle

        # Named tuples to contain the outputs of DLL calls
        self._ABFL1dlloutput_tuple = namedtuple('ABFL1dlloutput',["T","P","D","ierr","herr"])
        self._ABFL2dlloutput_tuple = namedtuple('ABFL2dlloutput',["Tbub","Tdew","Pbub","Pdew","Dlbub","Dvdew","ybub","xdew","T","P","Dl","Dv","x","y","q","ierr","herr"])
        self._ABFLASHdlloutput_tuple = namedtuple('ABFLASHdlloutput',["T","P","D","Dl","Dv","x","y","q","e","h","s","Cv","Cp","w","ierr","herr"])
        self._ABFLSHdlloutput_tuple = namedtuple('ABFLSHdlloutput',["T","P","D","Dl","Dv","x","y","q","e","h","s","Cv","Cp","w","ierr","herr"])
        self._AGdlloutput_tuple = namedtuple('AGdlloutput',["a","g"])
        self._ALLPROPS0dlloutput_tuple = namedtuple('ALLPROPS0dlloutput',["Output","ierr","herr"])
        self._ALLPROPS1dlloutput_tuple = namedtuple('ALLPROPS1dlloutput',["c","ierr","herr"])
        self._ALLPROPS20dlloutput_tuple = namedtuple('ALLPROPS20dlloutput',["Output","hUnitsArray","iUCodeArray","ierr","herr"])
        self._ALLPROPSdlloutput_tuple = namedtuple('ALLPROPSdlloutput',["Output","hUnitsArray","iUCodeArray","ierr","herr"])
        self._BLCRVdlloutput_tuple = namedtuple('BLCRVdlloutput',["T","ierr","herr"])
        self._CCRITdlloutput_tuple = namedtuple('CCRITdlloutput',["Cs","Ts","Ds","Ps","ws","ierr","herr"])
        self._CHEMPOTdlloutput_tuple = namedtuple('CHEMPOTdlloutput',["u","ierr","herr"])
        self._CRITPdlloutput_tuple = namedtuple('CRITPdlloutput',["Tc","Pc","Dc","ierr","herr"])
        self._CRTPNTdlloutput_tuple = namedtuple('CRTPNTdlloutput',["Tc","Pc","Dc","ierr","herr"])
        self._CSATKdlloutput_tuple = namedtuple('CSATKdlloutput',["P","D","Csat","ierr","herr"])
        self._CSTARdlloutput_tuple = namedtuple('CSTARdlloutput',["Cs","Ts","Ds","Ps","ws","ierr","herr"])
        self._CV2PKdlloutput_tuple = namedtuple('CV2PKdlloutput',["Cv2p","Csat","ierr","herr"])
        self._CVCPKdlloutput_tuple = namedtuple('CVCPKdlloutput',["Cv","Cp"])
        self._CVCPdlloutput_tuple = namedtuple('CVCPdlloutput',["Cv","Cp"])
        self._DBFL1dlloutput_tuple = namedtuple('DBFL1dlloutput',["T","P","ierr","herr"])
        self._DBFL2dlloutput_tuple = namedtuple('DBFL2dlloutput',["T","P","Dl","Dv","x","y","q","ierr","herr"])
        self._DEFL1dlloutput_tuple = namedtuple('DEFL1dlloutput',["T","ierr","herr"])
        self._DEFLSHdlloutput_tuple = namedtuple('DEFLSHdlloutput',["T","P","Dl","Dv","x","y","q","h","s","Cv","Cp","w","ierr","herr"])
        self._DERVPVTdlloutput_tuple = namedtuple('DERVPVTdlloutput',["dPdD","dPdT","d2PdD2","d2PdT2","d2PdTD","dDdP","dDdT","d2DdP2","d2DdT2","d2DdPT","dTdP","dTdD","d2TdP2","d2TdD2","d2TdPD"])
        self._DHD1dlloutput_tuple = namedtuple('DHD1dlloutput',["dhdt_d","dhdt_p","dhdd_t","dhdd_p","dhdp_t","dhdp_d"])
        self._DHFL1dlloutput_tuple = namedtuple('DHFL1dlloutput',["T","ierr","herr"])
        self._DHFLSHdlloutput_tuple = namedtuple('DHFLSHdlloutput',["T","P","Dl","Dv","x","y","q","e","s","Cv","Cp","w","ierr","herr"])
        self._DLSATKdlloutput_tuple = namedtuple('DLSATKdlloutput',["D","ierr","herr"])
        self._DPTSATKdlloutput_tuple = namedtuple('DPTSATKdlloutput',["P","D","Csat","dPdT","ierr","herr"])
        self._DQFL2dlloutput_tuple = namedtuple('DQFL2dlloutput',["T","P","Dl","Dv","x","y","ierr","herr"])
        self._DSD1dlloutput_tuple = namedtuple('DSD1dlloutput',["dsdt_d","dsdt_p","dsdd_t","dsdd_p","dsdp_t","dsdp_d"])
        self._DSFL1dlloutput_tuple = namedtuple('DSFL1dlloutput',["T","ierr","herr"])
        self._DSFLSHdlloutput_tuple = namedtuple('DSFLSHdlloutput',["T","P","Dl","Dv","x","y","q","e","h","Cv","Cp","w","ierr","herr"])
        self._DVSATKdlloutput_tuple = namedtuple('DVSATKdlloutput',["D","ierr","herr"])
        self._ESFLSHdlloutput_tuple = namedtuple('ESFLSHdlloutput',["T","P","D","Dl","Dv","x","y","q","h","Cv","Cp","w","ierr","herr"])
        self._EXCESSdlloutput_tuple = namedtuple('EXCESSdlloutput',["D","vE","eE","hE","sE","aE","gE","ierr","herr"])
        self._FGCTY2dlloutput_tuple = namedtuple('FGCTY2dlloutput',["f","ierr","herr"])
        self._FLAGSdlloutput_tuple = namedtuple('FLAGSdlloutput',["kFlag","ierr","herr"])
        self._FUGCOFdlloutput_tuple = namedtuple('FUGCOFdlloutput',["phi","ierr","herr"])
        self._GERG04dlloutput_tuple = namedtuple('GERG04dlloutput',["ierr","herr"])
        self._GERG08dlloutput_tuple = namedtuple('GERG08dlloutput',["ierr","herr"])
        self._GETENUMdlloutput_tuple = namedtuple('GETENUMdlloutput',["iEnum","ierr","herr"])
        self._GETFIJdlloutput_tuple = namedtuple('GETFIJdlloutput',["fij","hfij","hmxrul"])
        self._GETKTVdlloutput_tuple = namedtuple('GETKTVdlloutput',["hmodij","fij","hFmix","hfij","hbinp","hmxrul"])
        self._GETMODdlloutput_tuple = namedtuple('GETMODdlloutput',["hcode","hcite"])
        self._GIBBSdlloutput_tuple = namedtuple('GIBBSdlloutput',["ar","gr"])
        self._HEATFRMdlloutput_tuple = namedtuple('HEATFRMdlloutput',["hFrm","ierr","herr"])
        self._HEATdlloutput_tuple = namedtuple('HEATdlloutput',["hg","hn","ierr","herr"])
        self._HMXORDERdlloutput_tuple = namedtuple('HMXORDERdlloutput',["hcasi","hcasj","iFlag","ierr","herr"])
        self._HSFL1dlloutput_tuple = namedtuple('HSFL1dlloutput',["T","D","ierr","herr"])
        self._HSFLSHdlloutput_tuple = namedtuple('HSFLSHdlloutput',["T","P","D","Dl","Dv","x","y","q","e","Cv","Cp","w","ierr","herr"])
        self._IDCRVdlloutput_tuple = namedtuple('IDCRVdlloutput',["T","ierr","herr"])
        self._INFOdlloutput_tuple = namedtuple('INFOdlloutput',["wmm","Ttrp","Tnbpt","Tc","Pc","Dc","Zc","acf","dip","Rgas"])
        self._JICRVdlloutput_tuple = namedtuple('JICRVdlloutput',["T","ierr","herr"])
        self._JTCRVdlloutput_tuple = namedtuple('JTCRVdlloutput',["T","ierr","herr"])
        self._LIMITKdlloutput_tuple = namedtuple('LIMITKdlloutput',["Tmin","Tmax","Dmax","Pmax","ierr","herr"])
        self._LIMITSdlloutput_tuple = namedtuple('LIMITSdlloutput',["Tmin","Tmax","Dmax","Pmax"])
        self._LIMITXdlloutput_tuple = namedtuple('LIMITXdlloutput',["Tmin","Tmax","Dmax","Pmax","ierr","herr"])
        self._LIQSPNDLdlloutput_tuple = namedtuple('LIQSPNDLdlloutput',["D","ierr","herr"])
        self._MASSFLUXdlloutput_tuple = namedtuple('MASSFLUXdlloutput',["fluxm","Cs","T0","P0","xMach","u","Ts","Ps","ierr","herr"])
        self._MAXPdlloutput_tuple = namedtuple('MAXPdlloutput',["Tm","Pm","Dm","ierr","herr"])
        self._MAXTdlloutput_tuple = namedtuple('MAXTdlloutput',["Tm","Pm","Dm","ierr","herr"])
        self._MELTKdlloutput_tuple = namedtuple('MELTKdlloutput',["P","ierr","herr"])
        self._MELTPdlloutput_tuple = namedtuple('MELTPdlloutput',["T","ierr","herr"])
        self._MELTTdlloutput_tuple = namedtuple('MELTTdlloutput',["P","ierr","herr"])
        self._MLTH2Odlloutput_tuple = namedtuple('MLTH2Odlloutput',["P1","P2"])
        self._NAMEdlloutput_tuple = namedtuple('NAMEdlloutput',["hnam","hn80","hcasn"])
        self._PASSCMNdlloutput_tuple = namedtuple('PASSCMNdlloutput',["hstr","ilng","dbl","arr","ierr","herr"])
        self._PDFL1dlloutput_tuple = namedtuple('PDFL1dlloutput',["T","ierr","herr"])
        self._PDFLSHdlloutput_tuple = namedtuple('PDFLSHdlloutput',["T","Dl","Dv","x","y","q","e","h","s","Cv","Cp","w","ierr","herr"])
        self._PEFL1dlloutput_tuple = namedtuple('PEFL1dlloutput',["T","D","ierr","herr"])
        self._PEFLSHdlloutput_tuple = namedtuple('PEFLSHdlloutput',["T","D","Dl","Dv","x","y","q","h","s","Cv","Cp","w","ierr","herr"])
        self._PHFL1dlloutput_tuple = namedtuple('PHFL1dlloutput',["T","D","ierr","herr"])
        self._PHFLSHdlloutput_tuple = namedtuple('PHFLSHdlloutput',["T","D","Dl","Dv","x","y","q","e","s","Cv","Cp","w","ierr","herr"])
        self._PHIDERVdlloutput_tuple = namedtuple('PHIDERVdlloutput',["dadn","dnadn","ierr","herr"])
        self._PQFLSHdlloutput_tuple = namedtuple('PQFLSHdlloutput',["T","D","Dl","Dv","x","y","e","h","s","Cv","Cp","w","ierr","herr"])
        self._PSATKdlloutput_tuple = namedtuple('PSATKdlloutput',["P","ierr","herr"])
        self._PSFL1dlloutput_tuple = namedtuple('PSFL1dlloutput',["T","D","ierr","herr"])
        self._PSFLSHdlloutput_tuple = namedtuple('PSFLSHdlloutput',["T","D","Dl","Dv","x","y","q","e","h","Cv","Cp","w","ierr","herr"])
        self._QMASSdlloutput_tuple = namedtuple('QMASSdlloutput',["qkg","xlkg","xvkg","wliq","wvap","ierr","herr"])
        self._QMOLEdlloutput_tuple = namedtuple('QMOLEdlloutput',["qmol","xl","xv","wliq","wvap","ierr","herr"])
        self._RDXHMXdlloutput_tuple = namedtuple('RDXHMXdlloutput',["Tred","Dred","ierr","herr"])
        self._REDXdlloutput_tuple = namedtuple('REDXdlloutput',["Tred","Dred"])
        self._REFPROP1dlloutput_tuple = namedtuple('REFPROP1dlloutput',["z","c","q","ierr","herr"])
        self._REFPROP2dlloutput_tuple = namedtuple('REFPROP2dlloutput',["z","Output","q","ierr","herr"])
        self._REFPROPdlloutput_tuple = namedtuple('REFPROPdlloutput',["z","Output","hUnits","iUCode","x","y","x3","q","ierr","herr"])
        self._RESIDUALdlloutput_tuple = namedtuple('RESIDUALdlloutput',["Pr","er","hr","sr","Cvr","Cpr","ar","gr"])
        self._SATDdlloutput_tuple = namedtuple('SATDdlloutput',["kr","T","P","Dl","Dv","x","y","ierr","herr"])
        self._SATESTdlloutput_tuple = namedtuple('SATESTdlloutput',["T","P","x","y","ierr","herr"])
        self._SATEdlloutput_tuple = namedtuple('SATEdlloutput',["nroot","k1","T1","P1","D1","k2","T2","P2","D2","ierr","herr"])
        self._SATGUESSdlloutput_tuple = namedtuple('SATGUESSdlloutput',["T","P","D","h","s","Dy","y","ierr","herr"])
        self._SATGVdlloutput_tuple = namedtuple('SATGVdlloutput',["T","P","Dx","Dy","x","y","ierr","herr"])
        self._SATHdlloutput_tuple = namedtuple('SATHdlloutput',["nroot","k1","T1","P1","D1","k2","T2","P2","D2","ierr","herr"])
        self._SATPESTdlloutput_tuple = namedtuple('SATPESTdlloutput',["T","x2","ierr","herr"])
        self._SATPdlloutput_tuple = namedtuple('SATPdlloutput',["T","Dl","Dv","x","y","ierr","herr"])
        self._SATSPLNdlloutput_tuple = namedtuple('SATSPLNdlloutput',["ierr","herr"])
        self._SATSdlloutput_tuple = namedtuple('SATSdlloutput',["nroot","k1","T1","P1","D1","k2","T2","P2","D2","k3","T3","P3","D3","ierr","herr"])
        self._SATTESTdlloutput_tuple = namedtuple('SATTESTdlloutput',["P","x2","ierr","herr"])
        self._SATTPdlloutput_tuple = namedtuple('SATTPdlloutput',["T","P","D","Dl","Dv","x","y","q","ierr","herr"])
        self._SATTdlloutput_tuple = namedtuple('SATTdlloutput',["P","Dl","Dv","x","y","ierr","herr"])
        self._SETAGAdlloutput_tuple = namedtuple('SETAGAdlloutput',["ierr","herr"])
        self._SETKTVdlloutput_tuple = namedtuple('SETKTVdlloutput',["ierr","herr"])
        self._SETMIXTUREdlloutput_tuple = namedtuple('SETMIXTUREdlloutput',["z","ierr"])
        self._SETMIXdlloutput_tuple = namedtuple('SETMIXdlloutput',["ncc","hFiles","z","ierr","herr"])
        self._SETMODdlloutput_tuple = namedtuple('SETMODdlloutput',["ierr","herr"])
        self._SETREFdlloutput_tuple = namedtuple('SETREFdlloutput',["ierr","herr"])
        self._SETUPdlloutput_tuple = namedtuple('SETUPdlloutput',["ierr","herr"])
        self._SPLNROOTdlloutput_tuple = namedtuple('SPLNROOTdlloutput',["a","ierr","herr"])
        self._SPLNVALdlloutput_tuple = namedtuple('SPLNVALdlloutput',["f","ierr","herr"])
        self._STNdlloutput_tuple = namedtuple('STNdlloutput',["sigma","ierr","herr"])
        self._SUBLPdlloutput_tuple = namedtuple('SUBLPdlloutput',["T","ierr","herr"])
        self._SUBLTdlloutput_tuple = namedtuple('SUBLTdlloutput',["P","ierr","herr"])
        self._SURFTdlloutput_tuple = namedtuple('SURFTdlloutput',["sigma","ierr","herr"])
        self._SURTENdlloutput_tuple = namedtuple('SURTENdlloutput',["sigma","ierr","herr"])
        self._TDFLSHdlloutput_tuple = namedtuple('TDFLSHdlloutput',["P","Dl","Dv","x","y","q","e","h","s","Cv","Cp","w","ierr","herr"])
        self._TEFL1dlloutput_tuple = namedtuple('TEFL1dlloutput',["D","ierr","herr"])
        self._TEFLSHdlloutput_tuple = namedtuple('TEFLSHdlloutput',["P","D","Dl","Dv","x","y","q","h","s","Cv","Cp","w","ierr","herr"])
        self._THERM0dlloutput_tuple = namedtuple('THERM0dlloutput',["P0","e0","h0","s0","Cv0","Cp00","w0","a0","g0"])
        self._THERM2dlloutput_tuple = namedtuple('THERM2dlloutput',["P","e","h","s","Cv","Cp","w","zz","hjt","a","g","xkappa","beta","dPdD","d2PdD2","dPdT","dDdT","dDdP","d2PdT2","d2PdTD","spare3","spare4"])
        self._THERM3dlloutput_tuple = namedtuple('THERM3dlloutput',["xkappa","beta","xisenk","xkt","betas","bs","xkkt","thrott","pi","spht"])
        self._THERMdlloutput_tuple = namedtuple('THERMdlloutput',["P","e","h","s","Cv","Cp","w","hjt"])
        self._THFL1dlloutput_tuple = namedtuple('THFL1dlloutput',["D","ierr","herr"])
        self._THFLSHdlloutput_tuple = namedtuple('THFLSHdlloutput',["P","D","Dl","Dv","x","y","q","e","s","Cv","Cp","w","ierr","herr"])
        self._TPFL2dlloutput_tuple = namedtuple('TPFL2dlloutput',["Dl","Dv","x","y","q","ierr","herr"])
        self._TPFLSHdlloutput_tuple = namedtuple('TPFLSHdlloutput',["D","Dl","Dv","x","y","q","e","h","s","Cv","Cp","w","ierr","herr"])
        self._TPRHOPRdlloutput_tuple = namedtuple('TPRHOPRdlloutput',["D1","D2"])
        self._TPRHOdlloutput_tuple = namedtuple('TPRHOdlloutput',["D","ierr","herr"])
        self._TQFLSHdlloutput_tuple = namedtuple('TQFLSHdlloutput',["P","D","Dl","Dv","x","y","e","h","s","Cv","Cp","w","ierr","herr"])
        self._TRNPRPdlloutput_tuple = namedtuple('TRNPRPdlloutput',["eta","tcx","ierr","herr"])
        self._TSATDdlloutput_tuple = namedtuple('TSATDdlloutput',["T","ierr","herr"])
        self._TSATPdlloutput_tuple = namedtuple('TSATPdlloutput',["T","ierr","herr"])
        self._TSFL1dlloutput_tuple = namedtuple('TSFL1dlloutput',["D","ierr","herr"])
        self._TSFLSHdlloutput_tuple = namedtuple('TSFLSHdlloutput',["P","D","Dl","Dv","x","y","q","e","h","Cv","Cp","w","ierr","herr"])
        self._VAPSPNDLdlloutput_tuple = namedtuple('VAPSPNDLdlloutput',["D","ierr","herr"])
        self._VIRBCD12dlloutput_tuple = namedtuple('VIRBCD12dlloutput',["B","C","D","E"])
        self._VIRBCDdlloutput_tuple = namedtuple('VIRBCDdlloutput',["B","C","D","E"])
        self._VIRTAUdlloutput_tuple = namedtuple('VIRTAUdlloutput',["BTau","CTau","DTau","ETau","ierr","herr"])
        self._XMASSdlloutput_tuple = namedtuple('XMASSdlloutput',["xkg","wmix"])
        self._XMOLEdlloutput_tuple = namedtuple('XMOLEdlloutput',["xmol","wmix"])

        self._ABFL1dll = self._getfcn(self.dll, 'ABFL1dll')
        self._ABFL2dll = self._getfcn(self.dll, 'ABFL2dll')
        self._ABFLASHdll = self._getfcn(self.dll, 'ABFLASHdll')
        self._ABFLSHdll = self._getfcn(self.dll, 'ABFLSHdll')
        self._AGdll = self._getfcn(self.dll, 'AGdll')
        self._ALLPROPS0dll = self._getfcn(self.dll, 'ALLPROPS0dll')
        self._ALLPROPS1dll = self._getfcn(self.dll, 'ALLPROPS1dll')
        self._ALLPROPS20dll = self._getfcn(self.dll, 'ALLPROPS20dll')
        self._ALLPROPSdll = self._getfcn(self.dll, 'ALLPROPSdll')
        self._B12dll = self._getfcn(self.dll, 'B12dll')
        self._BLCRVdll = self._getfcn(self.dll, 'BLCRVdll')
        self._CCRITdll = self._getfcn(self.dll, 'CCRITdll')
        self._CHEMPOTdll = self._getfcn(self.dll, 'CHEMPOTdll')
        self._CP0dll = self._getfcn(self.dll, 'CP0dll')
        self._CRITPdll = self._getfcn(self.dll, 'CRITPdll')
        self._CRTPNTdll = self._getfcn(self.dll, 'CRTPNTdll')
        self._CSATKdll = self._getfcn(self.dll, 'CSATKdll')
        self._CSTARdll = self._getfcn(self.dll, 'CSTARdll')
        self._CV2PKdll = self._getfcn(self.dll, 'CV2PKdll')
        self._CVCPKdll = self._getfcn(self.dll, 'CVCPKdll')
        self._CVCPdll = self._getfcn(self.dll, 'CVCPdll')
        self._DBDTdll = self._getfcn(self.dll, 'DBDTdll')
        self._DBFL1dll = self._getfcn(self.dll, 'DBFL1dll')
        self._DBFL2dll = self._getfcn(self.dll, 'DBFL2dll')
        self._DDDPdll = self._getfcn(self.dll, 'DDDPdll')
        self._DDDTdll = self._getfcn(self.dll, 'DDDTdll')
        self._DEFL1dll = self._getfcn(self.dll, 'DEFL1dll')
        self._DEFLSHdll = self._getfcn(self.dll, 'DEFLSHdll')
        self._DERVPVTdll = self._getfcn(self.dll, 'DERVPVTdll')
        self._DHD1dll = self._getfcn(self.dll, 'DHD1dll')
        self._DHFL1dll = self._getfcn(self.dll, 'DHFL1dll')
        self._DHFLSHdll = self._getfcn(self.dll, 'DHFLSHdll')
        self._DIELECdll = self._getfcn(self.dll, 'DIELECdll')
        self._DLSATKdll = self._getfcn(self.dll, 'DLSATKdll')
        self._DPDD2dll = self._getfcn(self.dll, 'DPDD2dll')
        self._DPDDdll = self._getfcn(self.dll, 'DPDDdll')
        self._DPDTdll = self._getfcn(self.dll, 'DPDTdll')
        self._DPTSATKdll = self._getfcn(self.dll, 'DPTSATKdll')
        self._DQFL2dll = self._getfcn(self.dll, 'DQFL2dll')
        self._DSD1dll = self._getfcn(self.dll, 'DSD1dll')
        self._DSFL1dll = self._getfcn(self.dll, 'DSFL1dll')
        self._DSFLSHdll = self._getfcn(self.dll, 'DSFLSHdll')
        self._DVSATKdll = self._getfcn(self.dll, 'DVSATKdll')
        self._ENTHALdll = self._getfcn(self.dll, 'ENTHALdll')
        self._ENTROdll = self._getfcn(self.dll, 'ENTROdll')
        self._ERRMSGdll = self._getfcn(self.dll, 'ERRMSGdll')
        self._ESFLSHdll = self._getfcn(self.dll, 'ESFLSHdll')
        self._EXCESSdll = self._getfcn(self.dll, 'EXCESSdll')
        self._FGCTY2dll = self._getfcn(self.dll, 'FGCTY2dll')
        self._FGCTYdll = self._getfcn(self.dll, 'FGCTYdll')
        self._FLAGSdll = self._getfcn(self.dll, 'FLAGSdll')
        self._FPVdll = self._getfcn(self.dll, 'FPVdll')
        self._FUGCOFdll = self._getfcn(self.dll, 'FUGCOFdll')
        self._GERG04dll = self._getfcn(self.dll, 'GERG04dll')
        self._GERG08dll = self._getfcn(self.dll, 'GERG08dll')
        self._GETENUMdll = self._getfcn(self.dll, 'GETENUMdll')
        self._GETFIJdll = self._getfcn(self.dll, 'GETFIJdll')
        self._GETKTVdll = self._getfcn(self.dll, 'GETKTVdll')
        self._GETMODdll = self._getfcn(self.dll, 'GETMODdll')
        self._GETREFDIRdll = self._getfcn(self.dll, 'GETREFDIRdll')
        self._GIBBSdll = self._getfcn(self.dll, 'GIBBSdll')
        self._HEATFRMdll = self._getfcn(self.dll, 'HEATFRMdll')
        self._HEATdll = self._getfcn(self.dll, 'HEATdll')
        self._HMXORDERdll = self._getfcn(self.dll, 'HMXORDERdll')
        self._HSFL1dll = self._getfcn(self.dll, 'HSFL1dll')
        self._HSFLSHdll = self._getfcn(self.dll, 'HSFLSHdll')
        self._IDCRVdll = self._getfcn(self.dll, 'IDCRVdll')
        self._INFOdll = self._getfcn(self.dll, 'INFOdll')
        self._JICRVdll = self._getfcn(self.dll, 'JICRVdll')
        self._JTCRVdll = self._getfcn(self.dll, 'JTCRVdll')
        self._LIMITKdll = self._getfcn(self.dll, 'LIMITKdll')
        self._LIMITSdll = self._getfcn(self.dll, 'LIMITSdll')
        self._LIMITXdll = self._getfcn(self.dll, 'LIMITXdll')
        self._LIQSPNDLdll = self._getfcn(self.dll, 'LIQSPNDLdll')
        self._MASSFLUXdll = self._getfcn(self.dll, 'MASSFLUXdll')
        self._MAXPdll = self._getfcn(self.dll, 'MAXPdll')
        self._MAXTdll = self._getfcn(self.dll, 'MAXTdll')
        self._MELTKdll = self._getfcn(self.dll, 'MELTKdll')
        self._MELTPdll = self._getfcn(self.dll, 'MELTPdll')
        self._MELTTdll = self._getfcn(self.dll, 'MELTTdll')
        self._MLTH2Odll = self._getfcn(self.dll, 'MLTH2Odll')
        self._NAMEdll = self._getfcn(self.dll, 'NAMEdll')
        self._PASSCMNdll = self._getfcn(self.dll, 'PASSCMNdll')
        self._PDFL1dll = self._getfcn(self.dll, 'PDFL1dll')
        self._PDFLSHdll = self._getfcn(self.dll, 'PDFLSHdll')
        self._PEFL1dll = self._getfcn(self.dll, 'PEFL1dll')
        self._PEFLSHdll = self._getfcn(self.dll, 'PEFLSHdll')
        self._PHFL1dll = self._getfcn(self.dll, 'PHFL1dll')
        self._PHFLSHdll = self._getfcn(self.dll, 'PHFLSHdll')
        self._PHI0dll = self._getfcn(self.dll, 'PHI0dll')
        self._PHIDERVdll = self._getfcn(self.dll, 'PHIDERVdll')
        self._PHIHMXdll = self._getfcn(self.dll, 'PHIHMXdll')
        self._PHIKdll = self._getfcn(self.dll, 'PHIKdll')
        self._PHIMIXdll = self._getfcn(self.dll, 'PHIMIXdll')
        self._PHIXdll = self._getfcn(self.dll, 'PHIXdll')
        self._PQFLSHdll = self._getfcn(self.dll, 'PQFLSHdll')
        self._PREOSdll = self._getfcn(self.dll, 'PREOSdll')
        self._PRESSdll = self._getfcn(self.dll, 'PRESSdll')
        self._PSATKdll = self._getfcn(self.dll, 'PSATKdll')
        self._PSFL1dll = self._getfcn(self.dll, 'PSFL1dll')
        self._PSFLSHdll = self._getfcn(self.dll, 'PSFLSHdll')
        self._PUREFLDdll = self._getfcn(self.dll, 'PUREFLDdll')
        self._QMASSdll = self._getfcn(self.dll, 'QMASSdll')
        self._QMOLEdll = self._getfcn(self.dll, 'QMOLEdll')
        self._RDXHMXdll = self._getfcn(self.dll, 'RDXHMXdll')
        self._REDXdll = self._getfcn(self.dll, 'REDXdll')
        self._REFPROP1dll = self._getfcn(self.dll, 'REFPROP1dll')
        self._REFPROP2dll = self._getfcn(self.dll, 'REFPROP2dll')
        self._REFPROPdll = self._getfcn(self.dll, 'REFPROPdll')
        self._RESIDUALdll = self._getfcn(self.dll, 'RESIDUALdll')
        self._RIEMdll = self._getfcn(self.dll, 'RIEMdll')
        self._RMIX2dll = self._getfcn(self.dll, 'RMIX2dll')
        self._RPVersion = self._getfcn(self.dll, 'RPVersion')
        self._SATDdll = self._getfcn(self.dll, 'SATDdll')
        self._SATESTdll = self._getfcn(self.dll, 'SATESTdll')
        self._SATEdll = self._getfcn(self.dll, 'SATEdll')
        self._SATGUESSdll = self._getfcn(self.dll, 'SATGUESSdll')
        self._SATGVdll = self._getfcn(self.dll, 'SATGVdll')
        self._SATHdll = self._getfcn(self.dll, 'SATHdll')
        self._SATPESTdll = self._getfcn(self.dll, 'SATPESTdll')
        self._SATPdll = self._getfcn(self.dll, 'SATPdll')
        self._SATSPLNdll = self._getfcn(self.dll, 'SATSPLNdll')
        self._SATSdll = self._getfcn(self.dll, 'SATSdll')
        self._SATTESTdll = self._getfcn(self.dll, 'SATTESTdll')
        self._SATTPdll = self._getfcn(self.dll, 'SATTPdll')
        self._SATTdll = self._getfcn(self.dll, 'SATTdll')
        self._SETAGAdll = self._getfcn(self.dll, 'SETAGAdll')
        self._SETFLUIDSdll = self._getfcn(self.dll, 'SETFLUIDSdll')
        self._SETKTVdll = self._getfcn(self.dll, 'SETKTVdll')
        self._SETMIXTUREdll = self._getfcn(self.dll, 'SETMIXTUREdll')
        self._SETMIXdll = self._getfcn(self.dll, 'SETMIXdll')
        self._SETMODdll = self._getfcn(self.dll, 'SETMODdll')
        self._SETNCdll = self._getfcn(self.dll, 'SETNCdll')
        self._SETPATHdll = self._getfcn(self.dll, 'SETPATHdll')
        self._SETREFDIRdll = self._getfcn(self.dll, 'SETREFDIRdll')
        self._SETREFdll = self._getfcn(self.dll, 'SETREFdll')
        self._SETUPdll = self._getfcn(self.dll, 'SETUPdll')
        self._SPLNROOTdll = self._getfcn(self.dll, 'SPLNROOTdll')
        self._SPLNVALdll = self._getfcn(self.dll, 'SPLNVALdll')
        self._STNdll = self._getfcn(self.dll, 'STNdll')
        self._SUBLPdll = self._getfcn(self.dll, 'SUBLPdll')
        self._SUBLTdll = self._getfcn(self.dll, 'SUBLTdll')
        self._SURFTdll = self._getfcn(self.dll, 'SURFTdll')
        self._SURTENdll = self._getfcn(self.dll, 'SURTENdll')
        self._TDFLSHdll = self._getfcn(self.dll, 'TDFLSHdll')
        self._TEFL1dll = self._getfcn(self.dll, 'TEFL1dll')
        self._TEFLSHdll = self._getfcn(self.dll, 'TEFLSHdll')
        self._THERM0dll = self._getfcn(self.dll, 'THERM0dll')
        self._THERM2dll = self._getfcn(self.dll, 'THERM2dll')
        self._THERM3dll = self._getfcn(self.dll, 'THERM3dll')
        self._THERMdll = self._getfcn(self.dll, 'THERMdll')
        self._THFL1dll = self._getfcn(self.dll, 'THFL1dll')
        self._THFLSHdll = self._getfcn(self.dll, 'THFLSHdll')
        self._TPFL2dll = self._getfcn(self.dll, 'TPFL2dll')
        self._TPFLSHdll = self._getfcn(self.dll, 'TPFLSHdll')
        self._TPRHOPRdll = self._getfcn(self.dll, 'TPRHOPRdll')
        self._TPRHOdll = self._getfcn(self.dll, 'TPRHOdll')
        self._TQFLSHdll = self._getfcn(self.dll, 'TQFLSHdll')
        self._TRNPRPdll = self._getfcn(self.dll, 'TRNPRPdll')
        self._TSATDdll = self._getfcn(self.dll, 'TSATDdll')
        self._TSATPdll = self._getfcn(self.dll, 'TSATPdll')
        self._TSFL1dll = self._getfcn(self.dll, 'TSFL1dll')
        self._TSFLSHdll = self._getfcn(self.dll, 'TSFLSHdll')
        self._UNSETAGAdll = self._getfcn(self.dll, 'UNSETAGAdll')
        self._VAPSPNDLdll = self._getfcn(self.dll, 'VAPSPNDLdll')
        self._VIRBAdll = self._getfcn(self.dll, 'VIRBAdll')
        self._VIRBCD12dll = self._getfcn(self.dll, 'VIRBCD12dll')
        self._VIRBCDdll = self._getfcn(self.dll, 'VIRBCDdll')
        self._VIRBdll = self._getfcn(self.dll, 'VIRBdll')
        self._VIRCAdll = self._getfcn(self.dll, 'VIRCAdll')
        self._VIRCdll = self._getfcn(self.dll, 'VIRCdll')
        self._VIRTAUdll = self._getfcn(self.dll, 'VIRTAUdll')
        self._WMOLIdll = self._getfcn(self.dll, 'WMOLIdll')
        self._WMOLdll = self._getfcn(self.dll, 'WMOLdll')
        self._XMASSdll = self._getfcn(self.dll, 'XMASSdll')
        self._XMOLEdll = self._getfcn(self.dll, 'XMOLEdll')

        try:
            self.DEFAULT = self.GETENUMdll(0, 'DEFAULT').iEnum
            self.MOLAR_SI = self.GETENUMdll(0, 'MOLAR SI').iEnum
            self.MASS_SI = self.GETENUMdll(0, 'MASS SI').iEnum
            self.SI_WITH_C = self.GETENUMdll(0, 'SI WITH C').iEnum
            self.MOLAR_BASE_SI = self.GETENUMdll(0, 'MOLAR BASE SI').iEnum
            self.MASS_BASE_SI = self.GETENUMdll(0, 'MASS BASE SI').iEnum
            self.ENGLISH = self.GETENUMdll(0, 'ENGLISH').iEnum
            self.MOLAR_ENGLISH = self.GETENUMdll(0, 'MOLAR ENGLISH').iEnum
            self.MKS = self.GETENUMdll(0, 'MKS').iEnum
            self.CGS = self.GETENUMdll(0, 'CGS').iEnum
            self.MIXED = self.GETENUMdll(0, 'MIXED').iEnum
            self.MEUNITS = self.GETENUMdll(0, 'MEUNITS').iEnum
        except:
            pass

    def ABFL1dll(self,a,b,z,kph,ab,Dmin,Dmax):
        """
        T,P,D,ierr,herr = ABFL1dll(a,b,z,kph,ab,Dmin,Dmax)
        """
        a = ct.c_double(a)
        b = ct.c_double(b)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        ab = ct.create_string_buffer(ab.encode('utf-8'),2)
        Dmin = ct.c_double(Dmin)
        Dmax = ct.c_double(Dmax)
        T = ct.c_double()
        P = ct.c_double()
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ABFL1dll is None: raise ValueError("The function ABFL1dll could not be loaded from the shared library.") 
        self._ABFL1dll(ct.byref(a),ct.byref(b),z,ct.byref(kph),ab,ct.byref(Dmin),ct.byref(Dmax),ct.byref(T),ct.byref(P),ct.byref(D),ct.byref(ierr),herr,2,255)

        return self._ABFL1dlloutput_tuple(T.value,P.value,D.value,ierr.value,trim(herr.raw))

    def ABFL2dll(self,a,b,z,kq,ksat,ab):
        """
        Tbub,Tdew,Pbub,Pdew,Dlbub,Dvdew,ybub,xdew,T,P,Dl,Dv,x,y,q,ierr,herr = ABFL2dll(a,b,z,kq,ksat,ab)
        """
        a = ct.c_double(a)
        b = ct.c_double(b)
        z = (len(z)*ct.c_double)(*z)
        kq = ct.c_int(kq)
        ksat = ct.c_int(ksat)
        ab = ct.create_string_buffer(ab.encode('utf-8'),2)
        Tbub = ct.c_double()
        Tdew = ct.c_double()
        Pbub = ct.c_double()
        Pdew = ct.c_double()
        Dlbub = ct.c_double()
        Dvdew = ct.c_double()
        ybub = (20*ct.c_double)()
        xdew = (20*ct.c_double)()
        T = ct.c_double()
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ABFL2dll is None: raise ValueError("The function ABFL2dll could not be loaded from the shared library.") 
        self._ABFL2dll(ct.byref(a),ct.byref(b),z,ct.byref(kq),ct.byref(ksat),ab,ct.byref(Tbub),ct.byref(Tdew),ct.byref(Pbub),ct.byref(Pdew),ct.byref(Dlbub),ct.byref(Dvdew),ybub,xdew,ct.byref(T),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(ierr),herr,2,255)

        return self._ABFL2dlloutput_tuple(Tbub.value,Tdew.value,Pbub.value,Pdew.value,Dlbub.value,Dvdew.value,to_double_array(ybub),to_double_array(xdew),T.value,P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,ierr.value,trim(herr.raw))

    def ABFLASHdll(self,ab,a,b,z,iFlag):
        """
        T,P,D,Dl,Dv,x,y,q,e,h,s,Cv,Cp,w,ierr,herr = ABFLASHdll(ab,a,b,z,iFlag)
        """
        ab = ct.create_string_buffer(ab.encode('utf-8'),2)
        a = ct.c_double(a)
        b = ct.c_double(b)
        z = (len(z)*ct.c_double)(*z)
        iFlag = ct.c_int(iFlag)
        T = ct.c_double()
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ABFLASHdll is None: raise ValueError("The function ABFLASHdll could not be loaded from the shared library.") 
        self._ABFLASHdll(ab,ct.byref(a),ct.byref(b),z,ct.byref(iFlag),ct.byref(T),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,2,255)

        return self._ABFLASHdlloutput_tuple(T.value,P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def ABFLSHdll(self,ab,a,b,z,iFlag):
        """
        T,P,D,Dl,Dv,x,y,q,e,h,s,Cv,Cp,w,ierr,herr = ABFLSHdll(ab,a,b,z,iFlag)
        """
        ab = ct.create_string_buffer(ab.encode('utf-8'),2)
        a = ct.c_double(a)
        b = ct.c_double(b)
        z = (len(z)*ct.c_double)(*z)
        iFlag = ct.c_int(iFlag)
        T = ct.c_double()
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ABFLSHdll is None: raise ValueError("The function ABFLSHdll could not be loaded from the shared library.") 
        self._ABFLSHdll(ab,ct.byref(a),ct.byref(b),z,ct.byref(iFlag),ct.byref(T),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,2,255)

        return self._ABFLSHdlloutput_tuple(T.value,P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def AGdll(self,T,D,z):
        """
        a,g = AGdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        a = ct.c_double()
        g = ct.c_double()

        if self._AGdll is None: raise ValueError("The function AGdll could not be loaded from the shared library.") 
        self._AGdll(ct.byref(T),ct.byref(D),z,ct.byref(a),ct.byref(g))

        return self._AGdlloutput_tuple(a.value,g.value)

    def ALLPROPS0dll(self,iIn,iOut,iFlag,T,D,z):
        """
        Output,ierr,herr = ALLPROPS0dll(iIn,iOut,iFlag,T,D,z)
        """
        iIn = ct.c_int(iIn)
        iOut = (len(iOut)*ct.c_int)(*iOut)
        iFlag = ct.c_int(iFlag)
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        Output = (200*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ALLPROPS0dll is None: raise ValueError("The function ALLPROPS0dll could not be loaded from the shared library.") 
        self._ALLPROPS0dll(ct.byref(iIn),iOut,ct.byref(iFlag),ct.byref(T),ct.byref(D),z,Output,ct.byref(ierr),herr,255)

        return self._ALLPROPS0dlloutput_tuple(to_double_array(Output),ierr.value,trim(herr.raw))

    def ALLPROPS1dll(self,hOut,iUnits,T,D,z):
        """
        c,ierr,herr = ALLPROPS1dll(hOut,iUnits,T,D,z)
        """
        hOut = ct.create_string_buffer(hOut.encode('utf-8'),255)
        iUnits = ct.c_int(iUnits)
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        c = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ALLPROPS1dll is None: raise ValueError("The function ALLPROPS1dll could not be loaded from the shared library.") 
        self._ALLPROPS1dll(hOut,ct.byref(iUnits),ct.byref(T),ct.byref(D),z,ct.byref(c),ct.byref(ierr),herr,255,255)

        return self._ALLPROPS1dlloutput_tuple(c.value,ierr.value,trim(herr.raw))

    def ALLPROPS20dll(self,hOut,iUnits,iMass,iFlag,T,D,z):
        """
        Output,hUnitsArray,iUCodeArray,ierr,herr = ALLPROPS20dll(hOut,iUnits,iMass,iFlag,T,D,z)
        """
        hOut = ct.create_string_buffer(hOut.encode('utf-8'),255)
        iUnits = ct.c_int(iUnits)
        iMass = ct.c_int(iMass)
        iFlag = ct.c_int(iFlag)
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        Output = (20*ct.c_double)()
        hUnitsArray = ct.create_string_buffer(1000)
        iUCodeArray = (20*ct.c_int)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ALLPROPS20dll is None: raise ValueError("The function ALLPROPS20dll could not be loaded from the shared library.") 
        self._ALLPROPS20dll(hOut,ct.byref(iUnits),ct.byref(iMass),ct.byref(iFlag),ct.byref(T),ct.byref(D),z,Output,hUnitsArray,iUCodeArray,ct.byref(ierr),herr,255,1000,255)

        return self._ALLPROPS20dlloutput_tuple(to_double_array(Output),trim(hUnitsArray.raw),to_int_array(iUCodeArray),ierr.value,trim(herr.raw))

    def ALLPROPSdll(self,hOut,iUnits,iMass,iFlag,T,D,z):
        """
        Output,hUnitsArray,iUCodeArray,ierr,herr = ALLPROPSdll(hOut,iUnits,iMass,iFlag,T,D,z)
        """
        hOut = ct.create_string_buffer(hOut.encode('utf-8'),10000)
        iUnits = ct.c_int(iUnits)
        iMass = ct.c_int(iMass)
        iFlag = ct.c_int(iFlag)
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        Output = (200*ct.c_double)()
        hUnitsArray = ct.create_string_buffer(10000)
        iUCodeArray = (200*ct.c_int)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ALLPROPSdll is None: raise ValueError("The function ALLPROPSdll could not be loaded from the shared library.") 
        self._ALLPROPSdll(hOut,ct.byref(iUnits),ct.byref(iMass),ct.byref(iFlag),ct.byref(T),ct.byref(D),z,Output,hUnitsArray,iUCodeArray,ct.byref(ierr),herr,10000,10000,255)

        return self._ALLPROPSdlloutput_tuple(to_double_array(Output),trim(hUnitsArray.raw),to_int_array(iUCodeArray),ierr.value,trim(herr.raw))

    def B12dll(self,T,z):
        """
        B = B12dll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        B = ct.c_double()

        if self._B12dll is None: raise ValueError("The function B12dll could not be loaded from the shared library.") 
        self._B12dll(ct.byref(T),z,ct.byref(B))

        return B.value

    def BLCRVdll(self,D,z,T):
        """
        T,ierr,herr = BLCRVdll(D,z,T)
        """
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double(T)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._BLCRVdll is None: raise ValueError("The function BLCRVdll could not be loaded from the shared library.") 
        self._BLCRVdll(ct.byref(D),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._BLCRVdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def CCRITdll(self,T,P,v,z):
        """
        Cs,Ts,Ds,Ps,ws,ierr,herr = CCRITdll(T,P,v,z)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        v = ct.c_double(v)
        z = (len(z)*ct.c_double)(*z)
        Cs = ct.c_double()
        Ts = ct.c_double()
        Ds = ct.c_double()
        Ps = ct.c_double()
        ws = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._CCRITdll is None: raise ValueError("The function CCRITdll could not be loaded from the shared library.") 
        self._CCRITdll(ct.byref(T),ct.byref(P),ct.byref(v),z,ct.byref(Cs),ct.byref(Ts),ct.byref(Ds),ct.byref(Ps),ct.byref(ws),ct.byref(ierr),herr,255)

        return self._CCRITdlloutput_tuple(Cs.value,Ts.value,Ds.value,Ps.value,ws.value,ierr.value,trim(herr.raw))

    def CHEMPOTdll(self,T,D,z):
        """
        u,ierr,herr = CHEMPOTdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        u = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._CHEMPOTdll is None: raise ValueError("The function CHEMPOTdll could not be loaded from the shared library.") 
        self._CHEMPOTdll(ct.byref(T),ct.byref(D),z,u,ct.byref(ierr),herr,255)

        return self._CHEMPOTdlloutput_tuple(to_double_array(u),ierr.value,trim(herr.raw))

    def CP0dll(self,T,z):
        """
        Cp = CP0dll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        Cp = ct.c_double()

        if self._CP0dll is None: raise ValueError("The function CP0dll could not be loaded from the shared library.") 
        self._CP0dll(ct.byref(T),z,ct.byref(Cp))

        return Cp.value

    def CRITPdll(self,z):
        """
        Tc,Pc,Dc,ierr,herr = CRITPdll(z)
        """
        z = (len(z)*ct.c_double)(*z)
        Tc = ct.c_double()
        Pc = ct.c_double()
        Dc = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._CRITPdll is None: raise ValueError("The function CRITPdll could not be loaded from the shared library.") 
        self._CRITPdll(z,ct.byref(Tc),ct.byref(Pc),ct.byref(Dc),ct.byref(ierr),herr,255)

        return self._CRITPdlloutput_tuple(Tc.value,Pc.value,Dc.value,ierr.value,trim(herr.raw))

    def CRTPNTdll(self,z,Tc,Pc):
        """
        Tc,Pc,Dc,ierr,herr = CRTPNTdll(z,Tc,Pc)
        """
        z = (len(z)*ct.c_double)(*z)
        Tc = ct.c_double(Tc)
        Pc = ct.c_double(Pc)
        Dc = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._CRTPNTdll is None: raise ValueError("The function CRTPNTdll could not be loaded from the shared library.") 
        self._CRTPNTdll(z,ct.byref(Tc),ct.byref(Pc),ct.byref(Dc),ct.byref(ierr),herr,255)

        return self._CRTPNTdlloutput_tuple(Tc.value,Pc.value,Dc.value,ierr.value,trim(herr.raw))

    def CSATKdll(self,icomp,T,kph):
        """
        P,D,Csat,ierr,herr = CSATKdll(icomp,T,kph)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        kph = ct.c_int(kph)
        P = ct.c_double()
        D = ct.c_double()
        Csat = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._CSATKdll is None: raise ValueError("The function CSATKdll could not be loaded from the shared library.") 
        self._CSATKdll(ct.byref(icomp),ct.byref(T),ct.byref(kph),ct.byref(P),ct.byref(D),ct.byref(Csat),ct.byref(ierr),herr,255)

        return self._CSATKdlloutput_tuple(P.value,D.value,Csat.value,ierr.value,trim(herr.raw))

    def CSTARdll(self,T,P,v,z):
        """
        Cs,Ts,Ds,Ps,ws,ierr,herr = CSTARdll(T,P,v,z)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        v = ct.c_double(v)
        z = (len(z)*ct.c_double)(*z)
        Cs = ct.c_double()
        Ts = ct.c_double()
        Ds = ct.c_double()
        Ps = ct.c_double()
        ws = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._CSTARdll is None: raise ValueError("The function CSTARdll could not be loaded from the shared library.") 
        self._CSTARdll(ct.byref(T),ct.byref(P),ct.byref(v),z,ct.byref(Cs),ct.byref(Ts),ct.byref(Ds),ct.byref(Ps),ct.byref(ws),ct.byref(ierr),herr,255)

        return self._CSTARdlloutput_tuple(Cs.value,Ts.value,Ds.value,Ps.value,ws.value,ierr.value,trim(herr.raw))

    def CV2PKdll(self,icomp,T,D):
        """
        Cv2p,Csat,ierr,herr = CV2PKdll(icomp,T,D)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        D = ct.c_double(D)
        Cv2p = ct.c_double()
        Csat = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._CV2PKdll is None: raise ValueError("The function CV2PKdll could not be loaded from the shared library.") 
        self._CV2PKdll(ct.byref(icomp),ct.byref(T),ct.byref(D),ct.byref(Cv2p),ct.byref(Csat),ct.byref(ierr),herr,255)

        return self._CV2PKdlloutput_tuple(Cv2p.value,Csat.value,ierr.value,trim(herr.raw))

    def CVCPKdll(self,icomp,T,D):
        """
        Cv,Cp = CVCPKdll(icomp,T,D)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        D = ct.c_double(D)
        Cv = ct.c_double()
        Cp = ct.c_double()

        if self._CVCPKdll is None: raise ValueError("The function CVCPKdll could not be loaded from the shared library.") 
        self._CVCPKdll(ct.byref(icomp),ct.byref(T),ct.byref(D),ct.byref(Cv),ct.byref(Cp))

        return self._CVCPKdlloutput_tuple(Cv.value,Cp.value)

    def CVCPdll(self,T,D,z):
        """
        Cv,Cp = CVCPdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        Cv = ct.c_double()
        Cp = ct.c_double()

        if self._CVCPdll is None: raise ValueError("The function CVCPdll could not be loaded from the shared library.") 
        self._CVCPdll(ct.byref(T),ct.byref(D),z,ct.byref(Cv),ct.byref(Cp))

        return self._CVCPdlloutput_tuple(Cv.value,Cp.value)

    def DBDTdll(self,T,z):
        """
        dBT = DBDTdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        dBT = ct.c_double()

        if self._DBDTdll is None: raise ValueError("The function DBDTdll could not be loaded from the shared library.") 
        self._DBDTdll(ct.byref(T),z,ct.byref(dBT))

        return dBT.value

    def DBFL1dll(self,D,b,z,hab):
        """
        T,P,ierr,herr = DBFL1dll(D,b,z,hab)
        """
        D = ct.c_double(D)
        b = ct.c_double(b)
        z = (len(z)*ct.c_double)(*z)
        hab = ct.create_string_buffer(hab.encode('utf-8'),2)
        T = ct.c_double()
        P = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DBFL1dll is None: raise ValueError("The function DBFL1dll could not be loaded from the shared library.") 
        self._DBFL1dll(ct.byref(D),ct.byref(b),z,hab,ct.byref(T),ct.byref(P),ct.byref(ierr),herr,2,255)

        return self._DBFL1dlloutput_tuple(T.value,P.value,ierr.value,trim(herr.raw))

    def DBFL2dll(self,D,b,z,kq,ab):
        """
        T,P,Dl,Dv,x,y,q,ierr,herr = DBFL2dll(D,b,z,kq,ab)
        """
        D = ct.c_double(D)
        b = ct.c_double(b)
        z = (len(z)*ct.c_double)(*z)
        kq = ct.c_int(kq)
        ab = ct.create_string_buffer(ab.encode('utf-8'),2)
        T = ct.c_double()
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DBFL2dll is None: raise ValueError("The function DBFL2dll could not be loaded from the shared library.") 
        self._DBFL2dll(ct.byref(D),ct.byref(b),z,ct.byref(kq),ab,ct.byref(T),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(ierr),herr,2,255)

        return self._DBFL2dlloutput_tuple(T.value,P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,ierr.value,trim(herr.raw))

    def DDDPdll(self,T,D,z):
        """
        dDdP = DDDPdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dDdP = ct.c_double()

        if self._DDDPdll is None: raise ValueError("The function DDDPdll could not be loaded from the shared library.") 
        self._DDDPdll(ct.byref(T),ct.byref(D),z,ct.byref(dDdP))

        return dDdP.value

    def DDDTdll(self,T,D,z):
        """
        dDdT = DDDTdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dDdT = ct.c_double()

        if self._DDDTdll is None: raise ValueError("The function DDDTdll could not be loaded from the shared library.") 
        self._DDDTdll(ct.byref(T),ct.byref(D),z,ct.byref(dDdT))

        return dDdT.value

    def DEFL1dll(self,D,e,z):
        """
        T,ierr,herr = DEFL1dll(D,e,z)
        """
        D = ct.c_double(D)
        e = ct.c_double(e)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DEFL1dll is None: raise ValueError("The function DEFL1dll could not be loaded from the shared library.") 
        self._DEFL1dll(ct.byref(D),ct.byref(e),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._DEFL1dlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def DEFLSHdll(self,D,e,z):
        """
        T,P,Dl,Dv,x,y,q,h,s,Cv,Cp,w,ierr,herr = DEFLSHdll(D,e,z)
        """
        D = ct.c_double(D)
        e = ct.c_double(e)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DEFLSHdll is None: raise ValueError("The function DEFLSHdll could not be loaded from the shared library.") 
        self._DEFLSHdll(ct.byref(D),ct.byref(e),z,ct.byref(T),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._DEFLSHdlloutput_tuple(T.value,P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def DERVPVTdll(self,T,D,z):
        """
        dPdD,dPdT,d2PdD2,d2PdT2,d2PdTD,dDdP,dDdT,d2DdP2,d2DdT2,d2DdPT,dTdP,dTdD,d2TdP2,d2TdD2,d2TdPD = DERVPVTdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dPdD = ct.c_double()
        dPdT = ct.c_double()
        d2PdD2 = ct.c_double()
        d2PdT2 = ct.c_double()
        d2PdTD = ct.c_double()
        dDdP = ct.c_double()
        dDdT = ct.c_double()
        d2DdP2 = ct.c_double()
        d2DdT2 = ct.c_double()
        d2DdPT = ct.c_double()
        dTdP = ct.c_double()
        dTdD = ct.c_double()
        d2TdP2 = ct.c_double()
        d2TdD2 = ct.c_double()
        d2TdPD = ct.c_double()

        if self._DERVPVTdll is None: raise ValueError("The function DERVPVTdll could not be loaded from the shared library.") 
        self._DERVPVTdll(ct.byref(T),ct.byref(D),z,ct.byref(dPdD),ct.byref(dPdT),ct.byref(d2PdD2),ct.byref(d2PdT2),ct.byref(d2PdTD),ct.byref(dDdP),ct.byref(dDdT),ct.byref(d2DdP2),ct.byref(d2DdT2),ct.byref(d2DdPT),ct.byref(dTdP),ct.byref(dTdD),ct.byref(d2TdP2),ct.byref(d2TdD2),ct.byref(d2TdPD))

        return self._DERVPVTdlloutput_tuple(dPdD.value,dPdT.value,d2PdD2.value,d2PdT2.value,d2PdTD.value,dDdP.value,dDdT.value,d2DdP2.value,d2DdT2.value,d2DdPT.value,dTdP.value,dTdD.value,d2TdP2.value,d2TdD2.value,d2TdPD.value)

    def DHD1dll(self,T,D,z):
        """
        dhdt_d,dhdt_p,dhdd_t,dhdd_p,dhdp_t,dhdp_d = DHD1dll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dhdt_d = ct.c_double()
        dhdt_p = ct.c_double()
        dhdd_t = ct.c_double()
        dhdd_p = ct.c_double()
        dhdp_t = ct.c_double()
        dhdp_d = ct.c_double()

        if self._DHD1dll is None: raise ValueError("The function DHD1dll could not be loaded from the shared library.") 
        self._DHD1dll(ct.byref(T),ct.byref(D),z,ct.byref(dhdt_d),ct.byref(dhdt_p),ct.byref(dhdd_t),ct.byref(dhdd_p),ct.byref(dhdp_t),ct.byref(dhdp_d))

        return self._DHD1dlloutput_tuple(dhdt_d.value,dhdt_p.value,dhdd_t.value,dhdd_p.value,dhdp_t.value,dhdp_d.value)

    def DHFL1dll(self,D,h,z):
        """
        T,ierr,herr = DHFL1dll(D,h,z)
        """
        D = ct.c_double(D)
        h = ct.c_double(h)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DHFL1dll is None: raise ValueError("The function DHFL1dll could not be loaded from the shared library.") 
        self._DHFL1dll(ct.byref(D),ct.byref(h),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._DHFL1dlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def DHFLSHdll(self,D,h,z):
        """
        T,P,Dl,Dv,x,y,q,e,s,Cv,Cp,w,ierr,herr = DHFLSHdll(D,h,z)
        """
        D = ct.c_double(D)
        h = ct.c_double(h)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DHFLSHdll is None: raise ValueError("The function DHFLSHdll could not be loaded from the shared library.") 
        self._DHFLSHdll(ct.byref(D),ct.byref(h),z,ct.byref(T),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._DHFLSHdlloutput_tuple(T.value,P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def DIELECdll(self,T,D,z):
        """
        de = DIELECdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        de = ct.c_double()

        if self._DIELECdll is None: raise ValueError("The function DIELECdll could not be loaded from the shared library.") 
        self._DIELECdll(ct.byref(T),ct.byref(D),z,ct.byref(de))

        return de.value

    def DLSATKdll(self,icomp,T):
        """
        D,ierr,herr = DLSATKdll(icomp,T)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DLSATKdll is None: raise ValueError("The function DLSATKdll could not be loaded from the shared library.") 
        self._DLSATKdll(ct.byref(icomp),ct.byref(T),ct.byref(D),ct.byref(ierr),herr,255)

        return self._DLSATKdlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def DPDD2dll(self,T,D,z):
        """
        d2PdD2 = DPDD2dll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        d2PdD2 = ct.c_double()

        if self._DPDD2dll is None: raise ValueError("The function DPDD2dll could not be loaded from the shared library.") 
        self._DPDD2dll(ct.byref(T),ct.byref(D),z,ct.byref(d2PdD2))

        return d2PdD2.value

    def DPDDdll(self,T,D,z):
        """
        dPdD = DPDDdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dPdD = ct.c_double()

        if self._DPDDdll is None: raise ValueError("The function DPDDdll could not be loaded from the shared library.") 
        self._DPDDdll(ct.byref(T),ct.byref(D),z,ct.byref(dPdD))

        return dPdD.value

    def DPDTdll(self,T,D,z):
        """
        dPdT = DPDTdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dPdT = ct.c_double()

        if self._DPDTdll is None: raise ValueError("The function DPDTdll could not be loaded from the shared library.") 
        self._DPDTdll(ct.byref(T),ct.byref(D),z,ct.byref(dPdT))

        return dPdT.value

    def DPTSATKdll(self,icomp,T,kph):
        """
        P,D,Csat,dPdT,ierr,herr = DPTSATKdll(icomp,T,kph)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        kph = ct.c_int(kph)
        P = ct.c_double()
        D = ct.c_double()
        Csat = ct.c_double()
        dPdT = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DPTSATKdll is None: raise ValueError("The function DPTSATKdll could not be loaded from the shared library.") 
        self._DPTSATKdll(ct.byref(icomp),ct.byref(T),ct.byref(kph),ct.byref(P),ct.byref(D),ct.byref(Csat),ct.byref(dPdT),ct.byref(ierr),herr,255)

        return self._DPTSATKdlloutput_tuple(P.value,D.value,Csat.value,dPdT.value,ierr.value,trim(herr.raw))

    def DQFL2dll(self,D,q,z,kq):
        """
        T,P,Dl,Dv,x,y,ierr,herr = DQFL2dll(D,q,z,kq)
        """
        D = ct.c_double(D)
        q = ct.c_double(q)
        z = (len(z)*ct.c_double)(*z)
        kq = ct.c_int(kq)
        T = ct.c_double()
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DQFL2dll is None: raise ValueError("The function DQFL2dll could not be loaded from the shared library.") 
        self._DQFL2dll(ct.byref(D),ct.byref(q),z,ct.byref(kq),ct.byref(T),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(ierr),herr,255)

        return self._DQFL2dlloutput_tuple(T.value,P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),ierr.value,trim(herr.raw))

    def DSD1dll(self,T,D,z):
        """
        dsdt_d,dsdt_p,dsdd_t,dsdd_p,dsdp_t,dsdp_d = DSD1dll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dsdt_d = ct.c_double()
        dsdt_p = ct.c_double()
        dsdd_t = ct.c_double()
        dsdd_p = ct.c_double()
        dsdp_t = ct.c_double()
        dsdp_d = ct.c_double()

        if self._DSD1dll is None: raise ValueError("The function DSD1dll could not be loaded from the shared library.") 
        self._DSD1dll(ct.byref(T),ct.byref(D),z,ct.byref(dsdt_d),ct.byref(dsdt_p),ct.byref(dsdd_t),ct.byref(dsdd_p),ct.byref(dsdp_t),ct.byref(dsdp_d))

        return self._DSD1dlloutput_tuple(dsdt_d.value,dsdt_p.value,dsdd_t.value,dsdd_p.value,dsdp_t.value,dsdp_d.value)

    def DSFL1dll(self,D,s,z):
        """
        T,ierr,herr = DSFL1dll(D,s,z)
        """
        D = ct.c_double(D)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DSFL1dll is None: raise ValueError("The function DSFL1dll could not be loaded from the shared library.") 
        self._DSFL1dll(ct.byref(D),ct.byref(s),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._DSFL1dlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def DSFLSHdll(self,D,s,z):
        """
        T,P,Dl,Dv,x,y,q,e,h,Cv,Cp,w,ierr,herr = DSFLSHdll(D,s,z)
        """
        D = ct.c_double(D)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DSFLSHdll is None: raise ValueError("The function DSFLSHdll could not be loaded from the shared library.") 
        self._DSFLSHdll(ct.byref(D),ct.byref(s),z,ct.byref(T),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._DSFLSHdlloutput_tuple(T.value,P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def DVSATKdll(self,icomp,T):
        """
        D,ierr,herr = DVSATKdll(icomp,T)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._DVSATKdll is None: raise ValueError("The function DVSATKdll could not be loaded from the shared library.") 
        self._DVSATKdll(ct.byref(icomp),ct.byref(T),ct.byref(D),ct.byref(ierr),herr,255)

        return self._DVSATKdlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def ENTHALdll(self,T,D,z):
        """
        h = ENTHALdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        h = ct.c_double()

        if self._ENTHALdll is None: raise ValueError("The function ENTHALdll could not be loaded from the shared library.") 
        self._ENTHALdll(ct.byref(T),ct.byref(D),z,ct.byref(h))

        return h.value

    def ENTROdll(self,T,D,z):
        """
        s = ENTROdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        s = ct.c_double()

        if self._ENTROdll is None: raise ValueError("The function ENTROdll could not be loaded from the shared library.") 
        self._ENTROdll(ct.byref(T),ct.byref(D),z,ct.byref(s))

        return s.value

    def ERRMSGdll(self,ierr):
        """
        herr = ERRMSGdll(ierr)
        """
        ierr = ct.c_int(ierr)
        herr = ct.create_string_buffer(255)

        if self._ERRMSGdll is None: raise ValueError("The function ERRMSGdll could not be loaded from the shared library.") 
        self._ERRMSGdll(ct.byref(ierr),herr,255)

        return trim(herr.raw)

    def ESFLSHdll(self,e,s,z):
        """
        T,P,D,Dl,Dv,x,y,q,h,Cv,Cp,w,ierr,herr = ESFLSHdll(e,s,z)
        """
        e = ct.c_double(e)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        h = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._ESFLSHdll is None: raise ValueError("The function ESFLSHdll could not be loaded from the shared library.") 
        self._ESFLSHdll(ct.byref(e),ct.byref(s),z,ct.byref(T),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(h),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._ESFLSHdlloutput_tuple(T.value,P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,h.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def EXCESSdll(self,T,P,z,kph,D):
        """
        D,vE,eE,hE,sE,aE,gE,ierr,herr = EXCESSdll(T,P,z,kph,D)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        D = ct.c_double(D)
        vE = ct.c_double()
        eE = ct.c_double()
        hE = ct.c_double()
        sE = ct.c_double()
        aE = ct.c_double()
        gE = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._EXCESSdll is None: raise ValueError("The function EXCESSdll could not be loaded from the shared library.") 
        self._EXCESSdll(ct.byref(T),ct.byref(P),z,ct.byref(kph),ct.byref(D),ct.byref(vE),ct.byref(eE),ct.byref(hE),ct.byref(sE),ct.byref(aE),ct.byref(gE),ct.byref(ierr),herr,255)

        return self._EXCESSdlloutput_tuple(D.value,vE.value,eE.value,hE.value,sE.value,aE.value,gE.value,ierr.value,trim(herr.raw))

    def FGCTY2dll(self,T,D,z):
        """
        f,ierr,herr = FGCTY2dll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        f = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._FGCTY2dll is None: raise ValueError("The function FGCTY2dll could not be loaded from the shared library.") 
        self._FGCTY2dll(ct.byref(T),ct.byref(D),z,f,ct.byref(ierr),herr,255)

        return self._FGCTY2dlloutput_tuple(to_double_array(f),ierr.value,trim(herr.raw))

    def FGCTYdll(self,T,D,z):
        """
        f = FGCTYdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        f = (20*ct.c_double)()

        if self._FGCTYdll is None: raise ValueError("The function FGCTYdll could not be loaded from the shared library.") 
        self._FGCTYdll(ct.byref(T),ct.byref(D),z,f)

        return to_double_array(f)

    def FLAGSdll(self,hFlag,jFlag):
        """
        kFlag,ierr,herr = FLAGSdll(hFlag,jFlag)
        """
        hFlag = ct.create_string_buffer(hFlag.encode('utf-8'),255)
        jFlag = ct.c_int(jFlag)
        kFlag = ct.c_int()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._FLAGSdll is None: raise ValueError("The function FLAGSdll could not be loaded from the shared library.") 
        self._FLAGSdll(hFlag,ct.byref(jFlag),ct.byref(kFlag),ct.byref(ierr),herr,255,255)

        return self._FLAGSdlloutput_tuple(kFlag.value,ierr.value,trim(herr.raw))

    def FPVdll(self,T,D,P,z):
        """
        Fpvx = FPVdll(T,D,P,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        Fpvx = ct.c_double()

        if self._FPVdll is None: raise ValueError("The function FPVdll could not be loaded from the shared library.") 
        self._FPVdll(ct.byref(T),ct.byref(D),ct.byref(P),z,ct.byref(Fpvx))

        return Fpvx.value

    def FUGCOFdll(self,T,D,z):
        """
        phi,ierr,herr = FUGCOFdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        phi = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._FUGCOFdll is None: raise ValueError("The function FUGCOFdll could not be loaded from the shared library.") 
        self._FUGCOFdll(ct.byref(T),ct.byref(D),z,phi,ct.byref(ierr),herr,255)

        return self._FUGCOFdlloutput_tuple(to_double_array(phi),ierr.value,trim(herr.raw))

    def GERG04dll(self,ncomp,iFlag):
        """
        ierr,herr = GERG04dll(ncomp,iFlag)
        """
        ncomp = ct.c_int(ncomp)
        iFlag = ct.c_int(iFlag)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._GERG04dll is None: raise ValueError("The function GERG04dll could not be loaded from the shared library.") 
        self._GERG04dll(ct.byref(ncomp),ct.byref(iFlag),ct.byref(ierr),herr,255)

        return self._GERG04dlloutput_tuple(ierr.value,trim(herr.raw))

    def GERG08dll(self,ncomp,iFlag):
        """
        ierr,herr = GERG08dll(ncomp,iFlag)
        """
        ncomp = ct.c_int(ncomp)
        iFlag = ct.c_int(iFlag)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._GERG08dll is None: raise ValueError("The function GERG08dll could not be loaded from the shared library.") 
        self._GERG08dll(ct.byref(ncomp),ct.byref(iFlag),ct.byref(ierr),herr,255)

        return self._GERG08dlloutput_tuple(ierr.value,trim(herr.raw))

    def GETENUMdll(self,iFlag,hEnum):
        """
        iEnum,ierr,herr = GETENUMdll(iFlag,hEnum)
        """
        iFlag = ct.c_int(iFlag)
        hEnum = ct.create_string_buffer(hEnum.encode('utf-8'),255)
        iEnum = ct.c_int()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._GETENUMdll is None: raise ValueError("The function GETENUMdll could not be loaded from the shared library.") 
        self._GETENUMdll(ct.byref(iFlag),hEnum,ct.byref(iEnum),ct.byref(ierr),herr,255,255)

        return self._GETENUMdlloutput_tuple(iEnum.value,ierr.value,trim(herr.raw))

    def GETFIJdll(self,hmodij):
        """
        fij,hfij,hmxrul = GETFIJdll(hmodij)
        """
        hmodij = ct.create_string_buffer(hmodij.encode('utf-8'),3)
        fij = (6*ct.c_double)()
        hfij = ct.create_string_buffer(255)
        hmxrul = ct.create_string_buffer(255)

        if self._GETFIJdll is None: raise ValueError("The function GETFIJdll could not be loaded from the shared library.") 
        self._GETFIJdll(hmodij,fij,hfij,hmxrul,3,255,255)

        return self._GETFIJdlloutput_tuple(to_double_array(fij),trim(hfij.raw),trim(hmxrul.raw))

    def GETKTVdll(self,icomp,jcomp):
        """
        hmodij,fij,hFmix,hfij,hbinp,hmxrul = GETKTVdll(icomp,jcomp)
        """
        icomp = ct.c_int(icomp)
        jcomp = ct.c_int(jcomp)
        hmodij = ct.create_string_buffer(3)
        fij = (6*ct.c_double)()
        hFmix = ct.create_string_buffer(255)
        hfij = ct.create_string_buffer(255)
        hbinp = ct.create_string_buffer(255)
        hmxrul = ct.create_string_buffer(255)

        if self._GETKTVdll is None: raise ValueError("The function GETKTVdll could not be loaded from the shared library.") 
        self._GETKTVdll(ct.byref(icomp),ct.byref(jcomp),hmodij,fij,hFmix,hfij,hbinp,hmxrul,3,255,255,255,255)

        return self._GETKTVdlloutput_tuple(trim(hmodij.raw),to_double_array(fij),trim(hFmix.raw),trim(hfij.raw),trim(hbinp.raw),trim(hmxrul.raw))

    def GETMODdll(self,icomp,htype):
        """
        hcode,hcite = GETMODdll(icomp,htype)
        """
        icomp = ct.c_int(icomp)
        htype = ct.create_string_buffer(htype.encode('utf-8'),3)
        hcode = ct.create_string_buffer(3)
        hcite = ct.create_string_buffer(255)

        if self._GETMODdll is None: raise ValueError("The function GETMODdll could not be loaded from the shared library.") 
        self._GETMODdll(ct.byref(icomp),htype,hcode,hcite,3,3,255)

        return self._GETMODdlloutput_tuple(trim(hcode.raw),trim(hcite.raw))

    def GETREFDIRdll(self,):
        """
        hpth = GETREFDIRdll()
        """
        hpth = ct.create_string_buffer(255)

        if self._GETREFDIRdll is None: raise ValueError("The function GETREFDIRdll could not be loaded from the shared library.") 
        self._GETREFDIRdll(hpth,255)

        return trim(hpth.raw)

    def GIBBSdll(self,T,D,z):
        """
        ar,gr = GIBBSdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        ar = ct.c_double()
        gr = ct.c_double()

        if self._GIBBSdll is None: raise ValueError("The function GIBBSdll could not be loaded from the shared library.") 
        self._GIBBSdll(ct.byref(T),ct.byref(D),z,ct.byref(ar),ct.byref(gr))

        return self._GIBBSdlloutput_tuple(ar.value,gr.value)

    def HEATFRMdll(self,T,D,z):
        """
        hFrm,ierr,herr = HEATFRMdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        hFrm = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._HEATFRMdll is None: raise ValueError("The function HEATFRMdll could not be loaded from the shared library.") 
        self._HEATFRMdll(ct.byref(T),ct.byref(D),z,ct.byref(hFrm),ct.byref(ierr),herr,255)

        return self._HEATFRMdlloutput_tuple(hFrm.value,ierr.value,trim(herr.raw))

    def HEATdll(self,T,D,z):
        """
        hg,hn,ierr,herr = HEATdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        hg = ct.c_double()
        hn = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._HEATdll is None: raise ValueError("The function HEATdll could not be loaded from the shared library.") 
        self._HEATdll(ct.byref(T),ct.byref(D),z,ct.byref(hg),ct.byref(hn),ct.byref(ierr),herr,255)

        return self._HEATdlloutput_tuple(hg.value,hn.value,ierr.value,trim(herr.raw))

    def HMXORDERdll(self,i,j):
        """
        hcasi,hcasj,iFlag,ierr,herr = HMXORDERdll(i,j)
        """
        i = ct.c_int(i)
        j = ct.c_int(j)
        hcasi = ct.create_string_buffer(255)
        hcasj = ct.create_string_buffer(255)
        iFlag = ct.c_int()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._HMXORDERdll is None: raise ValueError("The function HMXORDERdll could not be loaded from the shared library.") 
        self._HMXORDERdll(ct.byref(i),ct.byref(j),hcasi,hcasj,ct.byref(iFlag),ct.byref(ierr),herr,255,255,255)

        return self._HMXORDERdlloutput_tuple(trim(hcasi.raw),trim(hcasj.raw),iFlag.value,ierr.value,trim(herr.raw))

    def HSFL1dll(self,h,s,z,Dmin,Dmax):
        """
        T,D,ierr,herr = HSFL1dll(h,s,z,Dmin,Dmax)
        """
        h = ct.c_double(h)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        Dmin = ct.c_double(Dmin)
        Dmax = ct.c_double(Dmax)
        T = ct.c_double()
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._HSFL1dll is None: raise ValueError("The function HSFL1dll could not be loaded from the shared library.") 
        self._HSFL1dll(ct.byref(h),ct.byref(s),z,ct.byref(Dmin),ct.byref(Dmax),ct.byref(T),ct.byref(D),ct.byref(ierr),herr,255)

        return self._HSFL1dlloutput_tuple(T.value,D.value,ierr.value,trim(herr.raw))

    def HSFLSHdll(self,h,s,z):
        """
        T,P,D,Dl,Dv,x,y,q,e,Cv,Cp,w,ierr,herr = HSFLSHdll(h,s,z)
        """
        h = ct.c_double(h)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._HSFLSHdll is None: raise ValueError("The function HSFLSHdll could not be loaded from the shared library.") 
        self._HSFLSHdll(ct.byref(h),ct.byref(s),z,ct.byref(T),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._HSFLSHdlloutput_tuple(T.value,P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def IDCRVdll(self,D,z,T):
        """
        T,ierr,herr = IDCRVdll(D,z,T)
        """
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double(T)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._IDCRVdll is None: raise ValueError("The function IDCRVdll could not be loaded from the shared library.") 
        self._IDCRVdll(ct.byref(D),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._IDCRVdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def INFOdll(self,icomp):
        """
        wmm,Ttrp,Tnbpt,Tc,Pc,Dc,Zc,acf,dip,Rgas = INFOdll(icomp)
        """
        icomp = ct.c_int(icomp)
        wmm = ct.c_double()
        Ttrp = ct.c_double()
        Tnbpt = ct.c_double()
        Tc = ct.c_double()
        Pc = ct.c_double()
        Dc = ct.c_double()
        Zc = ct.c_double()
        acf = ct.c_double()
        dip = ct.c_double()
        Rgas = ct.c_double()

        if self._INFOdll is None: raise ValueError("The function INFOdll could not be loaded from the shared library.") 
        self._INFOdll(ct.byref(icomp),ct.byref(wmm),ct.byref(Ttrp),ct.byref(Tnbpt),ct.byref(Tc),ct.byref(Pc),ct.byref(Dc),ct.byref(Zc),ct.byref(acf),ct.byref(dip),ct.byref(Rgas))

        return self._INFOdlloutput_tuple(wmm.value,Ttrp.value,Tnbpt.value,Tc.value,Pc.value,Dc.value,Zc.value,acf.value,dip.value,Rgas.value)

    def JICRVdll(self,D,z,T):
        """
        T,ierr,herr = JICRVdll(D,z,T)
        """
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double(T)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._JICRVdll is None: raise ValueError("The function JICRVdll could not be loaded from the shared library.") 
        self._JICRVdll(ct.byref(D),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._JICRVdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def JTCRVdll(self,D,z,T):
        """
        T,ierr,herr = JTCRVdll(D,z,T)
        """
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double(T)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._JTCRVdll is None: raise ValueError("The function JTCRVdll could not be loaded from the shared library.") 
        self._JTCRVdll(ct.byref(D),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._JTCRVdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def LIMITKdll(self,htyp,icomp,T,D,P):
        """
        Tmin,Tmax,Dmax,Pmax,ierr,herr = LIMITKdll(htyp,icomp,T,D,P)
        """
        htyp = ct.create_string_buffer(htyp.encode('utf-8'),3)
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        D = ct.c_double(D)
        P = ct.c_double(P)
        Tmin = ct.c_double()
        Tmax = ct.c_double()
        Dmax = ct.c_double()
        Pmax = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._LIMITKdll is None: raise ValueError("The function LIMITKdll could not be loaded from the shared library.") 
        self._LIMITKdll(htyp,ct.byref(icomp),ct.byref(T),ct.byref(D),ct.byref(P),ct.byref(Tmin),ct.byref(Tmax),ct.byref(Dmax),ct.byref(Pmax),ct.byref(ierr),herr,3,255)

        return self._LIMITKdlloutput_tuple(Tmin.value,Tmax.value,Dmax.value,Pmax.value,ierr.value,trim(herr.raw))

    def LIMITSdll(self,htyp,z):
        """
        Tmin,Tmax,Dmax,Pmax = LIMITSdll(htyp,z)
        """
        htyp = ct.create_string_buffer(htyp.encode('utf-8'),3)
        z = (len(z)*ct.c_double)(*z)
        Tmin = ct.c_double()
        Tmax = ct.c_double()
        Dmax = ct.c_double()
        Pmax = ct.c_double()

        if self._LIMITSdll is None: raise ValueError("The function LIMITSdll could not be loaded from the shared library.") 
        self._LIMITSdll(htyp,z,ct.byref(Tmin),ct.byref(Tmax),ct.byref(Dmax),ct.byref(Pmax),3)

        return self._LIMITSdlloutput_tuple(Tmin.value,Tmax.value,Dmax.value,Pmax.value)

    def LIMITXdll(self,htyp,T,D,P,z):
        """
        Tmin,Tmax,Dmax,Pmax,ierr,herr = LIMITXdll(htyp,T,D,P,z)
        """
        htyp = ct.create_string_buffer(htyp.encode('utf-8'),3)
        T = ct.c_double(T)
        D = ct.c_double(D)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        Tmin = ct.c_double()
        Tmax = ct.c_double()
        Dmax = ct.c_double()
        Pmax = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._LIMITXdll is None: raise ValueError("The function LIMITXdll could not be loaded from the shared library.") 
        self._LIMITXdll(htyp,ct.byref(T),ct.byref(D),ct.byref(P),z,ct.byref(Tmin),ct.byref(Tmax),ct.byref(Dmax),ct.byref(Pmax),ct.byref(ierr),herr,3,255)

        return self._LIMITXdlloutput_tuple(Tmin.value,Tmax.value,Dmax.value,Pmax.value,ierr.value,trim(herr.raw))

    def LIQSPNDLdll(self,T,z):
        """
        D,ierr,herr = LIQSPNDLdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._LIQSPNDLdll is None: raise ValueError("The function LIQSPNDLdll could not be loaded from the shared library.") 
        self._LIQSPNDLdll(ct.byref(T),z,ct.byref(D),ct.byref(ierr),herr,255)

        return self._LIQSPNDLdlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def MASSFLUXdll(self,Tm,P,z,beta,rf):
        """
        fluxm,Cs,T0,P0,xMach,u,Ts,Ps,ierr,herr = MASSFLUXdll(Tm,P,z,beta,rf)
        """
        Tm = ct.c_double(Tm)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        beta = ct.c_double(beta)
        rf = ct.c_double(rf)
        fluxm = ct.c_double()
        Cs = ct.c_double()
        T0 = ct.c_double()
        P0 = ct.c_double()
        xMach = ct.c_double()
        u = ct.c_double()
        Ts = ct.c_double()
        Ps = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._MASSFLUXdll is None: raise ValueError("The function MASSFLUXdll could not be loaded from the shared library.") 
        self._MASSFLUXdll(ct.byref(Tm),ct.byref(P),z,ct.byref(beta),ct.byref(rf),ct.byref(fluxm),ct.byref(Cs),ct.byref(T0),ct.byref(P0),ct.byref(xMach),ct.byref(u),ct.byref(Ts),ct.byref(Ps),ct.byref(ierr),herr,255)

        return self._MASSFLUXdlloutput_tuple(fluxm.value,Cs.value,T0.value,P0.value,xMach.value,u.value,Ts.value,Ps.value,ierr.value,trim(herr.raw))

    def MAXPdll(self,z):
        """
        Tm,Pm,Dm,ierr,herr = MAXPdll(z)
        """
        z = (len(z)*ct.c_double)(*z)
        Tm = ct.c_double()
        Pm = ct.c_double()
        Dm = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._MAXPdll is None: raise ValueError("The function MAXPdll could not be loaded from the shared library.") 
        self._MAXPdll(z,ct.byref(Tm),ct.byref(Pm),ct.byref(Dm),ct.byref(ierr),herr,255)

        return self._MAXPdlloutput_tuple(Tm.value,Pm.value,Dm.value,ierr.value,trim(herr.raw))

    def MAXTdll(self,z):
        """
        Tm,Pm,Dm,ierr,herr = MAXTdll(z)
        """
        z = (len(z)*ct.c_double)(*z)
        Tm = ct.c_double()
        Pm = ct.c_double()
        Dm = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._MAXTdll is None: raise ValueError("The function MAXTdll could not be loaded from the shared library.") 
        self._MAXTdll(z,ct.byref(Tm),ct.byref(Pm),ct.byref(Dm),ct.byref(ierr),herr,255)

        return self._MAXTdlloutput_tuple(Tm.value,Pm.value,Dm.value,ierr.value,trim(herr.raw))

    def MELTKdll(self,icomp,T):
        """
        P,ierr,herr = MELTKdll(icomp,T)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        P = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._MELTKdll is None: raise ValueError("The function MELTKdll could not be loaded from the shared library.") 
        self._MELTKdll(ct.byref(icomp),ct.byref(T),ct.byref(P),ct.byref(ierr),herr,255)

        return self._MELTKdlloutput_tuple(P.value,ierr.value,trim(herr.raw))

    def MELTPdll(self,P,z):
        """
        T,ierr,herr = MELTPdll(P,z)
        """
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._MELTPdll is None: raise ValueError("The function MELTPdll could not be loaded from the shared library.") 
        self._MELTPdll(ct.byref(P),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._MELTPdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def MELTTdll(self,T,z):
        """
        P,ierr,herr = MELTTdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        P = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._MELTTdll is None: raise ValueError("The function MELTTdll could not be loaded from the shared library.") 
        self._MELTTdll(ct.byref(T),z,ct.byref(P),ct.byref(ierr),herr,255)

        return self._MELTTdlloutput_tuple(P.value,ierr.value,trim(herr.raw))

    def MLTH2Odll(self,T):
        """
        P1,P2 = MLTH2Odll(T)
        """
        T = ct.c_double(T)
        P1 = ct.c_double()
        P2 = ct.c_double()

        if self._MLTH2Odll is None: raise ValueError("The function MLTH2Odll could not be loaded from the shared library.") 
        self._MLTH2Odll(ct.byref(T),ct.byref(P1),ct.byref(P2))

        return self._MLTH2Odlloutput_tuple(P1.value,P2.value)

    def NAMEdll(self,icomp):
        """
        hnam,hn80,hcasn = NAMEdll(icomp)
        """
        icomp = ct.c_int(icomp)
        hnam = ct.create_string_buffer(12)
        hn80 = ct.create_string_buffer(80)
        hcasn = ct.create_string_buffer(12)

        if self._NAMEdll is None: raise ValueError("The function NAMEdll could not be loaded from the shared library.") 
        self._NAMEdll(ct.byref(icomp),hnam,hn80,hcasn,12,80,12)

        return self._NAMEdlloutput_tuple(trim(hnam.raw),trim(hn80.raw),trim(hcasn.raw))

    def PASSCMNdll(self,hvr,iset,icomp,jcomp,hstr,ilng,dbl,arr):
        """
        hstr,ilng,dbl,arr,ierr,herr = PASSCMNdll(hvr,iset,icomp,jcomp,hstr,ilng,dbl,arr)
        """
        hvr = ct.create_string_buffer(hvr.encode('utf-8'),255)
        iset = ct.c_int(iset)
        icomp = ct.c_int(icomp)
        jcomp = ct.c_int(jcomp)
        hstr = ct.create_string_buffer(hstr.encode('utf-8'),255)
        ilng = ct.c_int(ilng)
        dbl = ct.c_double(dbl)
        arr = (100*ct.c_double)(*arr)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PASSCMNdll is None: raise ValueError("The function PASSCMNdll could not be loaded from the shared library.") 
        self._PASSCMNdll(hvr,ct.byref(iset),ct.byref(icomp),ct.byref(jcomp),hstr,ct.byref(ilng),ct.byref(dbl),arr,ct.byref(ierr),herr,255,255,255)

        return self._PASSCMNdlloutput_tuple(trim(hstr.raw),ilng.value,dbl.value,to_double_array(arr),ierr.value,trim(herr.raw))

    def PDFL1dll(self,P,D,z):
        """
        T,ierr,herr = PDFL1dll(P,D,z)
        """
        P = ct.c_double(P)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PDFL1dll is None: raise ValueError("The function PDFL1dll could not be loaded from the shared library.") 
        self._PDFL1dll(ct.byref(P),ct.byref(D),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._PDFL1dlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def PDFLSHdll(self,P,D,z):
        """
        T,Dl,Dv,x,y,q,e,h,s,Cv,Cp,w,ierr,herr = PDFLSHdll(P,D,z)
        """
        P = ct.c_double(P)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PDFLSHdll is None: raise ValueError("The function PDFLSHdll could not be loaded from the shared library.") 
        self._PDFLSHdll(ct.byref(P),ct.byref(D),z,ct.byref(T),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._PDFLSHdlloutput_tuple(T.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def PEFL1dll(self,P,e,z,kph):
        """
        T,D,ierr,herr = PEFL1dll(P,e,z,kph)
        """
        P = ct.c_double(P)
        e = ct.c_double(e)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        T = ct.c_double()
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PEFL1dll is None: raise ValueError("The function PEFL1dll could not be loaded from the shared library.") 
        self._PEFL1dll(ct.byref(P),ct.byref(e),z,ct.byref(kph),ct.byref(T),ct.byref(D),ct.byref(ierr),herr,255)

        return self._PEFL1dlloutput_tuple(T.value,D.value,ierr.value,trim(herr.raw))

    def PEFLSHdll(self,P,e,z):
        """
        T,D,Dl,Dv,x,y,q,h,s,Cv,Cp,w,ierr,herr = PEFLSHdll(P,e,z)
        """
        P = ct.c_double(P)
        e = ct.c_double(e)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PEFLSHdll is None: raise ValueError("The function PEFLSHdll could not be loaded from the shared library.") 
        self._PEFLSHdll(ct.byref(P),ct.byref(e),z,ct.byref(T),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._PEFLSHdlloutput_tuple(T.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def PHFL1dll(self,P,h,z,kph):
        """
        T,D,ierr,herr = PHFL1dll(P,h,z,kph)
        """
        P = ct.c_double(P)
        h = ct.c_double(h)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        T = ct.c_double()
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PHFL1dll is None: raise ValueError("The function PHFL1dll could not be loaded from the shared library.") 
        self._PHFL1dll(ct.byref(P),ct.byref(h),z,ct.byref(kph),ct.byref(T),ct.byref(D),ct.byref(ierr),herr,255)

        return self._PHFL1dlloutput_tuple(T.value,D.value,ierr.value,trim(herr.raw))

    def PHFLSHdll(self,P,h,z):
        """
        T,D,Dl,Dv,x,y,q,e,s,Cv,Cp,w,ierr,herr = PHFLSHdll(P,h,z)
        """
        P = ct.c_double(P)
        h = ct.c_double(h)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PHFLSHdll is None: raise ValueError("The function PHFLSHdll could not be loaded from the shared library.") 
        self._PHFLSHdll(ct.byref(P),ct.byref(h),z,ct.byref(T),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._PHFLSHdlloutput_tuple(T.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def PHI0dll(self,itau,idel,T,D,z):
        """
        phi00 = PHI0dll(itau,idel,T,D,z)
        """
        itau = ct.c_int(itau)
        idel = ct.c_int(idel)
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        phi00 = ct.c_double()

        if self._PHI0dll is None: raise ValueError("The function PHI0dll could not be loaded from the shared library.") 
        self._PHI0dll(ct.byref(itau),ct.byref(idel),ct.byref(T),ct.byref(D),z,ct.byref(phi00))

        return phi00.value

    def PHIDERVdll(self,iderv,T,D,z):
        """
        dadn,dnadn,ierr,herr = PHIDERVdll(iderv,T,D,z)
        """
        iderv = ct.c_int(iderv)
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        dadn = (20*ct.c_double)()
        dnadn = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PHIDERVdll is None: raise ValueError("The function PHIDERVdll could not be loaded from the shared library.") 
        self._PHIDERVdll(ct.byref(iderv),ct.byref(T),ct.byref(D),z,dadn,dnadn,ct.byref(ierr),herr,255)

        return self._PHIDERVdlloutput_tuple(to_double_array(dadn),to_double_array(dnadn),ierr.value,trim(herr.raw))

    def PHIHMXdll(self,itau,idel,tau,delta,z):
        """
        phi = PHIHMXdll(itau,idel,tau,delta,z)
        """
        itau = ct.c_int(itau)
        idel = ct.c_int(idel)
        tau = ct.c_double(tau)
        delta = ct.c_double(delta)
        z = (len(z)*ct.c_double)(*z)
        phi = ct.c_double()

        if self._PHIHMXdll is None: raise ValueError("The function PHIHMXdll could not be loaded from the shared library.") 
        self._PHIHMXdll(ct.byref(itau),ct.byref(idel),ct.byref(tau),ct.byref(delta),z,ct.byref(phi))

        return phi.value

    def PHIKdll(self,icomp,itau,idel,tau,delta):
        """
        phi = PHIKdll(icomp,itau,idel,tau,delta)
        """
        icomp = ct.c_int(icomp)
        itau = ct.c_int(itau)
        idel = ct.c_int(idel)
        tau = ct.c_double(tau)
        delta = ct.c_double(delta)
        phi = ct.c_double()

        if self._PHIKdll is None: raise ValueError("The function PHIKdll could not be loaded from the shared library.") 
        self._PHIKdll(ct.byref(icomp),ct.byref(itau),ct.byref(idel),ct.byref(tau),ct.byref(delta),ct.byref(phi))

        return phi.value

    def PHIMIXdll(self,i,j,itau,idel,tau,delta,z):
        """
        phi = PHIMIXdll(i,j,itau,idel,tau,delta,z)
        """
        i = ct.c_int(i)
        j = ct.c_int(j)
        itau = ct.c_int(itau)
        idel = ct.c_int(idel)
        tau = ct.c_double(tau)
        delta = ct.c_double(delta)
        z = (len(z)*ct.c_double)(*z)
        phi = ct.c_double()

        if self._PHIMIXdll is None: raise ValueError("The function PHIMIXdll could not be loaded from the shared library.") 
        self._PHIMIXdll(ct.byref(i),ct.byref(j),ct.byref(itau),ct.byref(idel),ct.byref(tau),ct.byref(delta),z,ct.byref(phi))

        return phi.value

    def PHIXdll(self,itau,idel,tau,delta,z):
        """
        phixx = PHIXdll(itau,idel,tau,delta,z)
        """
        itau = ct.c_int(itau)
        idel = ct.c_int(idel)
        tau = ct.c_double(tau)
        delta = ct.c_double(delta)
        z = (len(z)*ct.c_double)(*z)
        phixx = ct.c_double()

        if self._PHIXdll is None: raise ValueError("The function PHIXdll could not be loaded from the shared library.") 
        self._PHIXdll(ct.byref(itau),ct.byref(idel),ct.byref(tau),ct.byref(delta),z,ct.byref(phixx))

        return phixx.value

    def PQFLSHdll(self,P,q,z,kq):
        """
        T,D,Dl,Dv,x,y,e,h,s,Cv,Cp,w,ierr,herr = PQFLSHdll(P,q,z,kq)
        """
        P = ct.c_double(P)
        q = ct.c_double(q)
        z = (len(z)*ct.c_double)(*z)
        kq = ct.c_int(kq)
        T = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PQFLSHdll is None: raise ValueError("The function PQFLSHdll could not be loaded from the shared library.") 
        self._PQFLSHdll(ct.byref(P),ct.byref(q),z,ct.byref(kq),ct.byref(T),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._PQFLSHdlloutput_tuple(T.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),e.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def PREOSdll(self,i):
        """
         = PREOSdll(i)
        """
        i = ct.c_int(i)

        if self._PREOSdll is None: raise ValueError("The function PREOSdll could not be loaded from the shared library.") 
        self._PREOSdll(ct.byref(i))

        return

    def PRESSdll(self,T,D,z):
        """
        P = PRESSdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        P = ct.c_double()

        if self._PRESSdll is None: raise ValueError("The function PRESSdll could not be loaded from the shared library.") 
        self._PRESSdll(ct.byref(T),ct.byref(D),z,ct.byref(P))

        return P.value

    def PSATKdll(self,icomp,T):
        """
        P,ierr,herr = PSATKdll(icomp,T)
        """
        icomp = ct.c_int(icomp)
        T = ct.c_double(T)
        P = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PSATKdll is None: raise ValueError("The function PSATKdll could not be loaded from the shared library.") 
        self._PSATKdll(ct.byref(icomp),ct.byref(T),ct.byref(P),ct.byref(ierr),herr,255)

        return self._PSATKdlloutput_tuple(P.value,ierr.value,trim(herr.raw))

    def PSFL1dll(self,P,s,z,kph):
        """
        T,D,ierr,herr = PSFL1dll(P,s,z,kph)
        """
        P = ct.c_double(P)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        T = ct.c_double()
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PSFL1dll is None: raise ValueError("The function PSFL1dll could not be loaded from the shared library.") 
        self._PSFL1dll(ct.byref(P),ct.byref(s),z,ct.byref(kph),ct.byref(T),ct.byref(D),ct.byref(ierr),herr,255)

        return self._PSFL1dlloutput_tuple(T.value,D.value,ierr.value,trim(herr.raw))

    def PSFLSHdll(self,P,s,z):
        """
        T,D,Dl,Dv,x,y,q,e,h,Cv,Cp,w,ierr,herr = PSFLSHdll(P,s,z)
        """
        P = ct.c_double(P)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._PSFLSHdll is None: raise ValueError("The function PSFLSHdll could not be loaded from the shared library.") 
        self._PSFLSHdll(ct.byref(P),ct.byref(s),z,ct.byref(T),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._PSFLSHdlloutput_tuple(T.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def PUREFLDdll(self,icomp):
        """
         = PUREFLDdll(icomp)
        """
        icomp = ct.c_int(icomp)

        if self._PUREFLDdll is None: raise ValueError("The function PUREFLDdll could not be loaded from the shared library.") 
        self._PUREFLDdll(ct.byref(icomp))

        return

    def QMASSdll(self,qmol,xl,xv):
        """
        qkg,xlkg,xvkg,wliq,wvap,ierr,herr = QMASSdll(qmol,xl,xv)
        """
        qmol = ct.c_double(qmol)
        xl = (len(xl)*ct.c_double)(*xl)
        xv = (len(xv)*ct.c_double)(*xv)
        qkg = ct.c_double()
        xlkg = (20*ct.c_double)()
        xvkg = (20*ct.c_double)()
        wliq = ct.c_double()
        wvap = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._QMASSdll is None: raise ValueError("The function QMASSdll could not be loaded from the shared library.") 
        self._QMASSdll(ct.byref(qmol),xl,xv,ct.byref(qkg),xlkg,xvkg,ct.byref(wliq),ct.byref(wvap),ct.byref(ierr),herr,255)

        return self._QMASSdlloutput_tuple(qkg.value,to_double_array(xlkg),to_double_array(xvkg),wliq.value,wvap.value,ierr.value,trim(herr.raw))

    def QMOLEdll(self,qkg,xlkg,xvkg):
        """
        qmol,xl,xv,wliq,wvap,ierr,herr = QMOLEdll(qkg,xlkg,xvkg)
        """
        qkg = ct.c_double(qkg)
        xlkg = (len(xlkg)*ct.c_double)(*xlkg)
        xvkg = (len(xvkg)*ct.c_double)(*xvkg)
        qmol = ct.c_double()
        xl = (20*ct.c_double)()
        xv = (20*ct.c_double)()
        wliq = ct.c_double()
        wvap = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._QMOLEdll is None: raise ValueError("The function QMOLEdll could not be loaded from the shared library.") 
        self._QMOLEdll(ct.byref(qkg),xlkg,xvkg,ct.byref(qmol),xl,xv,ct.byref(wliq),ct.byref(wvap),ct.byref(ierr),herr,255)

        return self._QMOLEdlloutput_tuple(qmol.value,to_double_array(xl),to_double_array(xv),wliq.value,wvap.value,ierr.value,trim(herr.raw))

    def RDXHMXdll(self,ix,icmp,icmp2,z):
        """
        Tred,Dred,ierr,herr = RDXHMXdll(ix,icmp,icmp2,z)
        """
        ix = ct.c_int(ix)
        icmp = ct.c_int(icmp)
        icmp2 = ct.c_int(icmp2)
        z = (len(z)*ct.c_double)(*z)
        Tred = ct.c_double()
        Dred = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._RDXHMXdll is None: raise ValueError("The function RDXHMXdll could not be loaded from the shared library.") 
        self._RDXHMXdll(ct.byref(ix),ct.byref(icmp),ct.byref(icmp2),z,ct.byref(Tred),ct.byref(Dred),ct.byref(ierr),herr,255)

        return self._RDXHMXdlloutput_tuple(Tred.value,Dred.value,ierr.value,trim(herr.raw))

    def REDXdll(self,z):
        """
        Tred,Dred = REDXdll(z)
        """
        z = (len(z)*ct.c_double)(*z)
        Tred = ct.c_double()
        Dred = ct.c_double()

        if self._REDXdll is None: raise ValueError("The function REDXdll could not be loaded from the shared library.") 
        self._REDXdll(z,ct.byref(Tred),ct.byref(Dred))

        return self._REDXdlloutput_tuple(Tred.value,Dred.value)

    def REFPROP1dll(self,hIn,hOut,iUnits,iMass,a,b,z):
        """
        z,c,q,ierr,herr = REFPROP1dll(hIn,hOut,iUnits,iMass,a,b,z)
        """
        hIn = ct.create_string_buffer(hIn.encode('utf-8'),255)
        hOut = ct.create_string_buffer(hOut.encode('utf-8'),255)
        iUnits = ct.c_int(iUnits)
        iMass = ct.c_int(iMass)
        a = ct.c_double(a)
        b = ct.c_double(b)
        z = (20*ct.c_double)(*z)
        c = ct.c_double()
        q = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._REFPROP1dll is None: raise ValueError("The function REFPROP1dll could not be loaded from the shared library.") 
        self._REFPROP1dll(hIn,hOut,ct.byref(iUnits),ct.byref(iMass),ct.byref(a),ct.byref(b),z,ct.byref(c),ct.byref(q),ct.byref(ierr),herr,255,255,255)

        return self._REFPROP1dlloutput_tuple(to_double_array(z),c.value,q.value,ierr.value,trim(herr.raw))

    def REFPROP2dll(self,hFld,hIn,hOut,iUnits,iFlag,a,b,z):
        """
        z,Output,q,ierr,herr = REFPROP2dll(hFld,hIn,hOut,iUnits,iFlag,a,b,z)
        """
        hFld = ct.create_string_buffer(hFld.encode('utf-8'),10000)
        hIn = ct.create_string_buffer(hIn.encode('utf-8'),255)
        hOut = ct.create_string_buffer(hOut.encode('utf-8'),255)
        iUnits = ct.c_int(iUnits)
        iFlag = ct.c_int(iFlag)
        a = ct.c_double(a)
        b = ct.c_double(b)
        z = (20*ct.c_double)(*z)
        Output = (200*ct.c_double)()
        q = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._REFPROP2dll is None: raise ValueError("The function REFPROP2dll could not be loaded from the shared library.") 
        self._REFPROP2dll(hFld,hIn,hOut,ct.byref(iUnits),ct.byref(iFlag),ct.byref(a),ct.byref(b),z,Output,ct.byref(q),ct.byref(ierr),herr,10000,255,255,255)

        return self._REFPROP2dlloutput_tuple(to_double_array(z),to_double_array(Output),q.value,ierr.value,trim(herr.raw))

    def REFPROPdll(self,hFld,hIn,hOut,iUnits,iMass,iFlag,a,b,z):
        """
        z,Output,hUnits,iUCode,x,y,x3,q,ierr,herr = REFPROPdll(hFld,hIn,hOut,iUnits,iMass,iFlag,a,b,z)
        """
        hFld = ct.create_string_buffer(hFld.encode('utf-8'),10000)
        hIn = ct.create_string_buffer(hIn.encode('utf-8'),255)
        hOut = ct.create_string_buffer(hOut.encode('utf-8'),255)
        iUnits = ct.c_int(iUnits)
        iMass = ct.c_int(iMass)
        iFlag = ct.c_int(iFlag)
        a = ct.c_double(a)
        b = ct.c_double(b)
        z = (20*ct.c_double)(*z)
        Output = (200*ct.c_double)()
        hUnits = ct.create_string_buffer(255)
        iUCode = ct.c_int()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        x3 = (20*ct.c_double)()
        q = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._REFPROPdll is None: raise ValueError("The function REFPROPdll could not be loaded from the shared library.") 
        self._REFPROPdll(hFld,hIn,hOut,ct.byref(iUnits),ct.byref(iMass),ct.byref(iFlag),ct.byref(a),ct.byref(b),z,Output,hUnits,ct.byref(iUCode),x,y,x3,ct.byref(q),ct.byref(ierr),herr,10000,255,255,255,255)

        return self._REFPROPdlloutput_tuple(to_double_array(z),to_double_array(Output),trim(hUnits.raw),iUCode.value,to_double_array(x),to_double_array(y),to_double_array(x3),q.value,ierr.value,trim(herr.raw))

    def RESIDUALdll(self,T,D,z):
        """
        Pr,er,hr,sr,Cvr,Cpr,ar,gr = RESIDUALdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        Pr = ct.c_double()
        er = ct.c_double()
        hr = ct.c_double()
        sr = ct.c_double()
        Cvr = ct.c_double()
        Cpr = ct.c_double()
        ar = ct.c_double()
        gr = ct.c_double()

        if self._RESIDUALdll is None: raise ValueError("The function RESIDUALdll could not be loaded from the shared library.") 
        self._RESIDUALdll(ct.byref(T),ct.byref(D),z,ct.byref(Pr),ct.byref(er),ct.byref(hr),ct.byref(sr),ct.byref(Cvr),ct.byref(Cpr),ct.byref(ar),ct.byref(gr))

        return self._RESIDUALdlloutput_tuple(Pr.value,er.value,hr.value,sr.value,Cvr.value,Cpr.value,ar.value,gr.value)

    def RIEMdll(self,T,D,z):
        """
        riemc = RIEMdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        riemc = ct.c_double()

        if self._RIEMdll is None: raise ValueError("The function RIEMdll could not be loaded from the shared library.") 
        self._RIEMdll(ct.byref(T),ct.byref(D),z,ct.byref(riemc))

        return riemc.value

    def RMIX2dll(self,z):
        """
        Rgas = RMIX2dll(z)
        """
        z = (len(z)*ct.c_double)(*z)
        Rgas = ct.c_double()

        if self._RMIX2dll is None: raise ValueError("The function RMIX2dll could not be loaded from the shared library.") 
        self._RMIX2dll(z,ct.byref(Rgas))

        return Rgas.value

    def RPVersion(self,):
        """
        hv = RPVersion()
        """
        hv = ct.create_string_buffer(255)

        if self._RPVersion is None: raise ValueError("The function RPVersion could not be loaded from the shared library.") 
        self._RPVersion(hv,255)

        return trim(hv.raw)

    def SATDdll(self,D,z,kph):
        """
        kr,T,P,Dl,Dv,x,y,ierr,herr = SATDdll(D,z,kph)
        """
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        kr = ct.c_int()
        T = ct.c_double()
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATDdll is None: raise ValueError("The function SATDdll could not be loaded from the shared library.") 
        self._SATDdll(ct.byref(D),z,ct.byref(kph),ct.byref(kr),ct.byref(T),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(ierr),herr,255)

        return self._SATDdlloutput_tuple(kr.value,T.value,P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),ierr.value,trim(herr.raw))

    def SATESTdll(self,iFlash,T,P,z):
        """
        T,P,x,y,ierr,herr = SATESTdll(iFlash,T,P,z)
        """
        iFlash = ct.c_int(iFlash)
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATESTdll is None: raise ValueError("The function SATESTdll could not be loaded from the shared library.") 
        self._SATESTdll(ct.byref(iFlash),ct.byref(T),ct.byref(P),z,x,y,ct.byref(ierr),herr,255)

        return self._SATESTdlloutput_tuple(T.value,P.value,to_double_array(x),to_double_array(y),ierr.value,trim(herr.raw))

    def SATEdll(self,e,z,kph):
        """
        nroot,k1,T1,P1,D1,k2,T2,P2,D2,ierr,herr = SATEdll(e,z,kph)
        """
        e = ct.c_double(e)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        nroot = ct.c_int()
        k1 = ct.c_int()
        T1 = ct.c_double()
        P1 = ct.c_double()
        D1 = ct.c_double()
        k2 = ct.c_int()
        T2 = ct.c_double()
        P2 = ct.c_double()
        D2 = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATEdll is None: raise ValueError("The function SATEdll could not be loaded from the shared library.") 
        self._SATEdll(ct.byref(e),z,ct.byref(kph),ct.byref(nroot),ct.byref(k1),ct.byref(T1),ct.byref(P1),ct.byref(D1),ct.byref(k2),ct.byref(T2),ct.byref(P2),ct.byref(D2),ct.byref(ierr),herr,255)

        return self._SATEdlloutput_tuple(nroot.value,k1.value,T1.value,P1.value,D1.value,k2.value,T2.value,P2.value,D2.value,ierr.value,trim(herr.raw))

    def SATGUESSdll(self,kph,iprop,x,T,P,D,h,s,Dy,y):
        """
        T,P,D,h,s,Dy,y,ierr,herr = SATGUESSdll(kph,iprop,x,T,P,D,h,s,Dy,y)
        """
        kph = ct.c_int(kph)
        iprop = ct.c_int(iprop)
        x = (len(x)*ct.c_double)(*x)
        T = ct.c_double(T)
        P = ct.c_double(P)
        D = ct.c_double(D)
        h = ct.c_double(h)
        s = ct.c_double(s)
        Dy = ct.c_double(Dy)
        y = (20*ct.c_double)(*y)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATGUESSdll is None: raise ValueError("The function SATGUESSdll could not be loaded from the shared library.") 
        self._SATGUESSdll(ct.byref(kph),ct.byref(iprop),x,ct.byref(T),ct.byref(P),ct.byref(D),ct.byref(h),ct.byref(s),ct.byref(Dy),y,ct.byref(ierr),herr,255)

        return self._SATGUESSdlloutput_tuple(T.value,P.value,D.value,h.value,s.value,Dy.value,to_double_array(y),ierr.value,trim(herr.raw))

    def SATGVdll(self,T,P,z,vf,b,ipv,ityp,isp,Dx,Dy,x,y):
        """
        T,P,Dx,Dy,x,y,ierr,herr = SATGVdll(T,P,z,vf,b,ipv,ityp,isp,Dx,Dy,x,y)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        vf = ct.c_double(vf)
        b = ct.c_double(b)
        ipv = ct.c_int(ipv)
        ityp = ct.c_int(ityp)
        isp = ct.c_int(isp)
        Dx = ct.c_double(Dx)
        Dy = ct.c_double(Dy)
        x = (20*ct.c_double)(*x)
        y = (20*ct.c_double)(*y)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATGVdll is None: raise ValueError("The function SATGVdll could not be loaded from the shared library.") 
        self._SATGVdll(ct.byref(T),ct.byref(P),z,ct.byref(vf),ct.byref(b),ct.byref(ipv),ct.byref(ityp),ct.byref(isp),ct.byref(Dx),ct.byref(Dy),x,y,ct.byref(ierr),herr,255)

        return self._SATGVdlloutput_tuple(T.value,P.value,Dx.value,Dy.value,to_double_array(x),to_double_array(y),ierr.value,trim(herr.raw))

    def SATHdll(self,h,z,kph):
        """
        nroot,k1,T1,P1,D1,k2,T2,P2,D2,ierr,herr = SATHdll(h,z,kph)
        """
        h = ct.c_double(h)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        nroot = ct.c_int()
        k1 = ct.c_int()
        T1 = ct.c_double()
        P1 = ct.c_double()
        D1 = ct.c_double()
        k2 = ct.c_int()
        T2 = ct.c_double()
        P2 = ct.c_double()
        D2 = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATHdll is None: raise ValueError("The function SATHdll could not be loaded from the shared library.") 
        self._SATHdll(ct.byref(h),z,ct.byref(kph),ct.byref(nroot),ct.byref(k1),ct.byref(T1),ct.byref(P1),ct.byref(D1),ct.byref(k2),ct.byref(T2),ct.byref(P2),ct.byref(D2),ct.byref(ierr),herr,255)

        return self._SATHdlloutput_tuple(nroot.value,k1.value,T1.value,P1.value,D1.value,k2.value,T2.value,P2.value,D2.value,ierr.value,trim(herr.raw))

    def SATPESTdll(self,P,z,kph):
        """
        T,x2,ierr,herr = SATPESTdll(P,z,kph)
        """
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        T = ct.c_double()
        x2 = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATPESTdll is None: raise ValueError("The function SATPESTdll could not be loaded from the shared library.") 
        self._SATPESTdll(ct.byref(P),z,ct.byref(kph),ct.byref(T),x2,ct.byref(ierr),herr,255)

        return self._SATPESTdlloutput_tuple(T.value,to_double_array(x2),ierr.value,trim(herr.raw))

    def SATPdll(self,P,z,kph):
        """
        T,Dl,Dv,x,y,ierr,herr = SATPdll(P,z,kph)
        """
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        T = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATPdll is None: raise ValueError("The function SATPdll could not be loaded from the shared library.") 
        self._SATPdll(ct.byref(P),z,ct.byref(kph),ct.byref(T),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(ierr),herr,255)

        return self._SATPdlloutput_tuple(T.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),ierr.value,trim(herr.raw))

    def SATSPLNdll(self,z):
        """
        ierr,herr = SATSPLNdll(z)
        """
        z = (len(z)*ct.c_double)(*z)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATSPLNdll is None: raise ValueError("The function SATSPLNdll could not be loaded from the shared library.") 
        self._SATSPLNdll(z,ct.byref(ierr),herr,255)

        return self._SATSPLNdlloutput_tuple(ierr.value,trim(herr.raw))

    def SATSdll(self,s,z,kph):
        """
        nroot,k1,T1,P1,D1,k2,T2,P2,D2,k3,T3,P3,D3,ierr,herr = SATSdll(s,z,kph)
        """
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        nroot = ct.c_int()
        k1 = ct.c_int()
        T1 = ct.c_double()
        P1 = ct.c_double()
        D1 = ct.c_double()
        k2 = ct.c_int()
        T2 = ct.c_double()
        P2 = ct.c_double()
        D2 = ct.c_double()
        k3 = ct.c_int()
        T3 = ct.c_double()
        P3 = ct.c_double()
        D3 = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATSdll is None: raise ValueError("The function SATSdll could not be loaded from the shared library.") 
        self._SATSdll(ct.byref(s),z,ct.byref(kph),ct.byref(nroot),ct.byref(k1),ct.byref(T1),ct.byref(P1),ct.byref(D1),ct.byref(k2),ct.byref(T2),ct.byref(P2),ct.byref(D2),ct.byref(k3),ct.byref(T3),ct.byref(P3),ct.byref(D3),ct.byref(ierr),herr,255)

        return self._SATSdlloutput_tuple(nroot.value,k1.value,T1.value,P1.value,D1.value,k2.value,T2.value,P2.value,D2.value,k3.value,T3.value,P3.value,D3.value,ierr.value,trim(herr.raw))

    def SATTESTdll(self,T,z,kph):
        """
        P,x2,ierr,herr = SATTESTdll(T,z,kph)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        P = ct.c_double()
        x2 = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATTESTdll is None: raise ValueError("The function SATTESTdll could not be loaded from the shared library.") 
        self._SATTESTdll(ct.byref(T),z,ct.byref(kph),ct.byref(P),x2,ct.byref(ierr),herr,255)

        return self._SATTESTdlloutput_tuple(P.value,to_double_array(x2),ierr.value,trim(herr.raw))

    def SATTPdll(self,T,P,z,iFlsh,iGuess,D,Dl,Dv,x,y):
        """
        T,P,D,Dl,Dv,x,y,q,ierr,herr = SATTPdll(T,P,z,iFlsh,iGuess,D,Dl,Dv,x,y)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        iFlsh = ct.c_int(iFlsh)
        iGuess = ct.c_int(iGuess)
        D = ct.c_double(D)
        Dl = ct.c_double(Dl)
        Dv = ct.c_double(Dv)
        x = (20*ct.c_double)(*x)
        y = (20*ct.c_double)(*y)
        q = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATTPdll is None: raise ValueError("The function SATTPdll could not be loaded from the shared library.") 
        self._SATTPdll(ct.byref(T),ct.byref(P),z,ct.byref(iFlsh),ct.byref(iGuess),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(ierr),herr,255)

        return self._SATTPdlloutput_tuple(T.value,P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,ierr.value,trim(herr.raw))

    def SATTdll(self,T,z,kph):
        """
        P,Dl,Dv,x,y,ierr,herr = SATTdll(T,z,kph)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SATTdll is None: raise ValueError("The function SATTdll could not be loaded from the shared library.") 
        self._SATTdll(ct.byref(T),z,ct.byref(kph),ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(ierr),herr,255)

        return self._SATTdlloutput_tuple(P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),ierr.value,trim(herr.raw))

    def SETAGAdll(self,):
        """
        ierr,herr = SETAGAdll()
        """
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SETAGAdll is None: raise ValueError("The function SETAGAdll could not be loaded from the shared library.") 
        self._SETAGAdll(ct.byref(ierr),herr,255)

        return self._SETAGAdlloutput_tuple(ierr.value,trim(herr.raw))

    def SETFLUIDSdll(self,hFld):
        """
        ierr = SETFLUIDSdll(hFld)
        """
        hFld = ct.create_string_buffer(hFld.encode('utf-8'),10000)
        ierr = ct.c_int()

        if self._SETFLUIDSdll is None: raise ValueError("The function SETFLUIDSdll could not be loaded from the shared library.") 
        self._SETFLUIDSdll(hFld,ct.byref(ierr),10000)

        return ierr.value

    def SETKTVdll(self,icomp,jcomp,hmodij,fij,hFmix):
        """
        ierr,herr = SETKTVdll(icomp,jcomp,hmodij,fij,hFmix)
        """
        icomp = ct.c_int(icomp)
        jcomp = ct.c_int(jcomp)
        hmodij = ct.create_string_buffer(hmodij.encode('utf-8'),3)
        fij = (len(fij)*ct.c_double)(*fij)
        hFmix = ct.create_string_buffer(hFmix.encode('utf-8'),255)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SETKTVdll is None: raise ValueError("The function SETKTVdll could not be loaded from the shared library.") 
        self._SETKTVdll(ct.byref(icomp),ct.byref(jcomp),hmodij,fij,hFmix,ct.byref(ierr),herr,3,255,255)

        return self._SETKTVdlloutput_tuple(ierr.value,trim(herr.raw))

    def SETMIXTUREdll(self,hMixNme):
        """
        z,ierr = SETMIXTUREdll(hMixNme)
        """
        hMixNme = ct.create_string_buffer(hMixNme.encode('utf-8'),10000)
        z = (20*ct.c_double)()
        ierr = ct.c_int()

        if self._SETMIXTUREdll is None: raise ValueError("The function SETMIXTUREdll could not be loaded from the shared library.") 
        self._SETMIXTUREdll(hMixNme,z,ct.byref(ierr),10000)

        return self._SETMIXTUREdlloutput_tuple(to_double_array(z),ierr.value)

    def SETMIXdll(self,hMixNme,hFmix,hrf):
        """
        ncc,hFiles,z,ierr,herr = SETMIXdll(hMixNme,hFmix,hrf)
        """
        hMixNme = ct.create_string_buffer(hMixNme.encode('utf-8'),255)
        hFmix = ct.create_string_buffer(hFmix.encode('utf-8'),255)
        hrf = ct.create_string_buffer(hrf.encode('utf-8'),3)
        ncc = ct.c_int()
        hFiles = ct.create_string_buffer(10000)
        z = (20*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SETMIXdll is None: raise ValueError("The function SETMIXdll could not be loaded from the shared library.") 
        self._SETMIXdll(hMixNme,hFmix,hrf,ct.byref(ncc),hFiles,z,ct.byref(ierr),herr,255,255,3,10000,255)

        return self._SETMIXdlloutput_tuple(ncc.value,trim(hFiles.raw),to_double_array(z),ierr.value,trim(herr.raw))

    def SETMODdll(self,ncomp,htype,hmix,hcomp):
        """
        ierr,herr = SETMODdll(ncomp,htype,hmix,hcomp)
        """
        ncomp = ct.c_int(ncomp)
        htype = ct.create_string_buffer(htype.encode('utf-8'),3)
        hmix = ct.create_string_buffer(hmix.encode('utf-8'),3)
        hcomp = ct.create_string_buffer(hcomp.encode('utf-8'),60)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SETMODdll is None: raise ValueError("The function SETMODdll could not be loaded from the shared library.") 
        self._SETMODdll(ct.byref(ncomp),htype,hmix,hcomp,ct.byref(ierr),herr,3,3,60,255)

        return self._SETMODdlloutput_tuple(ierr.value,trim(herr.raw))

    def SETNCdll(self,ncomp):
        """
         = SETNCdll(ncomp)
        """
        ncomp = ct.c_int(ncomp)

        if self._SETNCdll is None: raise ValueError("The function SETNCdll could not be loaded from the shared library.") 
        self._SETNCdll(ct.byref(ncomp))

        return

    def SETPATHdll(self,hpth):
        """
         = SETPATHdll(hpth)
        """
        hpth = ct.create_string_buffer(hpth.encode('utf-8'),255)

        if self._SETPATHdll is None: raise ValueError("The function SETPATHdll could not be loaded from the shared library.") 
        self._SETPATHdll(hpth,255)

        return

    def SETREFDIRdll(self,hpth):
        """
         = SETREFDIRdll(hpth)
        """
        hpth = ct.create_string_buffer(hpth.encode('utf-8'),255)

        if self._SETREFDIRdll is None: raise ValueError("The function SETREFDIRdll could not be loaded from the shared library.") 
        self._SETREFDIRdll(hpth,255)

        return

    def SETREFdll(self,hrf,ixflag,x0,h0,s0,T0,P0):
        """
        ierr,herr = SETREFdll(hrf,ixflag,x0,h0,s0,T0,P0)
        """
        hrf = ct.create_string_buffer(hrf.encode('utf-8'),3)
        ixflag = ct.c_int(ixflag)
        x0 = (len(x0)*ct.c_double)(*x0)
        h0 = ct.c_double(h0)
        s0 = ct.c_double(s0)
        T0 = ct.c_double(T0)
        P0 = ct.c_double(P0)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SETREFdll is None: raise ValueError("The function SETREFdll could not be loaded from the shared library.") 
        self._SETREFdll(hrf,ct.byref(ixflag),x0,ct.byref(h0),ct.byref(s0),ct.byref(T0),ct.byref(P0),ct.byref(ierr),herr,3,255)

        return self._SETREFdlloutput_tuple(ierr.value,trim(herr.raw))

    def SETUPdll(self,ncomp,hFiles,hFmix,hrf):
        """
        ierr,herr = SETUPdll(ncomp,hFiles,hFmix,hrf)
        """
        ncomp = ct.c_int(ncomp)
        hFiles = ct.create_string_buffer(hFiles.encode('utf-8'),10000)
        hFmix = ct.create_string_buffer(hFmix.encode('utf-8'),255)
        hrf = ct.create_string_buffer(hrf.encode('utf-8'),3)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SETUPdll is None: raise ValueError("The function SETUPdll could not be loaded from the shared library.") 
        self._SETUPdll(ct.byref(ncomp),hFiles,hFmix,hrf,ct.byref(ierr),herr,10000,255,3,255)

        return self._SETUPdlloutput_tuple(ierr.value,trim(herr.raw))

    def SPLNROOTdll(self,isp,iderv,f):
        """
        a,ierr,herr = SPLNROOTdll(isp,iderv,f)
        """
        isp = ct.c_int(isp)
        iderv = ct.c_int(iderv)
        f = ct.c_double(f)
        a = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SPLNROOTdll is None: raise ValueError("The function SPLNROOTdll could not be loaded from the shared library.") 
        self._SPLNROOTdll(ct.byref(isp),ct.byref(iderv),ct.byref(f),ct.byref(a),ct.byref(ierr),herr,255)

        return self._SPLNROOTdlloutput_tuple(a.value,ierr.value,trim(herr.raw))

    def SPLNVALdll(self,isp,iderv,a):
        """
        f,ierr,herr = SPLNVALdll(isp,iderv,a)
        """
        isp = ct.c_int(isp)
        iderv = ct.c_int(iderv)
        a = ct.c_double(a)
        f = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SPLNVALdll is None: raise ValueError("The function SPLNVALdll could not be loaded from the shared library.") 
        self._SPLNVALdll(ct.byref(isp),ct.byref(iderv),ct.byref(a),ct.byref(f),ct.byref(ierr),herr,255)

        return self._SPLNVALdlloutput_tuple(f.value,ierr.value,trim(herr.raw))

    def STNdll(self,T,Dl,Dv,x,y):
        """
        sigma,ierr,herr = STNdll(T,Dl,Dv,x,y)
        """
        T = ct.c_double(T)
        Dl = ct.c_double(Dl)
        Dv = ct.c_double(Dv)
        x = (len(x)*ct.c_double)(*x)
        y = (len(y)*ct.c_double)(*y)
        sigma = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._STNdll is None: raise ValueError("The function STNdll could not be loaded from the shared library.") 
        self._STNdll(ct.byref(T),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(sigma),ct.byref(ierr),herr,255)

        return self._STNdlloutput_tuple(sigma.value,ierr.value,trim(herr.raw))

    def SUBLPdll(self,P,z):
        """
        T,ierr,herr = SUBLPdll(P,z)
        """
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SUBLPdll is None: raise ValueError("The function SUBLPdll could not be loaded from the shared library.") 
        self._SUBLPdll(ct.byref(P),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._SUBLPdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def SUBLTdll(self,T,z):
        """
        P,ierr,herr = SUBLTdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        P = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SUBLTdll is None: raise ValueError("The function SUBLTdll could not be loaded from the shared library.") 
        self._SUBLTdll(ct.byref(T),z,ct.byref(P),ct.byref(ierr),herr,255)

        return self._SUBLTdlloutput_tuple(P.value,ierr.value,trim(herr.raw))

    def SURFTdll(self,T,Dl,z):
        """
        sigma,ierr,herr = SURFTdll(T,Dl,z)
        """
        T = ct.c_double(T)
        Dl = ct.c_double(Dl)
        z = (len(z)*ct.c_double)(*z)
        sigma = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SURFTdll is None: raise ValueError("The function SURFTdll could not be loaded from the shared library.") 
        self._SURFTdll(ct.byref(T),ct.byref(Dl),z,ct.byref(sigma),ct.byref(ierr),herr,255)

        return self._SURFTdlloutput_tuple(sigma.value,ierr.value,trim(herr.raw))

    def SURTENdll(self,T,Dl,Dv,x,y):
        """
        sigma,ierr,herr = SURTENdll(T,Dl,Dv,x,y)
        """
        T = ct.c_double(T)
        Dl = ct.c_double(Dl)
        Dv = ct.c_double(Dv)
        x = (len(x)*ct.c_double)(*x)
        y = (len(y)*ct.c_double)(*y)
        sigma = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._SURTENdll is None: raise ValueError("The function SURTENdll could not be loaded from the shared library.") 
        self._SURTENdll(ct.byref(T),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(sigma),ct.byref(ierr),herr,255)

        return self._SURTENdlloutput_tuple(sigma.value,ierr.value,trim(herr.raw))

    def TDFLSHdll(self,T,D,z):
        """
        P,Dl,Dv,x,y,q,e,h,s,Cv,Cp,w,ierr,herr = TDFLSHdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        P = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TDFLSHdll is None: raise ValueError("The function TDFLSHdll could not be loaded from the shared library.") 
        self._TDFLSHdll(ct.byref(T),ct.byref(D),z,ct.byref(P),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._TDFLSHdlloutput_tuple(P.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def TEFL1dll(self,T,e,z,Dmin,Dmax):
        """
        D,ierr,herr = TEFL1dll(T,e,z,Dmin,Dmax)
        """
        T = ct.c_double(T)
        e = ct.c_double(e)
        z = (len(z)*ct.c_double)(*z)
        Dmin = ct.c_double(Dmin)
        Dmax = ct.c_double(Dmax)
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TEFL1dll is None: raise ValueError("The function TEFL1dll could not be loaded from the shared library.") 
        self._TEFL1dll(ct.byref(T),ct.byref(e),z,ct.byref(Dmin),ct.byref(Dmax),ct.byref(D),ct.byref(ierr),herr,255)

        return self._TEFL1dlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def TEFLSHdll(self,T,e,z,kr):
        """
        P,D,Dl,Dv,x,y,q,h,s,Cv,Cp,w,ierr,herr = TEFLSHdll(T,e,z,kr)
        """
        T = ct.c_double(T)
        e = ct.c_double(e)
        z = (len(z)*ct.c_double)(*z)
        kr = ct.c_int(kr)
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TEFLSHdll is None: raise ValueError("The function TEFLSHdll could not be loaded from the shared library.") 
        self._TEFLSHdll(ct.byref(T),ct.byref(e),z,ct.byref(kr),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._TEFLSHdlloutput_tuple(P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def THERM0dll(self,T,D,z):
        """
        P0,e0,h0,s0,Cv0,Cp00,w0,a0,g0 = THERM0dll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        P0 = ct.c_double()
        e0 = ct.c_double()
        h0 = ct.c_double()
        s0 = ct.c_double()
        Cv0 = ct.c_double()
        Cp00 = ct.c_double()
        w0 = ct.c_double()
        a0 = ct.c_double()
        g0 = ct.c_double()

        if self._THERM0dll is None: raise ValueError("The function THERM0dll could not be loaded from the shared library.") 
        self._THERM0dll(ct.byref(T),ct.byref(D),z,ct.byref(P0),ct.byref(e0),ct.byref(h0),ct.byref(s0),ct.byref(Cv0),ct.byref(Cp00),ct.byref(w0),ct.byref(a0),ct.byref(g0))

        return self._THERM0dlloutput_tuple(P0.value,e0.value,h0.value,s0.value,Cv0.value,Cp00.value,w0.value,a0.value,g0.value)

    def THERM2dll(self,T,D,z):
        """
        P,e,h,s,Cv,Cp,w,zz,hjt,a,g,xkappa,beta,dPdD,d2PdD2,dPdT,dDdT,dDdP,d2PdT2,d2PdTD,spare3,spare4 = THERM2dll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        P = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        zz = ct.c_double()
        hjt = ct.c_double()
        a = ct.c_double()
        g = ct.c_double()
        xkappa = ct.c_double()
        beta = ct.c_double()
        dPdD = ct.c_double()
        d2PdD2 = ct.c_double()
        dPdT = ct.c_double()
        dDdT = ct.c_double()
        dDdP = ct.c_double()
        d2PdT2 = ct.c_double()
        d2PdTD = ct.c_double()
        spare3 = ct.c_double()
        spare4 = ct.c_double()

        if self._THERM2dll is None: raise ValueError("The function THERM2dll could not be loaded from the shared library.") 
        self._THERM2dll(ct.byref(T),ct.byref(D),z,ct.byref(P),ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(zz),ct.byref(hjt),ct.byref(a),ct.byref(g),ct.byref(xkappa),ct.byref(beta),ct.byref(dPdD),ct.byref(d2PdD2),ct.byref(dPdT),ct.byref(dDdT),ct.byref(dDdP),ct.byref(d2PdT2),ct.byref(d2PdTD),ct.byref(spare3),ct.byref(spare4))

        return self._THERM2dlloutput_tuple(P.value,e.value,h.value,s.value,Cv.value,Cp.value,w.value,zz.value,hjt.value,a.value,g.value,xkappa.value,beta.value,dPdD.value,d2PdD2.value,dPdT.value,dDdT.value,dDdP.value,d2PdT2.value,d2PdTD.value,spare3.value,spare4.value)

    def THERM3dll(self,T,D,z):
        """
        xkappa,beta,xisenk,xkt,betas,bs,xkkt,thrott,pi,spht = THERM3dll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        xkappa = ct.c_double()
        beta = ct.c_double()
        xisenk = ct.c_double()
        xkt = ct.c_double()
        betas = ct.c_double()
        bs = ct.c_double()
        xkkt = ct.c_double()
        thrott = ct.c_double()
        pi = ct.c_double()
        spht = ct.c_double()

        if self._THERM3dll is None: raise ValueError("The function THERM3dll could not be loaded from the shared library.") 
        self._THERM3dll(ct.byref(T),ct.byref(D),z,ct.byref(xkappa),ct.byref(beta),ct.byref(xisenk),ct.byref(xkt),ct.byref(betas),ct.byref(bs),ct.byref(xkkt),ct.byref(thrott),ct.byref(pi),ct.byref(spht))

        return self._THERM3dlloutput_tuple(xkappa.value,beta.value,xisenk.value,xkt.value,betas.value,bs.value,xkkt.value,thrott.value,pi.value,spht.value)

    def THERMdll(self,T,D,z):
        """
        P,e,h,s,Cv,Cp,w,hjt = THERMdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        P = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        hjt = ct.c_double()

        if self._THERMdll is None: raise ValueError("The function THERMdll could not be loaded from the shared library.") 
        self._THERMdll(ct.byref(T),ct.byref(D),z,ct.byref(P),ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(hjt))

        return self._THERMdlloutput_tuple(P.value,e.value,h.value,s.value,Cv.value,Cp.value,w.value,hjt.value)

    def THFL1dll(self,T,h,z,Dmin,Dmax):
        """
        D,ierr,herr = THFL1dll(T,h,z,Dmin,Dmax)
        """
        T = ct.c_double(T)
        h = ct.c_double(h)
        z = (len(z)*ct.c_double)(*z)
        Dmin = ct.c_double(Dmin)
        Dmax = ct.c_double(Dmax)
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._THFL1dll is None: raise ValueError("The function THFL1dll could not be loaded from the shared library.") 
        self._THFL1dll(ct.byref(T),ct.byref(h),z,ct.byref(Dmin),ct.byref(Dmax),ct.byref(D),ct.byref(ierr),herr,255)

        return self._THFL1dlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def THFLSHdll(self,T,h,z,kr):
        """
        P,D,Dl,Dv,x,y,q,e,s,Cv,Cp,w,ierr,herr = THFLSHdll(T,h,z,kr)
        """
        T = ct.c_double(T)
        h = ct.c_double(h)
        z = (len(z)*ct.c_double)(*z)
        kr = ct.c_int(kr)
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._THFLSHdll is None: raise ValueError("The function THFLSHdll could not be loaded from the shared library.") 
        self._THFLSHdll(ct.byref(T),ct.byref(h),z,ct.byref(kr),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._THFLSHdlloutput_tuple(P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def TPFL2dll(self,T,P,z):
        """
        Dl,Dv,x,y,q,ierr,herr = TPFL2dll(T,P,z)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TPFL2dll is None: raise ValueError("The function TPFL2dll could not be loaded from the shared library.") 
        self._TPFL2dll(ct.byref(T),ct.byref(P),z,ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(ierr),herr,255)

        return self._TPFL2dlloutput_tuple(Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,ierr.value,trim(herr.raw))

    def TPFLSHdll(self,T,P,z):
        """
        D,Dl,Dv,x,y,q,e,h,s,Cv,Cp,w,ierr,herr = TPFLSHdll(T,P,z)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TPFLSHdll is None: raise ValueError("The function TPFLSHdll could not be loaded from the shared library.") 
        self._TPFLSHdll(ct.byref(T),ct.byref(P),z,ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._TPFLSHdlloutput_tuple(D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def TPRHOPRdll(self,T,P,z):
        """
        D1,D2 = TPRHOPRdll(T,P,z)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        D1 = ct.c_double()
        D2 = ct.c_double()

        if self._TPRHOPRdll is None: raise ValueError("The function TPRHOPRdll could not be loaded from the shared library.") 
        self._TPRHOPRdll(ct.byref(T),ct.byref(P),z,ct.byref(D1),ct.byref(D2))

        return self._TPRHOPRdlloutput_tuple(D1.value,D2.value)

    def TPRHOdll(self,T,P,z,kph,kguess,D):
        """
        D,ierr,herr = TPRHOdll(T,P,z,kph,kguess,D)
        """
        T = ct.c_double(T)
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        kph = ct.c_int(kph)
        kguess = ct.c_int(kguess)
        D = ct.c_double(D)
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TPRHOdll is None: raise ValueError("The function TPRHOdll could not be loaded from the shared library.") 
        self._TPRHOdll(ct.byref(T),ct.byref(P),z,ct.byref(kph),ct.byref(kguess),ct.byref(D),ct.byref(ierr),herr,255)

        return self._TPRHOdlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def TQFLSHdll(self,T,q,z,kq):
        """
        P,D,Dl,Dv,x,y,e,h,s,Cv,Cp,w,ierr,herr = TQFLSHdll(T,q,z,kq)
        """
        T = ct.c_double(T)
        q = ct.c_double(q)
        z = (len(z)*ct.c_double)(*z)
        kq = ct.c_int(kq)
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        e = ct.c_double()
        h = ct.c_double()
        s = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TQFLSHdll is None: raise ValueError("The function TQFLSHdll could not be loaded from the shared library.") 
        self._TQFLSHdll(ct.byref(T),ct.byref(q),z,ct.byref(kq),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(e),ct.byref(h),ct.byref(s),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._TQFLSHdlloutput_tuple(P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),e.value,h.value,s.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def TRNPRPdll(self,T,D,z):
        """
        eta,tcx,ierr,herr = TRNPRPdll(T,D,z)
        """
        T = ct.c_double(T)
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        eta = ct.c_double()
        tcx = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TRNPRPdll is None: raise ValueError("The function TRNPRPdll could not be loaded from the shared library.") 
        self._TRNPRPdll(ct.byref(T),ct.byref(D),z,ct.byref(eta),ct.byref(tcx),ct.byref(ierr),herr,255)

        return self._TRNPRPdlloutput_tuple(eta.value,tcx.value,ierr.value,trim(herr.raw))

    def TSATDdll(self,D,z):
        """
        T,ierr,herr = TSATDdll(D,z)
        """
        D = ct.c_double(D)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TSATDdll is None: raise ValueError("The function TSATDdll could not be loaded from the shared library.") 
        self._TSATDdll(ct.byref(D),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._TSATDdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def TSATPdll(self,P,z):
        """
        T,ierr,herr = TSATPdll(P,z)
        """
        P = ct.c_double(P)
        z = (len(z)*ct.c_double)(*z)
        T = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TSATPdll is None: raise ValueError("The function TSATPdll could not be loaded from the shared library.") 
        self._TSATPdll(ct.byref(P),z,ct.byref(T),ct.byref(ierr),herr,255)

        return self._TSATPdlloutput_tuple(T.value,ierr.value,trim(herr.raw))

    def TSFL1dll(self,T,s,z,Dmin,Dmax):
        """
        D,ierr,herr = TSFL1dll(T,s,z,Dmin,Dmax)
        """
        T = ct.c_double(T)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        Dmin = ct.c_double(Dmin)
        Dmax = ct.c_double(Dmax)
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TSFL1dll is None: raise ValueError("The function TSFL1dll could not be loaded from the shared library.") 
        self._TSFL1dll(ct.byref(T),ct.byref(s),z,ct.byref(Dmin),ct.byref(Dmax),ct.byref(D),ct.byref(ierr),herr,255)

        return self._TSFL1dlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def TSFLSHdll(self,T,s,z,kr):
        """
        P,D,Dl,Dv,x,y,q,e,h,Cv,Cp,w,ierr,herr = TSFLSHdll(T,s,z,kr)
        """
        T = ct.c_double(T)
        s = ct.c_double(s)
        z = (len(z)*ct.c_double)(*z)
        kr = ct.c_int(kr)
        P = ct.c_double()
        D = ct.c_double()
        Dl = ct.c_double()
        Dv = ct.c_double()
        x = (20*ct.c_double)()
        y = (20*ct.c_double)()
        q = ct.c_double()
        e = ct.c_double()
        h = ct.c_double()
        Cv = ct.c_double()
        Cp = ct.c_double()
        w = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._TSFLSHdll is None: raise ValueError("The function TSFLSHdll could not be loaded from the shared library.") 
        self._TSFLSHdll(ct.byref(T),ct.byref(s),z,ct.byref(kr),ct.byref(P),ct.byref(D),ct.byref(Dl),ct.byref(Dv),x,y,ct.byref(q),ct.byref(e),ct.byref(h),ct.byref(Cv),ct.byref(Cp),ct.byref(w),ct.byref(ierr),herr,255)

        return self._TSFLSHdlloutput_tuple(P.value,D.value,Dl.value,Dv.value,to_double_array(x),to_double_array(y),q.value,e.value,h.value,Cv.value,Cp.value,w.value,ierr.value,trim(herr.raw))

    def UNSETAGAdll(self,):
        """
         = UNSETAGAdll()
        """

        if self._UNSETAGAdll is None: raise ValueError("The function UNSETAGAdll could not be loaded from the shared library.") 
        self._UNSETAGAdll()

        return

    def VAPSPNDLdll(self,T,z):
        """
        D,ierr,herr = VAPSPNDLdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        D = ct.c_double()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._VAPSPNDLdll is None: raise ValueError("The function VAPSPNDLdll could not be loaded from the shared library.") 
        self._VAPSPNDLdll(ct.byref(T),z,ct.byref(D),ct.byref(ierr),herr,255)

        return self._VAPSPNDLdlloutput_tuple(D.value,ierr.value,trim(herr.raw))

    def VIRBAdll(self,T,z):
        """
        Ba = VIRBAdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        Ba = ct.c_double()

        if self._VIRBAdll is None: raise ValueError("The function VIRBAdll could not be loaded from the shared library.") 
        self._VIRBAdll(ct.byref(T),z,ct.byref(Ba))

        return Ba.value

    def VIRBCD12dll(self,T,z,iFlag):
        """
        B,C,D,E = VIRBCD12dll(T,z,iFlag)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        iFlag = ct.c_int(iFlag)
        B = (6*ct.c_double)()
        C = (6*ct.c_double)()
        D = (6*ct.c_double)()
        E = (6*ct.c_double)()

        if self._VIRBCD12dll is None: raise ValueError("The function VIRBCD12dll could not be loaded from the shared library.") 
        self._VIRBCD12dll(ct.byref(T),z,ct.byref(iFlag),B,C,D,E)

        return self._VIRBCD12dlloutput_tuple(to_double_array(B),to_double_array(C),to_double_array(D),to_double_array(E))

    def VIRBCDdll(self,T,z):
        """
        B,C,D,E = VIRBCDdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        B = ct.c_double()
        C = ct.c_double()
        D = ct.c_double()
        E = ct.c_double()

        if self._VIRBCDdll is None: raise ValueError("The function VIRBCDdll could not be loaded from the shared library.") 
        self._VIRBCDdll(ct.byref(T),z,ct.byref(B),ct.byref(C),ct.byref(D),ct.byref(E))

        return self._VIRBCDdlloutput_tuple(B.value,C.value,D.value,E.value)

    def VIRBdll(self,T,z):
        """
        B = VIRBdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        B = ct.c_double()

        if self._VIRBdll is None: raise ValueError("The function VIRBdll could not be loaded from the shared library.") 
        self._VIRBdll(ct.byref(T),z,ct.byref(B))

        return B.value

    def VIRCAdll(self,T,z):
        """
        Ca = VIRCAdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        Ca = ct.c_double()

        if self._VIRCAdll is None: raise ValueError("The function VIRCAdll could not be loaded from the shared library.") 
        self._VIRCAdll(ct.byref(T),z,ct.byref(Ca))

        return Ca.value

    def VIRCdll(self,T,z):
        """
        C = VIRCdll(T,z)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        C = ct.c_double()

        if self._VIRCdll is None: raise ValueError("The function VIRCdll could not be loaded from the shared library.") 
        self._VIRCdll(ct.byref(T),z,ct.byref(C))

        return C.value

    def VIRTAUdll(self,T,z,iFlag):
        """
        BTau,CTau,DTau,ETau,ierr,herr = VIRTAUdll(T,z,iFlag)
        """
        T = ct.c_double(T)
        z = (len(z)*ct.c_double)(*z)
        iFlag = ct.c_int(iFlag)
        BTau = (6*ct.c_double)()
        CTau = (6*ct.c_double)()
        DTau = (6*ct.c_double)()
        ETau = (6*ct.c_double)()
        ierr = ct.c_int()
        herr = ct.create_string_buffer(255)

        if self._VIRTAUdll is None: raise ValueError("The function VIRTAUdll could not be loaded from the shared library.") 
        self._VIRTAUdll(ct.byref(T),z,ct.byref(iFlag),BTau,CTau,DTau,ETau,ct.byref(ierr),herr,255)

        return self._VIRTAUdlloutput_tuple(to_double_array(BTau),to_double_array(CTau),to_double_array(DTau),to_double_array(ETau),ierr.value,trim(herr.raw))

    def WMOLIdll(self,icomp):
        """
        wmm = WMOLIdll(icomp)
        """
        icomp = ct.c_int(icomp)
        wmm = ct.c_double()

        if self._WMOLIdll is None: raise ValueError("The function WMOLIdll could not be loaded from the shared library.") 
        self._WMOLIdll(ct.byref(icomp),ct.byref(wmm))

        return wmm.value

    def WMOLdll(self,z):
        """
        wmm = WMOLdll(z)
        """
        z = (len(z)*ct.c_double)(*z)
        wmm = ct.c_double()

        if self._WMOLdll is None: raise ValueError("The function WMOLdll could not be loaded from the shared library.") 
        self._WMOLdll(z,ct.byref(wmm))

        return wmm.value

    def XMASSdll(self,xmol):
        """
        xkg,wmix = XMASSdll(xmol)
        """
        xmol = (len(xmol)*ct.c_double)(*xmol)
        xkg = (20*ct.c_double)()
        wmix = ct.c_double()

        if self._XMASSdll is None: raise ValueError("The function XMASSdll could not be loaded from the shared library.") 
        self._XMASSdll(xmol,xkg,ct.byref(wmix))

        return self._XMASSdlloutput_tuple(to_double_array(xkg),wmix.value)

    def XMOLEdll(self,xkg):
        """
        xmol,wmix = XMOLEdll(xkg)
        """
        xkg = (len(xkg)*ct.c_double)(*xkg)
        xmol = (20*ct.c_double)()
        wmix = ct.c_double()

        if self._XMOLEdll is None: raise ValueError("The function XMOLEdll could not be loaded from the shared library.") 
        self._XMOLEdll(xkg,xmol,ct.byref(wmix))

        return self._XMOLEdlloutput_tuple(to_double_array(xmol),wmix.value)




    def RPVersion(self):
        """ Replace the normal implementation of RPVersion to get the semantic versioned 
        version from REFPROPdll function to support getting version from 10.0.0 

        Falls back to old implementation for REFPROP < 10.0.0
        """
        if self._REFPROPdll is not None:
            return self.REFPROPdll('','','DLL#',0,0,0,0,0,[1.0]).hUnits
        else:
            hv = ct.create_string_buffer(255)
            if self._RPVersion is None: raise ValueError("The function RPVersion could not be loaded from the shared library.")
            self._RPVersion(hv,255)
            return trim(hv.raw)
