#include "windows.h"
#include "hbapi.h"

#define DllImport  extern  __declspec(dllimport)

DllImport int __stdcall Bematech_FI_RetornoImpressora (short* ACK, short* ST1, short* ST2);
DllImport int __stdcall Bematech_FI_RetornoImpressoraMFD (short* ACK, short* ST1, short* ST2, short* ST3);
DllImport int __stdcall Bematech_FI_DataHoraImpressora (char* Data, char* Hora);
DllImport int __stdcall Bematech_FI_AlteraSimboloMoeda (char* Moeda);
DllImport int __stdcall Bematech_FI_VerificaEstadoImpressora (short int* ACK,short int* ST1,short int* ST2);
DllImport int __stdcall Bematech_FI_NumeroSerie (char* NumeroSerie);
//DllImport int __stdcall Bematech_FI_NumeroSeriemfd (char* NumeroSerie);
DllImport int __stdcall Bematech_FI_DadosSintegra (char* DataInicial, char* DataFinal);
DllImport int __stdcall Bematech_FI_VerificaRecebimentoNaoFiscal (char* Recebimentos);
DllImport int __stdcall Bematech_FI_VerificaFormasPagamento( char* forma );

//typedef int (WINAPI * _BEMATECH_FI_DOWNLOADMFD)(char* nomearq, char* tipodown, char* intini,char* intfin, char* numecf);
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMAALIQUOTA)( LPSTR Aliquota , INT  ICMS_ISS  );
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMAHORARIOVERAO)( void );
typedef INT (WINAPI * _BEMATECH_FI_NOMEIADEPARTAMENTO)( INT Indice , LPSTR  Departamento  );
typedef INT (WINAPI * _BEMATECH_FI_NOMEIATOTALIZADORNAOSUJEITOICMS)( INT Indice , LPSTR  Totalizador  );
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMAARREDONDAMENTO)( void );
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMATRUNCAMENTO)( void );
typedef INT (WINAPI * _BEMATECH_FI_LINHASENTRECUPONS)( INT Linha  );
typedef INT (WINAPI * _BEMATECH_FI_ESPACOENTRELINHAS)( INT Dots  );
typedef INT (WINAPI * _BEMATECH_FI_FORCAIMPACTOAGULHAS)( INT ForcaImpacto  );
typedef INT (WINAPI * _BEMATECH_FI_ABRECUPOM)( LPSTR CGC_CPF  );
typedef INT (WINAPI * _BEMATECH_FI_VENDEITEMDEPARTAMENTO)( LPSTR Codigo , LPSTR  Descricao , LPSTR  Aliquota , LPSTR  ValorUnitario , LPSTR  Quantidade , LPSTR  Acrescimo , LPSTR  Desconto , LPSTR  IndiceDepartamento , LPSTR  UnidadeMedida  );
typedef INT (WINAPI * _BEMATECH_FI_CANCELAITEMANTERIOR)( void );
typedef INT (WINAPI * _BEMATECH_FI_CANCELAITEMGENERICO)( LPSTR NumeroItem  );
typedef INT (WINAPI * _BEMATECH_FI_CANCELACUPOM)( void );
typedef INT (WINAPI * _BEMATECH_FI_FECHACUPOMRESUMIDO)( LPSTR FormaPagamento , LPSTR  Mensagem  );
typedef INT (WINAPI * _BEMATECH_FI_FECHACUPOM)( LPSTR FormaPagamento , LPSTR  AcrescimoDesconto , LPSTR  TipoAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto , LPSTR  ValorPago , LPSTR  Mensagem  );
typedef INT (WINAPI * _BEMATECH_FI_RESETAIMPRESSORA)( void );
typedef INT (WINAPI * _BEMATECH_FI_EFETUAFORMAPAGAMENTO)( LPSTR FormaPagamento , LPSTR  ValorFormaPagamento  );
typedef INT (WINAPI * _BEMATECH_FI_EFETUAFORMAPAGAMENTODESCRICAOFORMA)( LPSTR FormaPagamento , LPSTR  ValorFormaPagamento , LPSTR  DescricaoFormaPagto  );
typedef INT (WINAPI * _BEMATECH_FI_TERMINAFECHAMENTOCUPOM)( LPSTR Mensagem  );
typedef INT (WINAPI * _BEMATECH_FI_ESTORNOFORMASPAGAMENTO)( LPSTR FormaOrigem , LPSTR  FormaDestino , LPSTR  Valor  );
typedef INT (WINAPI * _BEMATECH_FI_USAUNIDADEMEDIDA)( LPSTR UnidadeMedida  );
typedef INT (WINAPI * _BEMATECH_FI_AUMENTADESCRICAOITEM)( LPSTR Descricao  );
typedef INT (WINAPI * _BEMATECH_FI_LEITURAX)( void );
typedef INT (WINAPI * _BEMATECH_FI_REDUCAOZ)( LPSTR Data , LPSTR  Hora  );
typedef INT (WINAPI * _BEMATECH_FI_RELATORIOGERENCIAL)( LPSTR Texto  );
typedef INT (WINAPI * _BEMATECH_FI_FECHARELATORIOGERENCIAL)( void );
typedef INT (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALDATA)( LPSTR DataInicial , LPSTR  DataFinal  );
typedef INT (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAO)( LPSTR ReducaoInicial , LPSTR  ReducaoFinal  );
typedef INT (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALDATA)( LPSTR DataInicial , LPSTR  DataFinal  );
typedef INT (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALREDUCAO)( LPSTR ReducaoInicial , LPSTR  ReducaoFinal  );
typedef INT (WINAPI * _BEMATECH_FI_RECEBIMENTONAOFISCAL)( LPSTR IndiceTotalizador , LPSTR  Valor , LPSTR  FormaPagamento  );
typedef INT (WINAPI * _BEMATECH_FI_ABRECOMPROVANTENAOFISCALVINCULADO)( LPSTR FormaPagamento , LPSTR  Valor , LPSTR  NumeroCupom  );
typedef INT (WINAPI * _BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADO)( LPSTR Texto  );
typedef INT (WINAPI * _BEMATECH_FI_FECHACOMPROVANTENAOFISCALVINCULADO)( void );
typedef INT (WINAPI * _BEMATECH_FI_SANGRIA)( LPSTR Valor  );
typedef INT (WINAPI * _BEMATECH_FI_SUPRIMENTO)( LPSTR Valor , LPSTR  FormaPagamento  );
//typedef INT (WINAPI * _BEMATECH_FI_NUMEROSERIE)( LPSTR NumeroSerie  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROSERIEMFD)( LPSTR NumeroSerie  );
typedef INT (WINAPI * _BEMATECH_FI_VENDABRUTA)( LPSTR VendaBruta  );
typedef INT (WINAPI * _BEMATECH_FI_SUBTOTAL)( LPSTR SubTotal  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROCUPOM)( LPSTR NumeroCupom  );
typedef INT (WINAPI * _BEMATECH_FI_LEITURAXSERIAL)( void );
typedef INT (WINAPI * _BEMATECH_FI_VERSAOFIRMWARE)( LPSTR VersaoFirmware  );
typedef INT (WINAPI * _BEMATECH_FI_CGC_IE)( LPSTR CGC , LPSTR  IE  );
typedef INT (WINAPI * _BEMATECH_FI_GRANDETOTAL)( LPSTR GrandeTotal  );
typedef INT (WINAPI * _BEMATECH_FI_CANCELAMENTOS)( LPSTR ValorCancelamentos  );
typedef INT (WINAPI * _BEMATECH_FI_DESCONTOS)( LPSTR ValorDescontos  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROOPERACOESNAOFISCAIS)( LPSTR NumeroOperacoes  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROCUPONSCANCELADOS)( LPSTR NumeroCancelamentos  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROINTERVENCOES)( LPSTR NumeroIntervencoes  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROREDUCOES)( LPSTR NumeroReducoes  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROSUBSTITUICOESPROPRIETARIO)( LPSTR NumeroSubstituicoes  );
typedef INT (WINAPI * _BEMATECH_FI_ULTIMOITEMVENDIDO)( LPSTR NumeroItem  );
typedef INT (WINAPI * _BEMATECH_FI_CLICHEPROPRIETARIO)( LPSTR Cliche  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROCAIXA)( LPSTR NumeroCaixa  );
typedef INT (WINAPI * _BEMATECH_FI_NUMEROLOJA)( LPSTR NumeroLoja  );
typedef INT (WINAPI * _BEMATECH_FI_SIMBOLOMOEDA)( LPSTR SimboloMoeda  );
typedef INT (WINAPI * _BEMATECH_FI_MINUTOSLIGADA)( LPSTR Minutos  );
typedef INT (WINAPI * _BEMATECH_FI_MINUTOSIMPRIMINDO)( LPSTR Minutos  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAMODOOPERACAO)( LPSTR Modo  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAEPROMCONECTADA)( LPSTR Flag  );
typedef INT (WINAPI * _BEMATECH_FI_VALORPAGOULTIMOCUPOM)( LPSTR ValorCupom  );
typedef INT (WINAPI * _BEMATECH_FI_DATAHORAIMPRESSORA)( LPSTR Data , LPSTR  Hora  );
typedef INT (WINAPI * _BEMATECH_FI_CONTADORESTOTALIZADORESNAOFISCAIS)( LPSTR Contadores  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICATOTALIZADORESNAOFISCAIS)( LPSTR Totalizadores  );
typedef INT (WINAPI * _BEMATECH_FI_DATAHORAREDUCAO)( LPSTR Data , LPSTR  Hora  );
//typedef INT (WINAPI * _BEMATECH_FI_DATAMOVIMENTO)( LPSTR Data  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICATRUNCAMENTO)( LPSTR Flag  );
typedef INT (WINAPI * _BEMATECH_FI_ACRESCIMOS)( LPSTR ValorAcrescimos  );
typedef INT (WINAPI * _BEMATECH_FI_CONTADORBILHETEPASSAGEM)( LPSTR ContadorPa  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAALIQUOTAISS)( LPSTR Flag  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAFORMASPAGAMENTO)( LPSTR Forma  );
//typedef INT (WINAPI * _BEMATECH_FI_VERIFICARECEBIMENTONAOFISCAL)( LPSTR Recebimentos  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICADEPARTAMENTOS)( LPSTR Departamentos  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICATIPOIMPRESSORA)( INT TipoImpressora  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICATOTALIZADORESPARCIAIS)( LPSTR Totalizadores  );
typedef INT (WINAPI * _BEMATECH_FI_RETORNOALIQUOTAS)( LPSTR Aliquota  );
typedef INT (WINAPI * _BEMATECH_FI_DADOSULTIMAREDUCAO)( char* DadosReducao  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAINDICEALIQUOTASISS)( LPSTR Flag  );
typedef INT (WINAPI * _BEMATECH_FI_VALORFORMAPAGAMENTO)( LPSTR FormaPagamento , LPSTR  Valor  );
typedef INT (WINAPI * _BEMATECH_FI_VALORTOTALIZADORNAOFISCAL)( LPSTR Totalizador , LPSTR  Valor  );
typedef INT (WINAPI * _BEMATECH_FI_AUTENTICACAO)( void );
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMACARACTERAUTENTICACAO)( LPSTR Parametros  );
typedef INT (WINAPI * _BEMATECH_FI_ACIONAGAVETA)( void );
typedef INT (WINAPI * _BEMATECH_FIR_ABRECUPOMRESTAURANTE)( LPSTR Mesa , LPSTR  CGC_CPF  );
typedef INT (WINAPI * _BEMATECH_FIR_REGISTRAVENDA)( LPSTR Mesa , LPSTR  Codigo , LPSTR  Descricao , LPSTR  Aliquota , LPSTR  Quantidade , LPSTR  ValorUnitario , LPSTR  FlagAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto  );
typedef INT (WINAPI * _BEMATECH_FIR_CANCELAVENDA)( LPSTR Mesa , LPSTR  Codigo , LPSTR  Descricao , LPSTR  Aliquota , LPSTR  Quantidade , LPSTR  ValorUnitario , LPSTR  FlagAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto  );
typedef INT (WINAPI * _BEMATECH_FIR_CONFERENCIAMESA)( LPSTR Mesa , LPSTR  FlagAcrescimoDesconto , LPSTR  TipoAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto  );
typedef INT (WINAPI * _BEMATECH_FIR_ABRECONFERENCIAMESA)( LPSTR Mesa  );
typedef INT (WINAPI * _BEMATECH_FIR_FECHACONFERENCIAMESA)( LPSTR FlagAcrescimoDesconto , LPSTR  TipoAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto  );
typedef INT (WINAPI * _BEMATECH_FIR_TRANSFERENCIAMESA)( LPSTR MesaOrigem , LPSTR  MesaDestino  );
typedef INT (WINAPI * _BEMATECH_FIR_CONTADIVIDIDA)( LPSTR NumeroCup , LPSTR  ValorPago , LPSTR  CGC_CPF  );
typedef INT (WINAPI * _BEMATECH_FIR_FECHACUPOMCONTADIVIDIDA)( LPSTR NumeroCupons , LPSTR  FlagAcrescimoDesconto , LPSTR  TipoAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto , LPSTR  FormaPagamento , LPSTR  ValorFormaPagamento , LPSTR  ValorPagoCliente , LPSTR  CGC_CPF  );
typedef INT (WINAPI * _BEMATECH_FIR_TRANSFERENCIAITEM)( LPSTR MesaOrigem , LPSTR  Codigo , LPSTR  Descricao , LPSTR  Aliquota , LPSTR  Quantidade , LPSTR  ValorUnitario , LPSTR  FlagAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto , LPSTR  MesaDestino  );
typedef INT (WINAPI * _BEMATECH_FIR_RELATORIOMESASABERTAS)( INT TipoRelatorio  );
typedef INT (WINAPI * _BEMATECH_FIR_IMPRIMECARDAPIO)( void );
typedef INT (WINAPI * _BEMATECH_FIR_RELATORIOMESASABERTASSERIAL)( void );
typedef INT (WINAPI * _BEMATECH_FIR_CARDAPIOPELASERIAL)( void );
typedef INT (WINAPI * _BEMATECH_FIR_REGISTROVENDASERIAL)( LPSTR Mesa  );
typedef INT (WINAPI * _BEMATECH_FIR_VERIFICAMEMORIALIVRE)( LPSTR Bytes  );
typedef INT (WINAPI * _BEMATECH_FIR_FECHACUPOMRESTAURANTE)( LPSTR FormaPagamento , LPSTR  FlagAcrescimoDesconto , LPSTR  TipoAcrescimoDesconto , LPSTR  ValorAcrescimoDesconto , LPSTR  ValorFormaPagto , LPSTR  Mensagem  );
typedef INT (WINAPI * _BEMATECH_FIR_FECHACUPOMRESUMIDORESTAURANTE)( LPSTR FormaPagamento , LPSTR  Mensagem  );
typedef INT (WINAPI * _BEMATECH_FI_ABREBILHETEPASSAGEM)( LPSTR ImprimeValorFinal , LPSTR  ImprimeEnfatizado , LPSTR  Embarque , LPSTR  Destino , LPSTR  Linha , LPSTR  Prefixo , LPSTR  Agente , LPSTR  Agencia , LPSTR  Data , LPSTR  Hora , LPSTR  Poltrona , LPSTR  Plataforma  );
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMAMOEDASINGULAR)( LPSTR MoedaSingular  );
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMAMOEDAPLURAL)( LPSTR MoedaPlural  );
typedef INT (WINAPI * _BEMATECH_FI_CANCELAIMPRESSAOCHEQUE)( void );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICASTATUSCHEQUE)( INT StatusCheque  );
typedef INT (WINAPI * _BEMATECH_FI_IMPRIMECHEQUE)( LPSTR Banco , LPSTR  Valor , LPSTR  Favorecido , LPSTR  Cidade , LPSTR  Data , LPSTR  Mensagem  );
typedef INT (WINAPI * _BEMATECH_FI_INCLUICIDADEFAVORECIDO)( LPSTR Cidade , LPSTR  Favorecido  );
typedef INT (WINAPI * _BEMATECH_FI_IMPRIMECOPIACHEQUE)( void );
typedef INT (WINAPI * _BEMATECH_FI_ABREPORTASERIAL)( void );
typedef INT (WINAPI * _BEMATECH_FI_FECHAPORTASERIAL)( void );
typedef INT (WINAPI * _BEMATECH_FI_MAPARESUMOAS)( void );
typedef INT (WINAPI * _BEMATECH_FI_ABERTURADODIA)( LPSTR ValorCompra , LPSTR  FormaPagamento  );
typedef INT (WINAPI * _BEMATECH_FI_FECHAMENTODODIA)( void );
typedef INT (WINAPI * _BEMATECH_FI_IMPRIMECONFIGURACOESIMPRESSORA)( void );
typedef INT (WINAPI * _BEMATECH_FI_IMPRIMEDEPARTAMENTOS)( void );
typedef INT (WINAPI * _BEMATECH_FI_RELATORIOTIPO60ANALITICO)( void );
typedef INT (WINAPI * _BEMATECH_FI_RELATORIOTIPO60MESTRE)( void );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAIMPRESSORALIGADA)( void );
typedef INT (WINAPI * _BEMATECH_FI_LEARQUIVORETORNO)( LPSTR sRetorno  );
typedef INT (WINAPI * _BEMATECH_FI_FECHARELATORIOXOUZ)( void );

typedef INT (WINAPI * _BEMATECH_FI_VERIFICAESTADOIMPRESSORA) (short int* ACK,short int* ST1,short int* ST2);
typedef INT (WINAPI * _BEMATECH_FI_MONITORAMENTOPAPEL) (int* LinhasImpressas);
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAESTADOGAVETA )(short int* Estado);
typedef INT (WINAPI * _BEMATECH_FI_RETORNOIMPRESSORA )(int* ACK, int* ST1, int* ST2);
typedef INT (WINAPI * _BEMATECH_FI_RETORNOIMPRESSORAMFD )(int* ACK, int* ST1, int* ST2, int* ST3);
typedef INT (WINAPI * _BEMATECH_FI_FLAGSFISCAIS )(int* Flag);
typedef INT (WINAPI * _BEMATECH_FI_VENDEITEM )(char* Codigo, char* Descricao, char* Aliquota, char* TipoQuantidade, char* Quantidade, int CasasDecimais, char* ValorUnitario, char* TipoDesconto, char* ValorDesconto);
typedef INT (WINAPI * _BEMATECH_FI_INICIAFECHAMENTOCUPOM) (char* AcrescimoDesconto, char* TipoAcrescimoDesconto, char* ValorAcrescimoDesconto);
//typedef INT (WINAPI * _BEMATECH_FI_RETORNOALIQUOTAS) (char* Aliquotas);
typedef INT (WINAPI * _BEMATECH_FI_INICIAMODOTEF)( void );
typedef INT (WINAPI * _BEMATECH_FI_FINALIZAMODOTEF)( void );
typedef INT (WINAPI * _BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADOTEF)( LPSTR Texto  );
typedef INT (WINAPI * _BEMATECH_FI_RELATORIOGERENCIALTEF)( LPSTR Texto  );
typedef INT (WINAPI * _BEMATECH_FI_VERIFICAREDUCAOZAUTOMATICA)( short* Flag );
//typedef INT (WINAPI * _BEMATECH_FI_DADOSSINTEGRA)( LPSTR DataInicial, LPSTR DataFinal );
//typedef INT (WINAPI * _BEMATECH_FI_VENDEITEMARREDONDAMENTOMFD )(char* Codigo, char* Descricao, char* Aliquota, char* Unidade, char* Quantidade, char * ValorUnitario, char* ValorAcrescimo, char* ValorDesconto, BOOL arredonda);
typedef INT (WINAPI * _BEMATECH_FI_ACIONAGUILHOTINAMFD)(int* TipoCorte);
typedef INT (WINAPI * _BEMATECH_FI_ESTORNONAOFISCALVINCULADOMFD )(char* Cpf, char* Nome, char* Endereco);
typedef INT (WINAPI * _BEMATECH_FI_PROGRAMAFORMAPAGAMENTOMFD )(char* CFormaPgto, char* cTef);
typedef int (WINAPI * _BEMATECH_FI_INFOBALANCA) (char* Porta, int Modelo, char* Peso, char* PrecoKilo, char* Total);

/*
HB_FUNC( BEMATECH_FI_DOWNLOADMFD )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_DOWNLOADMFD pFunc;
        char a[ 20]  = { 0 };
        char b[ 1 ] =  { 0 };
        char c[ 6 ] =  { 0 };
        char d[ 6 ] =  { 0 };
        char e[ 1 ] =  { 0 };
        pFunc = (_BEMATECH_FI_DOWNLOADMFD) GetProcAddress(handle, "Bematech_FI_DownLoadMFD");
        strcpy( a , hb_parcx( 1 ));
        strcpy( b , hb_parcx( 2 ));
        strcpy( d , hb_parcx( 3 ));
        strcpy( d , hb_parcx( 4 ));
        strcpy( e , hb_parcx( 5 ));
        hb_retni(pFunc( a, b, c, d, e));
        FreeLibrary( handle );  
    }
}

*/
HB_FUNC( BEMATECH_FI_PROGRAMAALIQUOTA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Aliquota[ 150 ] =  { 0 } ;
        INT ICMS_ISS =  hb_parni( 2 );

        _BEMATECH_FI_PROGRAMAALIQUOTA pFunc;
        strcpy( Aliquota, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_PROGRAMAALIQUOTA) GetProcAddress(handle, "Bematech_FI_ProgramaAliquota");
        hb_retni(pFunc( Aliquota , ICMS_ISS  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_PROGRAMAHORARIOVERAO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_PROGRAMAHORARIOVERAO pFunc;
        
        pFunc = (_BEMATECH_FI_PROGRAMAHORARIOVERAO) GetProcAddress(handle, "Bematech_FI_ProgramaHorarioVerao");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NOMEIADEPARTAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT Indice =  hb_parni( 1 );
        char Departamento[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NOMEIADEPARTAMENTO pFunc;
                strcpy( Departamento, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_NOMEIADEPARTAMENTO) GetProcAddress(handle, "Bematech_FI_NomeiaDepartamento");
        hb_retni(pFunc( Indice , Departamento  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NOMEIATOTALIZADORNAOSUJEITOICMS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT Indice =  hb_parni( 1 );
        char Totalizador[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NOMEIATOTALIZADORNAOSUJEITOICMS pFunc;
                strcpy( Totalizador, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_NOMEIATOTALIZADORNAOSUJEITOICMS) GetProcAddress(handle, "Bematech_FI_NomeiaTotalizadorNaoSujeitoIcms");
        hb_retni(pFunc( Indice , Totalizador  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_PROGRAMAARREDONDAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_PROGRAMAARREDONDAMENTO pFunc;
        
        pFunc = (_BEMATECH_FI_PROGRAMAARREDONDAMENTO) GetProcAddress(handle, "Bematech_FI_ProgramaArredondamento");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_PROGRAMATRUNCAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_PROGRAMATRUNCAMENTO pFunc;
        
        pFunc = (_BEMATECH_FI_PROGRAMATRUNCAMENTO) GetProcAddress(handle, "Bematech_FI_ProgramaTruncamento");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LINHASENTRECUPONS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT Linha =  hb_parni( 1 );

        _BEMATECH_FI_LINHASENTRECUPONS pFunc;
        
        pFunc = (_BEMATECH_FI_LINHASENTRECUPONS) GetProcAddress(handle, "Bematech_FI_LinhasEntreCupons");
        hb_retni(pFunc( Linha  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ESPACOENTRELINHAS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT Dots =  hb_parni( 1 );

        _BEMATECH_FI_ESPACOENTRELINHAS pFunc;
        
        pFunc = (_BEMATECH_FI_ESPACOENTRELINHAS) GetProcAddress(handle, "Bematech_FI_EspacoEntreLinhas");
        hb_retni(pFunc( Dots  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FORCAIMPACTOAGULHAS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT ForcaImpacto =  hb_parni( 1 );

        _BEMATECH_FI_FORCAIMPACTOAGULHAS pFunc;
        
        pFunc = (_BEMATECH_FI_FORCAIMPACTOAGULHAS) GetProcAddress(handle, "Bematech_FI_ForcaImpactoAgulhas");
        hb_retni(pFunc( ForcaImpacto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ABRECUPOM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char CGC_CPF[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ABRECUPOM pFunc;
        strcpy( CGC_CPF, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_ABRECUPOM) GetProcAddress(handle, "Bematech_FI_AbreCupom");
        hb_retni(pFunc( CGC_CPF  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VENDEITEMDEPARTAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Codigo[ 150 ] =  { 0 } ;
        char Descricao[ 150 ] =  { 0 } ;
        char Aliquota[ 150 ] =  { 0 } ;
        char ValorUnitario[ 150 ] =  { 0 } ;
        char Quantidade[ 150 ] =  { 0 } ;
        char Acrescimo[ 150 ] =  { 0 } ;
        char Desconto[ 150 ] =  { 0 } ;
        char IndiceDepartamento[ 150 ] =  { 0 } ;
        char UnidadeMedida[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VENDEITEMDEPARTAMENTO pFunc;
        strcpy( Codigo, hb_parc( 1 ) );
        strcpy( Descricao, hb_parc( 2 ) );
        strcpy( Aliquota, hb_parc( 3 ) );
        strcpy( ValorUnitario, hb_parc( 4 ) );
        strcpy( Quantidade, hb_parc( 5 ) );
        strcpy( Acrescimo, hb_parc( 6 ) );
        strcpy( Desconto, hb_parc( 7 ) );
        strcpy( IndiceDepartamento, hb_parc( 8 ) );
        strcpy( UnidadeMedida, hb_parc( 9 ) );

        pFunc = (_BEMATECH_FI_VENDEITEMDEPARTAMENTO) GetProcAddress(handle, "Bematech_FI_VendeItemDepartamento");
        hb_retni(pFunc( Codigo , Descricao , Aliquota , ValorUnitario , Quantidade , Acrescimo , Desconto , IndiceDepartamento , UnidadeMedida  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CANCELAITEMANTERIOR )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_CANCELAITEMANTERIOR pFunc;
        
        pFunc = (_BEMATECH_FI_CANCELAITEMANTERIOR) GetProcAddress(handle, "Bematech_FI_CancelaItemAnterior");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CANCELAITEMGENERICO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroItem[ 150 ] =  { 0 } ;

        _BEMATECH_FI_CANCELAITEMGENERICO pFunc;
        strcpy( NumeroItem, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_CANCELAITEMGENERICO) GetProcAddress(handle, "Bematech_FI_CancelaItemGenerico");
        hb_retni(pFunc( NumeroItem  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CANCELACUPOM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_CANCELACUPOM pFunc;
        
        pFunc = (_BEMATECH_FI_CANCELACUPOM) GetProcAddress(handle, "Bematech_FI_CancelaCupom");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FECHACUPOMRESUMIDO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 150 ] =  { 0 } ;
        char Mensagem[ 150 ] =  { 0 } ;

        _BEMATECH_FI_FECHACUPOMRESUMIDO pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( Mensagem, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_FECHACUPOMRESUMIDO) GetProcAddress(handle, "Bematech_FI_FechaCupomResumido");
        hb_retni(pFunc( FormaPagamento , Mensagem  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FECHACUPOM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 150 ] =  { 0 } ;
        char AcrescimoDesconto[ 150 ] =  { 0 } ;
        char TipoAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorPago[ 150 ] =  { 0 } ;
        char Mensagem[ 150 ] =  { 0 } ;

        _BEMATECH_FI_FECHACUPOM pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( AcrescimoDesconto, hb_parc( 2 ) );
        strcpy( TipoAcrescimoDesconto, hb_parc( 3 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 4 ) );
        strcpy( ValorPago, hb_parc( 5 ) );
        strcpy( Mensagem, hb_parc( 6 ) );

        pFunc = (_BEMATECH_FI_FECHACUPOM) GetProcAddress(handle, "Bematech_FI_FechaCupom");
        hb_retni(pFunc( FormaPagamento , AcrescimoDesconto , TipoAcrescimoDesconto , ValorAcrescimoDesconto , ValorPago , Mensagem  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_RESETAIMPRESSORA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_RESETAIMPRESSORA pFunc;
        
        pFunc = (_BEMATECH_FI_RESETAIMPRESSORA) GetProcAddress(handle, "Bematech_FI_ResetaImpressora");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_EFETUAFORMAPAGAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 150 ] =  { 0 } ;
        char ValorFormaPagamento[ 150 ] =  { 0 } ;

        _BEMATECH_FI_EFETUAFORMAPAGAMENTO pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( ValorFormaPagamento, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_EFETUAFORMAPAGAMENTO) GetProcAddress(handle, "Bematech_FI_EfetuaFormaPagamento");
        hb_retni(pFunc( FormaPagamento , ValorFormaPagamento  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_EFETUAFORMAPAGAMENTODESCRICAOFORMA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 150 ] =  { 0 } ;
        char ValorFormaPagamento[ 150 ] =  { 0 } ;
        char DescricaoFormaPagto[ 150 ] =  { 0 } ;

        _BEMATECH_FI_EFETUAFORMAPAGAMENTODESCRICAOFORMA pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( ValorFormaPagamento, hb_parc( 2 ) );
        strcpy( DescricaoFormaPagto, hb_parc( 3 ) );

        pFunc = (_BEMATECH_FI_EFETUAFORMAPAGAMENTODESCRICAOFORMA) GetProcAddress(handle, "Bematech_FI_EfetuaFormaPagamentoDescricaoForma");
        hb_retni(pFunc( FormaPagamento , ValorFormaPagamento , DescricaoFormaPagto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_TERMINAFECHAMENTOCUPOM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Mensagem[ 384 ] =  { 0 } ;

        _BEMATECH_FI_TERMINAFECHAMENTOCUPOM pFunc;
        strcpy( Mensagem, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_TERMINAFECHAMENTOCUPOM) GetProcAddress(handle, "Bematech_FI_TerminaFechamentoCupom");
        hb_retni(pFunc( Mensagem  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ESTORNOFORMASPAGAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaOrigem[ 150 ] =  { 0 } ;
        char FormaDestino[ 150 ] =  { 0 } ;
        char Valor[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ESTORNOFORMASPAGAMENTO pFunc;
        strcpy( FormaOrigem, hb_parc( 1 ) );
        strcpy( FormaDestino, hb_parc( 2 ) );
        strcpy( Valor, hb_parc( 3 ) );

        pFunc = (_BEMATECH_FI_ESTORNOFORMASPAGAMENTO) GetProcAddress(handle, "Bematech_FI_EstornoFormasPagamento");
        hb_retni(pFunc( FormaOrigem , FormaDestino , Valor  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_USAUNIDADEMEDIDA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char UnidadeMedida[ 150 ] =  { 0 } ;

        _BEMATECH_FI_USAUNIDADEMEDIDA pFunc;
        strcpy( UnidadeMedida, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_USAUNIDADEMEDIDA) GetProcAddress(handle, "Bematech_FI_UsaUnidadeMedida");
        hb_retni(pFunc( UnidadeMedida  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_AUMENTADESCRICAOITEM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Descricao[ 150 ] =  { 0 } ;

        _BEMATECH_FI_AUMENTADESCRICAOITEM pFunc;
        strcpy( Descricao, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_AUMENTADESCRICAOITEM) GetProcAddress(handle, "Bematech_FI_AumentaDescricaoItem");
        hb_retni(pFunc( Descricao  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LEITURAX )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_LEITURAX pFunc;
        
        pFunc = (_BEMATECH_FI_LEITURAX) GetProcAddress(handle, "Bematech_FI_LeituraX");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_REDUCAOZ )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Data[ 150 ] =  { 0 } ;
        char Hora[ 150 ] =  { 0 } ;

        _BEMATECH_FI_REDUCAOZ pFunc;
        strcpy( Data, hb_parc( 1 ) );
        strcpy( Hora, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_REDUCAOZ) GetProcAddress(handle, "Bematech_FI_ReducaoZ");
        hb_retni(pFunc( Data , Hora  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_RELATORIOGERENCIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Texto[ 650 ] =  { 0 } ; // Luiz Henrique 30/11/2005 - estava 150 e o certo é 618

        _BEMATECH_FI_RELATORIOGERENCIAL pFunc;
        strcpy( Texto, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_RELATORIOGERENCIAL) GetProcAddress(handle, "Bematech_FI_RelatorioGerencial");
        hb_retni(pFunc( Texto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FECHARELATORIOGERENCIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_FECHARELATORIOGERENCIAL pFunc;
        
        pFunc = (_BEMATECH_FI_FECHARELATORIOGERENCIAL) GetProcAddress(handle, "Bematech_FI_FechaRelatorioGerencial");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LEITURAMEMORIAFISCALDATA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char DataInicial[ 150 ] =  { 0 } ;
        char DataFinal[ 150 ] =  { 0 } ;

        _BEMATECH_FI_LEITURAMEMORIAFISCALDATA pFunc;
        strcpy( DataInicial, hb_parc( 1 ) );
        strcpy( DataFinal, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALDATA) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalData");
        hb_retni(pFunc( DataInicial , DataFinal  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ReducaoInicial[ 150 ] =  { 0 } ;
        char ReducaoFinal[ 150 ] =  { 0 } ;

        _BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAO pFunc;
        strcpy( ReducaoInicial, hb_parc( 1 ) );
        strcpy( ReducaoFinal, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAO) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalReducao");
        hb_retni(pFunc( ReducaoInicial , ReducaoFinal  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LEITURAMEMORIAFISCALSERIALDATA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char DataInicial[ 150 ] =  { 0 } ;
        char DataFinal[ 150 ] =  { 0 } ;

        _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALDATA pFunc;
        strcpy( DataInicial, hb_parc( 1 ) );
        strcpy( DataFinal, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALSERIALDATA) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalSerialData");
        hb_retni(pFunc( DataInicial , DataFinal  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LEITURAMEMORIAFISCALSERIALREDUCAO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ReducaoInicial[ 150 ] =  { 0 } ;
        char ReducaoFinal[ 150 ] =  { 0 } ;

        _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALREDUCAO pFunc;
        strcpy( ReducaoInicial, hb_parc( 1 ) );
        strcpy( ReducaoFinal, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALSERIALREDUCAO) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalSerialReducao");
        hb_retni(pFunc( ReducaoInicial , ReducaoFinal  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_RECEBIMENTONAOFISCAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char IndiceTotalizador[ 150 ] =  { 0 } ;
        char Valor[ 150 ] =  { 0 } ;
        char FormaPagamento[ 150 ] =  { 0 } ;

        _BEMATECH_FI_RECEBIMENTONAOFISCAL pFunc;
        strcpy( IndiceTotalizador, hb_parc( 1 ) );
        strcpy( Valor, hb_parc( 2 ) );
        strcpy( FormaPagamento, hb_parc( 3 ) );

        pFunc = (_BEMATECH_FI_RECEBIMENTONAOFISCAL) GetProcAddress(handle, "Bematech_FI_RecebimentoNaoFiscal");
        hb_retni(pFunc( IndiceTotalizador , Valor , FormaPagamento  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ABRECOMPROVANTENAOFISCALVINCULADO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 16 ] =  { 0 } ; // Luiz Henrique 30/11/2005 - estava 150 e o certo é 14
        char Valor[ 14 ] =  { 0 } ; // Luiz Henrique 30/11/2005 - estava 150 e o certo é 14
        char NumeroCupom[ 6 ] =  { 0 } ; // Luiz Henrique 30/11/2005 - estava 150 e o certo é 6

        _BEMATECH_FI_ABRECOMPROVANTENAOFISCALVINCULADO pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( Valor, hb_parc( 2 ) );
        strcpy( NumeroCupom, hb_parc( 3 ) );

        pFunc = (_BEMATECH_FI_ABRECOMPROVANTENAOFISCALVINCULADO) GetProcAddress(handle, "Bematech_FI_AbreComprovanteNaoFiscalVinculado");
        hb_retni(pFunc( FormaPagamento , Valor , NumeroCupom  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Texto[ 618 ] =  { 0 } ; // Luiz Henrique 30/11/2005 - era 150 e o certo é 618

        _BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADO pFunc;
        strcpy( Texto, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADO) GetProcAddress(handle, "Bematech_FI_UsaComprovanteNaoFiscalVinculado");
        hb_retni(pFunc( Texto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FECHACOMPROVANTENAOFISCALVINCULADO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_FECHACOMPROVANTENAOFISCALVINCULADO pFunc;
        
        pFunc = (_BEMATECH_FI_FECHACOMPROVANTENAOFISCALVINCULADO) GetProcAddress(handle, "Bematech_FI_FechaComprovanteNaoFiscalVinculado");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_SANGRIA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Valor[ 150 ] =  { 0 } ;

        _BEMATECH_FI_SANGRIA pFunc;
        strcpy( Valor, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_SANGRIA) GetProcAddress(handle, "Bematech_FI_Sangria");
        hb_retni(pFunc( Valor  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_SUPRIMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Valor[ 150 ] =  { 0 } ;
        char FormaPagamento[ 150 ] =  { 0 } ;

        _BEMATECH_FI_SUPRIMENTO pFunc;
        strcpy( Valor, hb_parc( 1 ) );
        strcpy( FormaPagamento, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_SUPRIMENTO) GetProcAddress(handle, "Bematech_FI_Suprimento");
        hb_retni(pFunc( Valor , FormaPagamento  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROSERIE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {	
        char NumeroSerie[21] = {0};
        hb_retni(Bematech_FI_NumeroSerie(NumeroSerie));    
        hb_storc((char*)NumeroSerie, 1);
    }    
}

HB_FUNC( BEMATECH_FI_NUMEROSERIEMFD )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {	
        char NumeroSerie[21] = {0};

        _BEMATECH_FI_NUMEROSERIEMFD pFunc;
        pFunc = (_BEMATECH_FI_NUMEROSERIEMFD) GetProcAddress(handle, "Bematech_FI_NumeroSerieMFD");
        
        hb_retni(pFunc(NumeroSerie));
        hb_storc((char*)NumeroSerie, 1);
        
//        hb_retni(Bematech_FI_NumeroSerieMFD(NumeroSerie));    
//        hb_storc((char*)NumeroSerie, 1);
    }    
}

HB_FUNC( BEMATECH_FI_VENDABRUTA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char VendaBruta[18] = {0};

        _BEMATECH_FI_VENDABRUTA pFunc;
        pFunc = (_BEMATECH_FI_VENDABRUTA) GetProcAddress(handle, "Bematech_FI_VendaBruta");
        
        hb_retni(pFunc(VendaBruta));
        hb_storc((char*)VendaBruta, 1);
        
        FreeLibrary(handle);  
    }        
}

HB_FUNC( BEMATECH_FI_SUBTOTAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char SubTotal[ 150 ] =  { 0 } ;

        _BEMATECH_FI_SUBTOTAL pFunc;
        strcpy( SubTotal, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_SUBTOTAL) GetProcAddress(handle, "Bematech_FI_SubTotal");
        hb_retni(pFunc( SubTotal  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROCUPOM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroCupom[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROCUPOM pFunc;
        pFunc = (_BEMATECH_FI_NUMEROCUPOM) GetProcAddress(handle, "Bematech_FI_NumeroCupom");
        hb_retni(pFunc( NumeroCupom));
        hb_storc((char*)NumeroCupom ,1);
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LEITURAXSERIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_LEITURAXSERIAL pFunc;
        
        pFunc = (_BEMATECH_FI_LEITURAXSERIAL) GetProcAddress(handle, "Bematech_FI_LeituraXSerial");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERSAOFIRMWARE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char VersaoFirmware[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERSAOFIRMWARE pFunc;
        
        pFunc = (_BEMATECH_FI_VERSAOFIRMWARE) GetProcAddress(handle, "Bematech_FI_VersaoFirmware");
        hb_retni(pFunc( VersaoFirmware  ));    
        hb_storc( ( char * ) VersaoFirmware , 1 );
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CGC_IE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char CGC[ 150 ] =  { 0 } ;
        char IE[ 150 ] =  { 0 } ;

        _BEMATECH_FI_CGC_IE pFunc;
        
        pFunc = (_BEMATECH_FI_CGC_IE) GetProcAddress(handle, "Bematech_FI_CGC_IE");
        hb_retni(pFunc( CGC , IE  ));    
        hb_storc( ( char * ) CGC , 1 );
        hb_storc( ( char * ) IE , 2 );
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_GRANDETOTAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char GrandeTotal[ 150 ] =  { 0 } ;

        _BEMATECH_FI_GRANDETOTAL pFunc;
        
        pFunc = (_BEMATECH_FI_GRANDETOTAL) GetProcAddress(handle, "Bematech_FI_GrandeTotal");
        hb_retni(pFunc( GrandeTotal  ));    
        hb_storc( ( char * ) GrandeTotal , 1 );        
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CANCELAMENTOS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ValorCancelamentos[ 150 ] =  { 0 } ;

        _BEMATECH_FI_CANCELAMENTOS pFunc;

        pFunc = (_BEMATECH_FI_CANCELAMENTOS) GetProcAddress(handle, "Bematech_FI_Cancelamentos");
        hb_retni(pFunc( ValorCancelamentos  ));    
        hb_storc( ( char * ) ValorCancelamentos , 1 );        
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_DESCONTOS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ValorDescontos[ 150 ] =  { 0 } ;

        _BEMATECH_FI_DESCONTOS pFunc;

        pFunc = (_BEMATECH_FI_DESCONTOS) GetProcAddress(handle, "Bematech_FI_Descontos");
        hb_retni(pFunc( ValorDescontos  ));    
        hb_storc( ( char * ) ValorDescontos , 1 );                
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROOPERACOESNAOFISCAIS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroOperacoes[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROOPERACOESNAOFISCAIS pFunc;
        
        pFunc = (_BEMATECH_FI_NUMEROOPERACOESNAOFISCAIS) GetProcAddress(handle, "Bematech_FI_NumeroOperacoesNaoFiscais");
        hb_retni(pFunc( NumeroOperacoes  ));    
        hb_storc( ( char * ) NumeroOperacoes , 1 );                        
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROCUPONSCANCELADOS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroCancelamentos[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROCUPONSCANCELADOS pFunc;
        
        pFunc = (_BEMATECH_FI_NUMEROCUPONSCANCELADOS) GetProcAddress(handle, "Bematech_FI_NumeroCuponsCancelados");
        hb_retni(pFunc( NumeroCancelamentos  ));    
        hb_storc( ( char * ) NumeroCancelamentos , 1 );                                
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROINTERVENCOES )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroIntervencoes[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROINTERVENCOES pFunc;
        
        pFunc = (_BEMATECH_FI_NUMEROINTERVENCOES) GetProcAddress(handle, "Bematech_FI_NumeroIntervencoes");
        hb_retni(pFunc( NumeroIntervencoes  ));    
        hb_storc( ( char * ) NumeroIntervencoes , 1 );                                
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROREDUCOES )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroReducoes[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROREDUCOES pFunc;
        
        pFunc = (_BEMATECH_FI_NUMEROREDUCOES) GetProcAddress(handle, "Bematech_FI_NumeroReducoes");
        hb_retni(pFunc( NumeroReducoes  ));    
        hb_storc( ( char * ) NumeroReducoes , 1 );
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROSUBSTITUICOESPROPRIETARIO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroSubstituicoes[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROSUBSTITUICOESPROPRIETARIO pFunc;

        pFunc = (_BEMATECH_FI_NUMEROSUBSTITUICOESPROPRIETARIO) GetProcAddress(handle, "Bematech_FI_NumeroSubstituicoesProprietario");
        hb_retni(pFunc( NumeroSubstituicoes  ));    
        hb_storc( ( char * ) NumeroSubstituicoes , 1 );        
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ULTIMOITEMVENDIDO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroItem[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ULTIMOITEMVENDIDO pFunc;
        
        pFunc = (_BEMATECH_FI_ULTIMOITEMVENDIDO) GetProcAddress(handle, "Bematech_FI_UltimoItemVendido");
        hb_retni(pFunc( NumeroItem  ));    
        hb_storc( ( char * ) NumeroItem , 1 );        
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CLICHEPROPRIETARIO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Cliche[ 200 ] =  { 0 } ;

        _BEMATECH_FI_CLICHEPROPRIETARIO pFunc;
        
        pFunc = (_BEMATECH_FI_CLICHEPROPRIETARIO) GetProcAddress(handle, "Bematech_FI_ClicheProprietario");
        hb_retni(pFunc( Cliche  ));    
        hb_storc( ( char * ) Cliche , 1 );         
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROCAIXA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroCaixa[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROCAIXA pFunc;
        
        pFunc = (_BEMATECH_FI_NUMEROCAIXA) GetProcAddress(handle, "Bematech_FI_NumeroCaixa");
        hb_retni(pFunc( NumeroCaixa  ));    
        hb_storc( ( char * ) NumeroCaixa , 1 );                 
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_NUMEROLOJA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroLoja[ 150 ] =  { 0 } ;

        _BEMATECH_FI_NUMEROLOJA pFunc;
        
        pFunc = (_BEMATECH_FI_NUMEROLOJA) GetProcAddress(handle, "Bematech_FI_NumeroLoja");
        hb_retni(pFunc( NumeroLoja  ));    
        hb_storc( ( char * ) NumeroLoja , 1 );                           
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_SIMBOLOMOEDA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char SimboloMoeda[ 150 ] =  { 0 } ;

        _BEMATECH_FI_SIMBOLOMOEDA pFunc;
        strcpy( SimboloMoeda, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_SIMBOLOMOEDA) GetProcAddress(handle, "Bematech_FI_SimboloMoeda");
        hb_retni(pFunc( SimboloMoeda  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_MINUTOSLIGADA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Minutos[ 150 ] =  { 0 } ;

        _BEMATECH_FI_MINUTOSLIGADA pFunc;
        strcpy( Minutos, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_MINUTOSLIGADA) GetProcAddress(handle, "Bematech_FI_MinutosLigada");
        hb_retni(pFunc( Minutos  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_MINUTOSIMPRIMINDO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Minutos[ 150 ] =  { 0 } ;

        _BEMATECH_FI_MINUTOSIMPRIMINDO pFunc;
        strcpy( Minutos, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_MINUTOSIMPRIMINDO) GetProcAddress(handle, "Bematech_FI_MinutosImprimindo");
        hb_retni(pFunc( Minutos  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICAMODOOPERACAO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Modo[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERIFICAMODOOPERACAO pFunc;
        strcpy( Modo, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICAMODOOPERACAO) GetProcAddress(handle, "Bematech_FI_VerificaModoOperacao");
        hb_retni(pFunc( Modo  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICAEPROMCONECTADA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Flag[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERIFICAEPROMCONECTADA pFunc;
        strcpy( Flag, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICAEPROMCONECTADA) GetProcAddress(handle, "Bematech_FI_VerificaEpromConectada");
        hb_retni(pFunc( Flag  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VALORPAGOULTIMOCUPOM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ValorCupom[ 14 ] =  { 0 } ; //Luiz Henrique dos Santos 28/11/2005 são 14 espacos e nao 150

        _BEMATECH_FI_VALORPAGOULTIMOCUPOM pFunc;
        strcpy( ValorCupom, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VALORPAGOULTIMOCUPOM) GetProcAddress(handle, "	");
        hb_retni(pFunc( ValorCupom  ));    
        hb_storc((char*)ValorCupom, 1); // Luiz Henrique dos Santos 28/11/2005 faltava preencher a variavel receptora 
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_DATAHORAIMPRESSORA )
{
   char Data[ 7 ] = { 0 };
   char Hora[ 7 ] = { 0 };
   int res;

   res = Bematech_FI_DataHoraImpressora(Data , Hora  );
   TraceLog("%s %s\n",Data,Hora);
   hb_storc((char*)Data,1);
   hb_storc((char*)Hora,2);
   hb_retni(res);
}

HB_FUNC( BEMATECH_FI_CONTADORESTOTALIZADORESNAOFISCAIS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Contadores[ 44 ] =  { 0 } ; //Luiz Henrique dos Santos 28/11/2005 são 44 espacos e nao 150

        _BEMATECH_FI_CONTADORESTOTALIZADORESNAOFISCAIS pFunc;
        strcpy( Contadores, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_CONTADORESTOTALIZADORESNAOFISCAIS) GetProcAddress(handle, "Bematech_FI_ContadoresTotalizadoresNaoFiscais");
        hb_retni(pFunc( Contadores  ));    
        hb_storc((char*)Contadores, 1); // Luiz Henrique dos Santos 28/11/2005 faltava preencher a variavel receptora 
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICATOTALIZADORESNAOFISCAIS )
{
  HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");
  if (handle)
  {
    char Totalizadores[179] = {0}; //Luiz Henrique dos Santos 28/11/2005 a são 179 espacos e nao 150
 
    _BEMATECH_FI_VERIFICATOTALIZADORESNAOFISCAIS pFunc;
    strcpy( Totalizadores, hb_parc(1));

    pFunc = (_BEMATECH_FI_VERIFICATOTALIZADORESNAOFISCAIS) GetProcAddress(handle, "Bematech_FI_VerificaTotalizadoresNaoFiscais");
    hb_retni(pFunc( Totalizadores));    
    hb_storc((char*)Totalizadores, 1);
    
    FreeLibrary( handle );  
  }        
}

HB_FUNC( BEMATECH_FI_DATAHORAREDUCAO )
{
  HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");
  if (handle)
  {
    char Data[6] = {0};
    char Hora[6] = {0};
    
    _BEMATECH_FI_DATAHORAREDUCAO pFunc;
    strcpy(Data, hb_parc(1));
    strcpy(Hora, hb_parc(2));
    
    pFunc = (_BEMATECH_FI_DATAHORAREDUCAO) GetProcAddress(handle, "Bematech_FI_DataHoraReducao");
    
    hb_retni(pFunc(Data, Hora));
    hb_storc((char*)Data, 1);
    hb_storc((char*)Hora, 2);

    FreeLibrary( handle );  
  }        
}

//HB_FUNC( BEMATECH_FI_DATAMOVIMENTO )
//{
//   HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");
//    if (handle)
//    {
//        char Data[ 150 ] =  { 0 } ;
//
//        _BEMATECH_FI_DATAMOVIMENTO pFunc;
//        strcpy( Data, hb_parc( 1 ) );
//
//        pFunc = (_BEMATECH_FI_DATAMOVIMENTO) GetProcAddress(handle, "Bematech_FI_DataMovimento");
//        hb_retni(pFunc( Data  ));    
//        FreeLibrary( handle );  
//    }        
//}

HB_FUNC( BEMATECH_FI_VERIFICATRUNCAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Flag[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERIFICATRUNCAMENTO pFunc;
        strcpy( Flag, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICATRUNCAMENTO) GetProcAddress(handle, "Bematech_FI_VerificaTruncamento");
        hb_retni(pFunc( Flag  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ACRESCIMOS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ValorAcrescimos[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ACRESCIMOS pFunc;
        strcpy( ValorAcrescimos, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_ACRESCIMOS) GetProcAddress(handle, "Bematech_FI_Acrescimos");
        hb_retni(pFunc( ValorAcrescimos  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CONTADORBILHETEPASSAGEM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ContadorPa[ 150 ] =  { 0 } ;

        _BEMATECH_FI_CONTADORBILHETEPASSAGEM pFunc;
        strcpy( ContadorPa, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_CONTADORBILHETEPASSAGEM) GetProcAddress(handle, "Bematech_FI_ContadorBilhetePassagem");
        hb_retni(pFunc( ContadorPa  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICAALIQUOTAISS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Flag[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERIFICAALIQUOTAISS pFunc;
        strcpy( Flag, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICAALIQUOTAISS) GetProcAddress(handle, "Bematech_FI_VerificaAliquotaIss");
        hb_retni(pFunc( Flag  ));    
        FreeLibrary( handle );  
    }        
}
HB_FUNC( BEMATECH_FI_VERIFICAFORMASPAGAMENTO )
{
      char Forma[ 3016 ] =  { 0 } ;

      hb_retni( Bematech_FI_VerificaFormasPagamento(Forma) );
      hb_storc((char*)Forma,1);
}

//HB_FUNC( BEMATECH_FI_VERIFICAFORMASPAGAMENTO )
//{
//    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");
//
//   if (handle)
//    {
//        char Forma[ 150 ] =  { 0 } ;
//
//        _BEMATECH_FI_VERIFICAFORMASPAGAMENTO pFunc;
//        strcpy( Forma, hb_parc( 1 ) );
//
//        pFunc = (_BEMATECH_FI_VERIFICAFORMASPAGAMENTO) GetProcAddress(handle, "Bematech_FI_VerificaFormasPagamento");
//        hb_retni(pFunc( Forma  ));    
//        FreeLibrary( handle );  
//   }        
//}

HB_FUNC( BEMATECH_FI_VERIFICARECEBIMENTONAOFISCAL )
{
    char Recebimento[2200] = {0};

    hb_retni(Bematech_FI_VerificaRecebimentoNaoFiscal(Recebimento));    

    hb_storc((char*)Recebimento, 1);
}

/*
HB_FUNC( BEMATECH_FI_VERIFICARECEBIMENTONAOFISCAL )
{
  HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

  if (handle)
  {
    char Recebimentos[2200] = {0};

    _BEMATECH_FI_VERIFICARECEBIMENTONAOFISCAL pFunc;
    strcpy(Recebimentos, hb_parc(1));

    pFunc = (_BEMATECH_FI_VERIFICARECEBIMENTONAOFISCAL) GetProcAddress(handle, "Bematech_FI_VerificaRecebimentoNaoFiscal");

    hb_retni(pFunc(Recebimentos));    
    
    hb_storc((char*)Recebimentos, 1);

    FreeLibrary( handle );  
  }        
}
*/

HB_FUNC( BEMATECH_FI_VERIFICADEPARTAMENTOS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Departamentos[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERIFICADEPARTAMENTOS pFunc;
        strcpy( Departamentos, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICADEPARTAMENTOS) GetProcAddress(handle, "Bematech_FI_VerificaDepartamentos");
        hb_retni(pFunc( Departamentos  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICATIPOIMPRESSORA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT TipoImpressora =  hb_parni( 1 );

        _BEMATECH_FI_VERIFICATIPOIMPRESSORA pFunc;
        
        pFunc = (_BEMATECH_FI_VERIFICATIPOIMPRESSORA) GetProcAddress(handle, "Bematech_FI_VerificaTipoImpressora");
        hb_retni(pFunc( TipoImpressora  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICATOTALIZADORESPARCIAIS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Totalizadores[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERIFICATOTALIZADORESPARCIAIS pFunc;
        strcpy( Totalizadores, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICATOTALIZADORESPARCIAIS) GetProcAddress(handle, "Bematech_FI_VerificaTotalizadoresParciais");
        hb_retni(pFunc( Totalizadores  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_RETORNOALIQUOTAS )
{
  HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

  if (handle)
  {
    char Aliquotas[79] = {0} ; //Luiz Henrique dos Santos 28/11/2005 são 79 espacos e nao 150

    _BEMATECH_FI_RETORNOALIQUOTAS pFunc;
    strcpy(Aliquotas, hb_parc(1));

    pFunc = (_BEMATECH_FI_RETORNOALIQUOTAS) GetProcAddress(handle, "Bematech_FI_RetornoAliquotas");

    hb_retni(pFunc(Aliquotas));    
    hb_storc((char*)Aliquotas, 1); // Luiz Henrique dos Santos 30/11/2005 faltava preencher a variavel receptora

    FreeLibrary( handle );  
  }        
}

HB_FUNC( BEMATECH_FI_DADOSULTIMAREDUCAO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_DADOSULTIMAREDUCAO pFunc;    	
        char a[ 631 ] =  { 0 } ;
        pFunc = (_BEMATECH_FI_DADOSULTIMAREDUCAO) GetProcAddress(handle, "Bematech_FI_DadosUltimaReducao");
        hb_retni(pFunc(a));        
        hb_storc((char*)a,1);
        FreeLibrary( handle );  
    }        
}


HB_FUNC( BEMATECH_FI_VERIFICAINDICEALIQUOTASISS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Flag[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VERIFICAINDICEALIQUOTASISS pFunc;
        strcpy( Flag, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICAINDICEALIQUOTASISS) GetProcAddress(handle, "Bematech_FI_VerificaIndiceAliquotasIss");
        hb_retni(pFunc( Flag  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VALORFORMAPAGAMENTO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 150 ] =  { 0 } ;
        char Valor[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VALORFORMAPAGAMENTO pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( Valor, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_VALORFORMAPAGAMENTO) GetProcAddress(handle, "Bematech_FI_ValorFormaPagamento");
        hb_retni(pFunc( FormaPagamento , Valor  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VALORTOTALIZADORNAOFISCAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Totalizador[ 150 ] =  { 0 } ;
        char Valor[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VALORTOTALIZADORNAOFISCAL pFunc;
        strcpy( Totalizador, hb_parc( 1 ) );
        strcpy( Valor, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_VALORTOTALIZADORNAOFISCAL) GetProcAddress(handle, "Bematech_FI_ValorTotalizadorNaoFiscal");
        hb_retni(pFunc( Totalizador , Valor  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_AUTENTICACAO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_AUTENTICACAO pFunc;
        
        pFunc = (_BEMATECH_FI_AUTENTICACAO) GetProcAddress(handle, "Bematech_FI_Autenticacao");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_PROGRAMACARACTERAUTENTICACAO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Parametros[ 150 ] =  { 0 } ;

        _BEMATECH_FI_PROGRAMACARACTERAUTENTICACAO pFunc;
        strcpy( Parametros, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_PROGRAMACARACTERAUTENTICACAO) GetProcAddress(handle, "Bematech_FI_ProgramaCaracterAutenticacao");
        hb_retni(pFunc( Parametros  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ACIONAGAVETA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_ACIONAGAVETA pFunc;
        
        pFunc = (_BEMATECH_FI_ACIONAGAVETA) GetProcAddress(handle, "Bematech_FI_AcionaGaveta");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_ABRECUPOMRESTAURANTE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Mesa[ 150 ] =  { 0 } ;
        char CGC_CPF[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_ABRECUPOMRESTAURANTE pFunc;
        strcpy( Mesa, hb_parc( 1 ) );
        strcpy( CGC_CPF, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FIR_ABRECUPOMRESTAURANTE) GetProcAddress(handle, "Bematech_FIR_AbreCupomRestaurante");
        hb_retni(pFunc( Mesa , CGC_CPF  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_REGISTRAVENDA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Mesa[ 150 ] =  { 0 } ;
        char Codigo[ 150 ] =  { 0 } ;
        char Descricao[ 150 ] =  { 0 } ;
        char Aliquota[ 150 ] =  { 0 } ;
        char Quantidade[ 150 ] =  { 0 } ;
        char ValorUnitario[ 150 ] =  { 0 } ;
        char FlagAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_REGISTRAVENDA pFunc;
        strcpy( Mesa, hb_parc( 1 ) );
        strcpy( Codigo, hb_parc( 2 ) );
        strcpy( Descricao, hb_parc( 3 ) );
        strcpy( Aliquota, hb_parc( 4 ) );
        strcpy( Quantidade, hb_parc( 5 ) );
        strcpy( ValorUnitario, hb_parc( 6 ) );
        strcpy( FlagAcrescimoDesconto, hb_parc( 7 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 8 ) );

        pFunc = (_BEMATECH_FIR_REGISTRAVENDA) GetProcAddress(handle, "Bematech_FIR_RegistraVenda");
        hb_retni(pFunc( Mesa , Codigo , Descricao , Aliquota , Quantidade , ValorUnitario , FlagAcrescimoDesconto , ValorAcrescimoDesconto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_CANCELAVENDA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Mesa[ 150 ] =  { 0 } ;
        char Codigo[ 150 ] =  { 0 } ;
        char Descricao[ 150 ] =  { 0 } ;
        char Aliquota[ 150 ] =  { 0 } ;
        char Quantidade[ 150 ] =  { 0 } ;
        char ValorUnitario[ 150 ] =  { 0 } ;
        char FlagAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_CANCELAVENDA pFunc;
        strcpy( Mesa, hb_parc( 1 ) );
        strcpy( Codigo, hb_parc( 2 ) );
        strcpy( Descricao, hb_parc( 3 ) );
        strcpy( Aliquota, hb_parc( 4 ) );
        strcpy( Quantidade, hb_parc( 5 ) );
        strcpy( ValorUnitario, hb_parc( 6 ) );
        strcpy( FlagAcrescimoDesconto, hb_parc( 7 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 8 ) );

        pFunc = (_BEMATECH_FIR_CANCELAVENDA) GetProcAddress(handle, "Bematech_FIR_CancelaVenda");
        hb_retni(pFunc( Mesa , Codigo , Descricao , Aliquota , Quantidade , ValorUnitario , FlagAcrescimoDesconto , ValorAcrescimoDesconto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_CONFERENCIAMESA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Mesa[ 150 ] =  { 0 } ;
        char FlagAcrescimoDesconto[ 150 ] =  { 0 } ;
        char TipoAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_CONFERENCIAMESA pFunc;
        strcpy( Mesa, hb_parc( 1 ) );
        strcpy( FlagAcrescimoDesconto, hb_parc( 2 ) );
        strcpy( TipoAcrescimoDesconto, hb_parc( 3 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 4 ) );

        pFunc = (_BEMATECH_FIR_CONFERENCIAMESA) GetProcAddress(handle, "Bematech_FIR_ConferenciaMesa");
        hb_retni(pFunc( Mesa , FlagAcrescimoDesconto , TipoAcrescimoDesconto , ValorAcrescimoDesconto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_ABRECONFERENCIAMESA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Mesa[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_ABRECONFERENCIAMESA pFunc;
        strcpy( Mesa, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FIR_ABRECONFERENCIAMESA) GetProcAddress(handle, "Bematech_FIR_AbreConferenciaMesa");
        hb_retni(pFunc( Mesa  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_FECHACONFERENCIAMESA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FlagAcrescimoDesconto[ 150 ] =  { 0 } ;
        char TipoAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_FECHACONFERENCIAMESA pFunc;
        strcpy( FlagAcrescimoDesconto, hb_parc( 1 ) );
        strcpy( TipoAcrescimoDesconto, hb_parc( 2 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 3 ) );

        pFunc = (_BEMATECH_FIR_FECHACONFERENCIAMESA) GetProcAddress(handle, "Bematech_FIR_FechaConferenciaMesa");
        hb_retni(pFunc( FlagAcrescimoDesconto , TipoAcrescimoDesconto , ValorAcrescimoDesconto  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_TRANSFERENCIAMESA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char MesaOrigem[ 150 ] =  { 0 } ;
        char MesaDestino[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_TRANSFERENCIAMESA pFunc;
        strcpy( MesaOrigem, hb_parc( 1 ) );
        strcpy( MesaDestino, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FIR_TRANSFERENCIAMESA) GetProcAddress(handle, "Bematech_FIR_TransferenciaMesa");
        hb_retni(pFunc( MesaOrigem , MesaDestino  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_CONTADIVIDIDA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroCup[ 150 ] =  { 0 } ;
        char ValorPago[ 150 ] =  { 0 } ;
        char CGC_CPF[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_CONTADIVIDIDA pFunc;
        strcpy( NumeroCup, hb_parc( 1 ) );
        strcpy( ValorPago, hb_parc( 2 ) );
        strcpy( CGC_CPF, hb_parc( 3 ) );

        pFunc = (_BEMATECH_FIR_CONTADIVIDIDA) GetProcAddress(handle, "Bematech_FIR_ContaDividida");
        hb_retni(pFunc( NumeroCup , ValorPago , CGC_CPF  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_FECHACUPOMCONTADIVIDIDA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char NumeroCupons[ 150 ] =  { 0 } ;
        char FlagAcrescimoDesconto[ 150 ] =  { 0 } ;
        char TipoAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;
        char FormaPagamento[ 150 ] =  { 0 } ;
        char ValorFormaPagamento[ 150 ] =  { 0 } ;
        char ValorPagoCliente[ 150 ] =  { 0 } ;
        char CGC_CPF[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_FECHACUPOMCONTADIVIDIDA pFunc;
        strcpy( NumeroCupons, hb_parc( 1 ) );
        strcpy( FlagAcrescimoDesconto, hb_parc( 2 ) );
        strcpy( TipoAcrescimoDesconto, hb_parc( 3 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 4 ) );
        strcpy( FormaPagamento, hb_parc( 5 ) );
        strcpy( ValorFormaPagamento, hb_parc( 6 ) );
        strcpy( ValorPagoCliente, hb_parc( 7 ) );
        strcpy( CGC_CPF, hb_parc( 8 ) );

        pFunc = (_BEMATECH_FIR_FECHACUPOMCONTADIVIDIDA) GetProcAddress(handle, "Bematech_FIR_FechaCupomContaDividida");
        hb_retni(pFunc( NumeroCupons , FlagAcrescimoDesconto , TipoAcrescimoDesconto , ValorAcrescimoDesconto , FormaPagamento , ValorFormaPagamento , ValorPagoCliente , CGC_CPF  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_TRANSFERENCIAITEM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char MesaOrigem[ 150 ] =  { 0 } ;
        char Codigo[ 150 ] =  { 0 } ;
        char Descricao[ 150 ] =  { 0 } ;
        char Aliquota[ 150 ] =  { 0 } ;
        char Quantidade[ 150 ] =  { 0 } ;
        char ValorUnitario[ 150 ] =  { 0 } ;
        char FlagAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;
        char MesaDestino[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_TRANSFERENCIAITEM pFunc;
        strcpy( MesaOrigem, hb_parc( 1 ) );
        strcpy( Codigo, hb_parc( 2 ) );
        strcpy( Descricao, hb_parc( 3 ) );
        strcpy( Aliquota, hb_parc( 4 ) );
        strcpy( Quantidade, hb_parc( 5 ) );
        strcpy( ValorUnitario, hb_parc( 6 ) );
        strcpy( FlagAcrescimoDesconto, hb_parc( 7 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 8 ) );
        strcpy( MesaDestino, hb_parc( 9 ) );

        pFunc = (_BEMATECH_FIR_TRANSFERENCIAITEM) GetProcAddress(handle, "Bematech_FIR_TransferenciaItem");
        hb_retni(pFunc( MesaOrigem , Codigo , Descricao , Aliquota , Quantidade , ValorUnitario , FlagAcrescimoDesconto , ValorAcrescimoDesconto , MesaDestino  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_RELATORIOMESASABERTAS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT TipoRelatorio =  hb_parni( 1 );

        _BEMATECH_FIR_RELATORIOMESASABERTAS pFunc;
        
        pFunc = (_BEMATECH_FIR_RELATORIOMESASABERTAS) GetProcAddress(handle, "Bematech_FIR_RelatorioMesasAbertas");
        hb_retni(pFunc( TipoRelatorio  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_IMPRIMECARDAPIO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FIR_IMPRIMECARDAPIO pFunc;
        
        pFunc = (_BEMATECH_FIR_IMPRIMECARDAPIO) GetProcAddress(handle, "Bematech_FIR_ImprimeCardapio");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_RELATORIOMESASABERTASSERIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FIR_RELATORIOMESASABERTASSERIAL pFunc;
        
        pFunc = (_BEMATECH_FIR_RELATORIOMESASABERTASSERIAL) GetProcAddress(handle, "Bematech_FIR_RelatorioMesasAbertasSerial");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_CARDAPIOPELASERIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FIR_CARDAPIOPELASERIAL pFunc;
        
        pFunc = (_BEMATECH_FIR_CARDAPIOPELASERIAL) GetProcAddress(handle, "Bematech_FIR_CardapioPelaSerial");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_REGISTROVENDASERIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Mesa[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_REGISTROVENDASERIAL pFunc;
        strcpy( Mesa, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FIR_REGISTROVENDASERIAL) GetProcAddress(handle, "Bematech_FIR_RegistroVendaSerial");
        hb_retni(pFunc( Mesa  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_VERIFICAMEMORIALIVRE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Bytes[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_VERIFICAMEMORIALIVRE pFunc;
        strcpy( Bytes, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FIR_VERIFICAMEMORIALIVRE) GetProcAddress(handle, "Bematech_FIR_VerificaMemoriaLivre");
        hb_retni(pFunc( Bytes  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_FECHACUPOMRESTAURANTE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 150 ] =  { 0 } ;
        char FlagAcrescimoDesconto[ 150 ] =  { 0 } ;
        char TipoAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorAcrescimoDesconto[ 150 ] =  { 0 } ;
        char ValorFormaPagto[ 150 ] =  { 0 } ;
        char Mensagem[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_FECHACUPOMRESTAURANTE pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( FlagAcrescimoDesconto, hb_parc( 2 ) );
        strcpy( TipoAcrescimoDesconto, hb_parc( 3 ) );
        strcpy( ValorAcrescimoDesconto, hb_parc( 4 ) );
        strcpy( ValorFormaPagto, hb_parc( 5 ) );
        strcpy( Mensagem, hb_parc( 6 ) );

        pFunc = (_BEMATECH_FIR_FECHACUPOMRESTAURANTE) GetProcAddress(handle, "Bematech_FIR_FechaCupomRestaurante");
        hb_retni(pFunc( FormaPagamento , FlagAcrescimoDesconto , TipoAcrescimoDesconto , ValorAcrescimoDesconto , ValorFormaPagto , Mensagem  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FIR_FECHACUPOMRESUMIDORESTAURANTE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL FLAGS DC_CALL_STD");

    if (handle)
    {
        char FormaPagamento[ 150 ] =  { 0 } ;
        char Mensagem[ 150 ] =  { 0 } ;

        _BEMATECH_FIR_FECHACUPOMRESUMIDORESTAURANTE pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( Mensagem, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FIR_FECHACUPOMRESUMIDORESTAURANTE) GetProcAddress(handle, "Bematech_FIR_FechaCupomResumidoRestaurante");
        hb_retni(pFunc( FormaPagamento , Mensagem  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ABREBILHETEPASSAGEM )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ImprimeValorFinal[ 150 ] =  { 0 } ;
        char ImprimeEnfatizado[ 150 ] =  { 0 } ;
        char Embarque[ 150 ] =  { 0 } ;
        char Destino[ 150 ] =  { 0 } ;
        char Linha[ 150 ] =  { 0 } ;
        char Prefixo[ 150 ] =  { 0 } ;
        char Agente[ 150 ] =  { 0 } ;
        char Agencia[ 150 ] =  { 0 } ;
        char Data[ 150 ] =  { 0 } ;
        char Hora[ 150 ] =  { 0 } ;
        char Poltrona[ 150 ] =  { 0 } ;
        char Plataforma[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ABREBILHETEPASSAGEM pFunc;
        strcpy( ImprimeValorFinal, hb_parc( 1 ) );
        strcpy( ImprimeEnfatizado, hb_parc( 2 ) );
        strcpy( Embarque, hb_parc( 3 ) );
        strcpy( Destino, hb_parc( 4 ) );
        strcpy( Linha, hb_parc( 5 ) );
        strcpy( Prefixo, hb_parc( 6 ) );
        strcpy( Agente, hb_parc( 7 ) );
        strcpy( Agencia, hb_parc( 8 ) );
        strcpy( Data, hb_parc( 9 ) );
        strcpy( Hora, hb_parc( 10 ) );
        strcpy( Poltrona, hb_parc( 11 ) );
        strcpy( Plataforma, hb_parc( 12 ) );

        pFunc = (_BEMATECH_FI_ABREBILHETEPASSAGEM) GetProcAddress(handle, "Bematech_FI_AbreBilhetePassagem");
        hb_retni(pFunc( ImprimeValorFinal , ImprimeEnfatizado , Embarque , Destino , Linha , Prefixo , Agente , Agencia , Data , Hora , Poltrona , Plataforma  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_PROGRAMAMOEDASINGULAR )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char MoedaSingular[ 150 ] =  { 0 } ;

        _BEMATECH_FI_PROGRAMAMOEDASINGULAR pFunc;
        strcpy( MoedaSingular, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_PROGRAMAMOEDASINGULAR) GetProcAddress(handle, "Bematech_FI_ProgramaMoedaSingular");
        hb_retni(pFunc( MoedaSingular  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_PROGRAMAMOEDAPLURAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char MoedaPlural[ 150 ] =  { 0 } ;

        _BEMATECH_FI_PROGRAMAMOEDAPLURAL pFunc;
        strcpy( MoedaPlural, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_PROGRAMAMOEDAPLURAL) GetProcAddress(handle, "Bematech_FI_ProgramaMoedaPlural");
        hb_retni(pFunc( MoedaPlural  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_CANCELAIMPRESSAOCHEQUE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_CANCELAIMPRESSAOCHEQUE pFunc;
        
        pFunc = (_BEMATECH_FI_CANCELAIMPRESSAOCHEQUE) GetProcAddress(handle, "Bematech_FI_CancelaImpressaoCheque");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICASTATUSCHEQUE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        INT StatusCheque =  hb_parni( 1 );

        _BEMATECH_FI_VERIFICASTATUSCHEQUE pFunc;
        
        pFunc = (_BEMATECH_FI_VERIFICASTATUSCHEQUE) GetProcAddress(handle, "Bematech_FI_VerificaStatusCheque");
        hb_retni(pFunc( StatusCheque  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_IMPRIMECHEQUE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Banco[ 150 ] =  { 0 } ;
        char Valor[ 150 ] =  { 0 } ;
        char Favorecido[ 150 ] =  { 0 } ;
        char Cidade[ 150 ] =  { 0 } ;
        char Data[ 150 ] =  { 0 } ;
        char Mensagem[ 150 ] =  { 0 } ;

        _BEMATECH_FI_IMPRIMECHEQUE pFunc;
        strcpy( Banco, hb_parc( 1 ) );
        strcpy( Valor, hb_parc( 2 ) );
        strcpy( Favorecido, hb_parc( 3 ) );
        strcpy( Cidade, hb_parc( 4 ) );
        strcpy( Data, hb_parc( 5 ) );
        strcpy( Mensagem, hb_parc( 6 ) );

        pFunc = (_BEMATECH_FI_IMPRIMECHEQUE) GetProcAddress(handle, "Bematech_FI_ImprimeCheque");
        hb_retni(pFunc( Banco , Valor , Favorecido , Cidade , Data , Mensagem  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_INCLUICIDADEFAVORECIDO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Cidade[ 150 ] =  { 0 } ;
        char Favorecido[ 150 ] =  { 0 } ;

        _BEMATECH_FI_INCLUICIDADEFAVORECIDO pFunc;
        strcpy( Cidade, hb_parc( 1 ) );
        strcpy( Favorecido, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_INCLUICIDADEFAVORECIDO) GetProcAddress(handle, "Bematech_FI_IncluiCidadeFavorecido");
        hb_retni(pFunc( Cidade , Favorecido  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_IMPRIMECOPIACHEQUE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_IMPRIMECOPIACHEQUE pFunc;
        
        pFunc = (_BEMATECH_FI_IMPRIMECOPIACHEQUE) GetProcAddress(handle, "Bematech_FI_ImprimeCopiaCheque");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ABREPORTASERIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_ABREPORTASERIAL pFunc;
        
        pFunc = (_BEMATECH_FI_ABREPORTASERIAL) GetProcAddress(handle, "Bematech_FI_AbrePortaSerial");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FECHAPORTASERIAL )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_FECHAPORTASERIAL pFunc;
        
        pFunc = (_BEMATECH_FI_FECHAPORTASERIAL) GetProcAddress(handle, "Bematech_FI_FechaPortaSerial");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_MAPARESUMOAS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_MAPARESUMOAS pFunc;
        
        pFunc = (_BEMATECH_FI_MAPARESUMOAS) GetProcAddress(handle, "Bematech_FI_MapaResumoas");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_ABERTURADODIA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char ValorCompra[ 150 ] =  { 0 } ;
        char FormaPagamento[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ABERTURADODIA pFunc;
        strcpy( ValorCompra, hb_parc( 1 ) );
        strcpy( FormaPagamento, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_ABERTURADODIA) GetProcAddress(handle, "Bematech_FI_AberturaDoDia");
        hb_retni(pFunc( ValorCompra , FormaPagamento  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FECHAMENTODODIA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_FECHAMENTODODIA pFunc;
        
        pFunc = (_BEMATECH_FI_FECHAMENTODODIA) GetProcAddress(handle, "Bematech_FI_FechamentoDoDia");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_IMPRIMECONFIGURACOESIMPRESSORA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_IMPRIMECONFIGURACOESIMPRESSORA pFunc;
        
        pFunc = (_BEMATECH_FI_IMPRIMECONFIGURACOESIMPRESSORA) GetProcAddress(handle, "Bematech_FI_ImprimeConfiguracoesImpressora");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_IMPRIMEDEPARTAMENTOS )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_IMPRIMEDEPARTAMENTOS pFunc;
        
        pFunc = (_BEMATECH_FI_IMPRIMEDEPARTAMENTOS) GetProcAddress(handle, "Bematech_FI_ImprimeDepartamentos");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_RELATORIOTIPO60ANALITICO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_RELATORIOTIPO60ANALITICO pFunc;
        
        pFunc = (_BEMATECH_FI_RELATORIOTIPO60ANALITICO) GetProcAddress(handle, "Bematech_FI_RelatorioTipo60Analitico");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_RELATORIOTIPO60MESTRE )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_RELATORIOTIPO60MESTRE pFunc;
        
        pFunc = (_BEMATECH_FI_RELATORIOTIPO60MESTRE) GetProcAddress(handle, "Bematech_FI_RelatorioTipo60Mestre");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VERIFICAIMPRESSORALIGADA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_VERIFICAIMPRESSORALIGADA pFunc;
        
        pFunc = (_BEMATECH_FI_VERIFICAIMPRESSORALIGADA) GetProcAddress(handle, "Bematech_FI_VerificaImpressoraLigada");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_LEARQUIVORETORNO )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char sRetorno[ 150 ] =  { 0 } ;

        _BEMATECH_FI_LEARQUIVORETORNO pFunc;
        strcpy( sRetorno, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_LEARQUIVORETORNO) GetProcAddress(handle, "Bematech_FI_LeArquivoRetorno");
        hb_retni(pFunc( sRetorno  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FECHARELATORIOXOUZ )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        
        _BEMATECH_FI_FECHARELATORIOXOUZ pFunc;
        
        pFunc = (_BEMATECH_FI_FECHARELATORIOXOUZ) GetProcAddress(handle, "Bematech_FI_FechaRelatorioXouZ");
        hb_retni(pFunc(  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_RETORNOIMPRESSORA)
{
    short ACK ;
    short ST1 ;
    short ST2 ;
    int Res;

    Res = Bematech_FI_RetornoImpressora(&ACK, &ST1, &ST2  );
    hb_storni((int)ACK,1);
    hb_storni((int)ST1,2);
    hb_storni((int)ST2,3);

    hb_retni(Res);

}

HB_FUNC( BEMATECH_FI_RETORNOIMPRESSORAMFD) 
{
    short ACK ;
    short ST1 ;
    short ST2 ;
    short ST3 ;
    int Res;

    Res = Bematech_FI_RetornoImpressoraMFD(&ACK, &ST1, &ST2, &ST3  );
    hb_storni((int)ACK,1);
    hb_storni((int)ST1,2);
    hb_storni((int)ST2,3);
    hb_storni((int)ST3,4);

    hb_retni(Res);

}


HB_FUNC( BEMATECH_FI_VERIFICAESTADOIMPRESSORA)
{
    short int ACK ;
    short int ST1 ;
    short int ST2 ;

    hb_retni(Bematech_FI_VerificaEstadoImpressora(&ACK, &ST1, &ST2  ));
    hb_storni(ACK,1);
    hb_storni(ST1,2);
    hb_storni(ST2,3);

}

HB_FUNC( BEMATECH_FI_MONITORAMENTOPAPEL)
{

    int ACK = hb_parni( 1 ); 
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_MONITORAMENTOPAPEL pFunc;

        pFunc = (_BEMATECH_FI_MONITORAMENTOPAPEL) GetProcAddress(handle, "Bematech_FI_MonitoramentoPapel");
        hb_retni(pFunc(&ACK  ));
        hb_storni(ACK,1);

        FreeLibrary( handle );  
    }        

}

HB_FUNC( BEMATECH_FI_VERIFICAESTADOGAVETA)
{
    short int ACK = hb_parni( 1 ); 
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_VERIFICAESTADOGAVETA pFunc;

        pFunc = (_BEMATECH_FI_VERIFICAESTADOGAVETA) GetProcAddress(handle, "Bematech_FI_VerificaEstadoGaveta");
        hb_retni(pFunc(&ACK  ));
        hb_storni(ACK,1);

        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_FLAGSFISCAIS)
{
    int ACK = hb_parni( 1 );
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_FLAGSFISCAIS pFunc;

        pFunc = (_BEMATECH_FI_FLAGSFISCAIS) GetProcAddress(handle, "Bematech_FI_FlagsFiscais");
        hb_retni(pFunc(&ACK  ));
        hb_storni(ACK,1);

        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_VENDEITEM )
{

    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_VENDEITEM pFunc;
        char a[150] = { 0 };
        char s[150] = { 0 };
        char d[150] = { 0 };
        char f[150] = { 0 };
        char g[150] = { 0 };
        char h[150] = { 0 };
        char j[150] = { 0 };
        char k[150] = { 0 };
        strcpy( a , hb_parcx( 1 ) ) ;
        strcpy( s , hb_parcx( 2 ) ) ;
        strcpy( d , hb_parcx( 3 ) ) ;
        strcpy( f , hb_parcx( 4 ) ) ;
        strcpy( g , hb_parcx( 5 ) ) ;
        strcpy( h , hb_parcx( 7 ) ) ;
        strcpy( j , hb_parcx( 8 ) ) ;
        strcpy( k , hb_parcx( 9 ) ) ;
                              
        pFunc = (_BEMATECH_FI_VENDEITEM) GetProcAddress(handle, "Bematech_FI_VendeItem");
        hb_retni(pFunc( a, s, d, f, g, hb_parni( 6 ), h, j, k  ));


        FreeLibrary( handle );  
    }        
}
/*
HB_FUNC( BEMATECH_FI_VENDEITEMARREDONDAMENTOMFD )
{

    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_VENDEITEMARREDONDAMENTOMFD pFunc;
        char a[150] = { 0 };
        char s[250] = { 0 };
        char d[150] = { 0 };
        char f[150] = { 0 };
        char g[150] = { 0 };
        char h[150] = { 0 };
        char j[150] = { 0 };
        char k[150] = { 0 };
        strcpy( a , hb_parcx( 1 ) ) ;
        strcpy( s , hb_parcx( 2 ) ) ;
        strcpy( d , hb_parcx( 3 ) ) ;
        strcpy( f , hb_parcx( 4 ) ) ;
        strcpy( g , hb_parcx( 5 ) ) ;
        strcpy( h , hb_parcx( 6 ) ) ;
        strcpy( j , hb_parcx( 7 ) ) ;
        strcpy( k , hb_parcx( 8 ) ) ;

        pFunc = (_BEMATECH_FI_VENDEITEMARREDONDAMENTOMFD) GetProcAddress(handle, "Bematech_FI_VendeItemArredondamentoMFD");
        hb_retni(pFunc( a, s, d, f, g, h, j, k, hb_parl(9) ));

        FreeLibrary( handle );
    }
}
*/
HB_FUNC( BEMATECH_FI_INICIAFECHAMENTOCUPOM )
{

    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        _BEMATECH_FI_INICIAFECHAMENTOCUPOM pFunc;
        char a[150] = { 0 };
        char s[150] = { 0 };
        char d[150] = { 0 };
        strcpy( a , hb_parcx( 1 ) ) ;
        strcpy( s , hb_parcx( 2 ) ) ;
        strcpy( d , hb_parcx( 3 ) ) ;

        pFunc = (_BEMATECH_FI_INICIAFECHAMENTOCUPOM) GetProcAddress(handle, "Bematech_FI_IniciaFechamentoCupom");
        hb_retni(pFunc( a, s, d ));

        FreeLibrary( handle );  
    }        

}

HB_FUNC( BEMATECH_FI_ALTERASIMBOLOMOEDA)
{
  char Moeda[150] = {0 } ;
  strcpy( Moeda , hb_parcx( 1 ) ) ;
  hb_retni(Bematech_FI_AlteraSimboloMoeda( Moeda));
}

HB_FUNC( BEMATECH_FI_RELATORIOGERENCIALTEF )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Texto[ 618 ] =  { 0 } ; // Luiz Henrique 30/11/2005 - estava 150 e o certo é 618

        _BEMATECH_FI_RELATORIOGERENCIALTEF pFunc;
        strcpy( Texto, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_RELATORIOGERENCIALTEF) GetProcAddress(handle, "Bematech_FI_RelatorioGerencialTEF");
        hb_retni(pFunc( Texto  ));
        FreeLibrary( handle );
    }
}
HB_FUNC( BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADOTEF )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Texto[ 619 ] =  { 0 } ;

        _BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADOTEF pFunc;
        strcpy( Texto, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADOTEF) GetProcAddress(handle, "Bematech_FI_UsaComprovanteNaoFiscalVinculadoTEF");
        hb_retni(pFunc( Texto  ));
        FreeLibrary( handle );
    }
}

HB_FUNC( BEMATECH_FI_INICIAMODOTEF )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {

        _BEMATECH_FI_INICIAMODOTEF pFunc;

        pFunc = (_BEMATECH_FI_INICIAMODOTEF) GetProcAddress(handle, "Bematech_FI_IniciaModoTEF");
        hb_retni(pFunc(  ));
        FreeLibrary( handle );
    }
}


HB_FUNC( BEMATECH_FI_FINALIZAMODOTEF )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {

        _BEMATECH_FI_FINALIZAMODOTEF pFunc;

        pFunc = (_BEMATECH_FI_FINALIZAMODOTEF) GetProcAddress(handle, "Bematech_FI_FinalizaModoTEF");
        hb_retni(pFunc(  ));
        FreeLibrary( handle );
    }
}

HB_FUNC( BEMATECH_FI_VERIFICAREDUCAOZAUTOMATICA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        int FLAG = hb_parni( 1 );
       
        _BEMATECH_FI_VERIFICAREDUCAOZAUTOMATICA pFunc;

        pFunc = (_BEMATECH_FI_VERIFICAREDUCAOZAUTOMATICA) GetProcAddress(handle, "Bematech_FI_VerificaReducaoZAutomatica");
        hb_retni(pFunc(&FLAG));
        hb_storni(FLAG,1);

        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_DADOSSINTEGRA )
{
    char DataInicial[8] = {0};
    char DataFinal[8] = {0};
  
    strcpy(DataInicial, hb_parc(1));
    strcpy(DataFinal, hb_parc(2));
  
    hb_retni(Bematech_FI_DadosSintegra(DataInicial, DataFinal));    
}

HB_FUNC( BEMATECH_FI_ACIONAGUILHOTINAMFD )
{
  int ACK = hb_parni( 1 );
  HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");
  
  if (handle)
  {
    _BEMATECH_FI_ACIONAGUILHOTINAMFD pFunc;

    pFunc = (_BEMATECH_FI_ACIONAGUILHOTINAMFD) GetProcAddress(handle, "Bematech_FI_AcionaGuilhotinaMFD");
    hb_retni(pFunc(&ACK));
    hb_storni(ACK, 1);

    FreeLibrary( handle );  
  }        
}

HB_FUNC( BEMATECH_FI_ESTORNONAOFISCALVINCULADOMFD )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char Cpf[ 150 ] =  { 0 } ;
        char Nome[ 150 ] = { 0 } ;
        char Endereco[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ESTORNONAOFISCALVINCULADOMFD pFunc;
        strcpy( Cpf, hb_parc( 1 ) );
        strcpy( Nome, hb_parc( 2 ) );
        strcpy( Endereco, hb_parc( 3 ) );

        pFunc = (_BEMATECH_FI_ESTORNONAOFISCALVINCULADOMFD) GetProcAddress(handle, "Bematech_FI_EstornoNaoFiscalVinculadoMFD");
        hb_retni(pFunc( Cpf, Nome, Endereco ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_PROGRAMAFORMAPAGAMENTOMFD )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        char FormaPagamento[ 16 ] =  { 0 } ;
        char Valor[ 16 ] =  { 0 } ;

        _BEMATECH_FI_PROGRAMAFORMAPAGAMENTOMFD pFunc;
        strcpy( FormaPagamento, hb_parc( 1 ) );
        strcpy( Valor, hb_parc( 2 ) );

        pFunc = (_BEMATECH_FI_PROGRAMAFORMAPAGAMENTOMFD) GetProcAddress(handle, "Bematech_FI_ProgramaFormaPagamentoMFD");
        hb_retni(pFunc( FormaPagamento , Valor  ));    
        FreeLibrary( handle );  
    }        
}

HB_FUNC( BEMATECH_FI_INFOBALANCA )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {   
    	  char Porta[ 5 ]= { 0 };
        int Modelo;
        char Peso[ 7 ] = { 0 };
        char PrecoKilo[ 6 ]= { 0 };
        char Total[ 7 ]= { 0 };                

        _BEMATECH_FI_INFOBALANCA pFunc;
        strcpy( Porta, hb_parc( 1 ) );

        pFunc = (_BEMATECH_FI_INFOBALANCA) GetProcAddress(handle, "Bematech_FI_InfoBalanca");
        hb_retni(pFunc( Porta , hb_parni(2), Peso, PrecoKilo, Total ));
        hb_storc((char*)Peso,3);
        hb_storc((char*)PrecoKilo,4);
        hb_storc((char*)Total,5 );
        
        FreeLibrary( handle );  
    }            
   
}