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

typedef int (WINAPI * _BEMATECH_FI_ALTERASIMBOLOMOEDA)(LPSTR Moeda );
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_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_ACIONAGUILHOTINAMFD)( short int* Tipo_Impr  );
typedef int (WINAPI * _BEMATECH_FI_VERIFICATOTALIZADORESPARCIAIS)( LPSTR Totalizadores  );
typedef int (WINAPI * _BEMATECH_FI_RETORNOALIQUOTAS)( LPSTR Aliquota  );
typedef int (WINAPI * _BEMATECH_FI_DADOSULTIMAREDUCAO)( LPSTR 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_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_RETORNIALIQUITAS) (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_ABRECUPOMMFD)( LPSTR CGC_CPF, LPSTR Nome, LPSTR Endereco  );
typedef int (WINAPI * _BEMATECH_FI_INICIAFECHAMENTOCUPOMMFD) (char* AcrescimoDesconto, char* TipoAcrescimoDesconto, char* ValorAcrescimo, char* ValorDesconto);
typedef int (WINAPI * _BEMATECH_FI_EFETUAFORMAPAGAMENTOMFD)( LPSTR FormaPagamento , LPSTR  ValorFormaPagamento, LPSTR Parcelas, LPSTR DescricaoFormaPagto  );
typedef int (WINAPI * _BEMATECH_FI_CANCELACUPOMMFD)( LPSTR CGC_CPF, LPSTR Nome, LPSTR Endereco  );
typedef int (WINAPI * _BEMATECH_FI_PROGRAMAFORMAPAGAMENTOMFD)( LPSTR FormaPagamento , LPSTR OperacaoTef );
typedef int (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALDATAMFD)( LPSTR DataInicial , LPSTR  DataFinal, LPSTR FlagLeitura );
typedef int (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAOMFD)( LPSTR ReducaoInicial , LPSTR  ReducaoFinal, LPSTR FlagLeitura   );
typedef int (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALDATAMFD)( LPSTR DataInicial , LPSTR  DataFinal, LPSTR FlagLeitura   );
typedef int (WINAPI * _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALREDUCAOMFD)( LPSTR ReducaoInicial , LPSTR  ReducaoFinal, LPSTR FlagLeitura   );
typedef int (WINAPI * _BEMATECH_FI_DADOSULTIMAREDUCAOMFD)( LPSTR DadosReducao  );
typedef int (WINAPI * _BEMATECH_FI_VERIFICAFORMASPAGAMENTOMFD)( LPSTR FormasPagamento );
typedef int (WINAPI * _BEMATECH_FI_DATAMOVIMENTOULTIMAREDUCAOMFD)( LPSTR DadosMovimento );

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

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

        _BEMATECH_FI_PROGRAMAFORMAPAGAMENTOMFD pFunc;
        strcpy_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( OperacaoTef, sizeof(OperacaoTef), hb_parcx( 2 ) );

        pFunc = (_BEMATECH_FI_PROGRAMAFORMAPAGAMENTOMFD) GetProcAddress(handle, "Bematech_FI_ProgramaFormaPagamentoMFD");
        hb_retni(pFunc( FormaPagamento , OperacaoTef ));
        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_s( Aliquota, sizeof(Aliquota), hb_parcx( 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_s( Departamento, sizeof(Departamento), hb_parcx( 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_s( Totalizador, sizeof(Totalizador), hb_parcx( 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_s( CGC_CPF, sizeof(CGC_CPF), hb_parcx( 1 ) );

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

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

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

        _BEMATECH_FI_ABRECUPOMMFD pFunc;
        strcpy_s( CGC_CPF, sizeof(CGC_CPF), hb_parcx( 1 ) );
        strcpy_s( Nome, sizeof(Nome), hb_parcx( 2 ) );
        strcpy_s( Endereco, sizeof(Endereco), hb_parcx( 3 ) );

        pFunc = (_BEMATECH_FI_ABRECUPOMMFD) GetProcAddress(handle, "Bematech_FI_AbreCupomMFD");
        hb_retni(pFunc( CGC_CPF, Nome, Endereco  ));
        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_s( Codigo, sizeof(Codigo), hb_parcx( 1 ) );
        strcpy_s( Descricao, sizeof(Descricao), hb_parcx( 2 ) );
        strcpy_s( Aliquota, sizeof(Aliquota), hb_parcx( 3 ) );
        strcpy_s( ValorUnitario, sizeof(ValorUnitario), hb_parcx( 4 ) );
        strcpy_s( Quantidade, sizeof(Quantidade), hb_parcx( 5 ) );
        strcpy_s( Acrescimo, sizeof(Acrescimo), hb_parcx( 6 ) );
        strcpy_s( Desconto, sizeof(Desconto), hb_parcx( 7 ) );
        strcpy_s( IndiceDepartamento, sizeof(IndiceDepartamento), hb_parcx( 8 ) );
        strcpy_s( UnidadeMedida, sizeof(UnidadeMedida), hb_parcx( 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_s( NumeroItem, sizeof(NumeroItem), hb_parcx( 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 );
    }
}


// DAQUI PRA BAIXO


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

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

        _BEMATECH_FI_CANCELACUPOMMFD pFunc;
        strcpy_s( CGC_CPF, sizeof(CGC_CPF), hb_parcx( 1 ) );
        strcpy_s( Nome, sizeof(Nome), hb_parcx( 2 ) );
        strcpy_s( Endereco, sizeof(Endereco), hb_parcx( 3 ) );

        pFunc = (_BEMATECH_FI_CANCELACUPOMMFD) GetProcAddress(handle, "Bematech_FI_CancelaCupomMFD");
        hb_retni(pFunc( CGC_CPF, Nome, Endereco ));
        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_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( Mensagem, sizeof(Mensagem), hb_parcx( 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_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( AcrescimoDesconto, sizeof(AcrescimoDesconto), hb_parcx( 2 ) );
        strcpy_s( TipoAcrescimoDesconto, sizeof(TipoAcrescimoDesconto), hb_parcx( 3 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 4 ) );
        strcpy_s( ValorPago, sizeof(ValorPago), hb_parcx( 5 ) );
        strcpy_s( Mensagem, sizeof(Mensagem), hb_parcx( 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_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( ValorFormaPagamento, sizeof(ValorFormaPagamento), hb_parcx( 2 ) );

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

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

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

        _BEMATECH_FI_EFETUAFORMAPAGAMENTOMFD pFunc;
        strcpy_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( ValorFormaPagamento, sizeof(ValorFormaPagamento), hb_parcx( 2 ) );
        strcpy_s( Parcelas, sizeof(Parcelas), hb_parcx( 3 ) );
        strcpy_s( DescricaoFormaPagto, sizeof(DescricaoFormaPagto), hb_parcx( 4 ) );

        pFunc = (_BEMATECH_FI_EFETUAFORMAPAGAMENTOMFD) GetProcAddress(handle, "Bematech_FI_EfetuaFormaPagamentoMFD");
        hb_retni(pFunc( FormaPagamento , ValorFormaPagamento, Parcelas, DescricaoFormaPagto  ));
        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_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( ValorFormaPagamento, sizeof(ValorFormaPagamento), hb_parcx( 2 ) );
        strcpy_s( DescricaoFormaPagto, sizeof(DescricaoFormaPagto), hb_parcx( 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[ 390 ] =  { 0 } ;

        _BEMATECH_FI_TERMINAFECHAMENTOCUPOM pFunc;
        strcpy_s( Mensagem, sizeof(Mensagem), hb_parcx( 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_s( FormaOrigem, sizeof(FormaOrigem), hb_parcx( 1 ) );
        strcpy_s( FormaDestino, sizeof(FormaDestino), hb_parcx( 2 ) );
        strcpy_s( Valor, sizeof(Valor), hb_parcx( 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_s( UnidadeMedida, sizeof(UnidadeMedida), hb_parcx( 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_s( Descricao, sizeof(Descricao), hb_parcx( 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_s( Data, sizeof(Data), hb_parcx( 1 ) );
        strcpy_s( Hora, sizeof(Hora), hb_parcx( 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[ 150 ] =  { 0 } ;

        _BEMATECH_FI_RELATORIOGERENCIAL pFunc;
        strcpy_s( Texto, sizeof(Texto), hb_parcx( 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_s( DataInicial, sizeof(DataInicial), hb_parcx( 1 ) );
        strcpy_s( DataFinal, sizeof(DataFinal), hb_parcx( 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_s( ReducaoInicial, sizeof(ReducaoInicial), hb_parcx( 1 ) );
        strcpy_s( ReducaoFinal, sizeof(ReducaoFinal), hb_parcx( 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_s( DataInicial, sizeof(DataInicial), hb_parcx( 1 ) );
        strcpy_s( DataFinal, sizeof(DataFinal), hb_parcx( 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_s( ReducaoInicial, sizeof(ReducaoInicial), hb_parcx( 1 ) );
        strcpy_s( ReducaoFinal, sizeof(ReducaoFinal), hb_parcx( 2 ) );

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


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

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

        _BEMATECH_FI_LEITURAMEMORIAFISCALDATAMFD pFunc;
        strcpy_s( DataInicial, sizeof(DataInicial), hb_parcx( 1 ) );
        strcpy_s( DataFinal, sizeof(DataFinal), hb_parcx( 2 ) );
        strcpy_s( FlagLeitura, sizeof(FlagLeitura), hb_parcx( 3 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALDATAMFD) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalDataMFD");
        hb_retni(pFunc( DataInicial , DataFinal, FlagLeitura ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAOMFD pFunc;
        strcpy_s( ReducaoInicial, sizeof(ReducaoInicial), hb_parcx( 1 ) );
        strcpy_s( ReducaoFinal, sizeof(ReducaoFinal), hb_parcx( 2 ) );
        strcpy_s( FlagLeitura, sizeof(FlagLeitura), hb_parcx( 3 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALREDUCAOMFD) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalReducaoMFD");
        hb_retni(pFunc( ReducaoInicial , ReducaoFinal, FlagLeitura ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALDATAMFD pFunc;
        strcpy_s( DataInicial, sizeof(DataInicial), hb_parcx( 1 ) );
        strcpy_s( DataFinal, sizeof(DataFinal), hb_parcx( 2 ) );
        strcpy_s( FlagLeitura, sizeof(FlagLeitura), hb_parcx( 3 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALSERIALDATAMFD) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalSerialDataMFD");
        hb_retni(pFunc( DataInicial , DataFinal, FlagLeitura ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_LEITURAMEMORIAFISCALSERIALREDUCAOMFD pFunc;
        strcpy_s( ReducaoInicial, sizeof(ReducaoInicial), hb_parcx( 1 ) );
        strcpy_s( ReducaoFinal, sizeof(ReducaoFinal), hb_parcx( 2 ) );
        strcpy_s( FlagLeitura, sizeof(FlagLeitura), hb_parcx( 3 ) );

        pFunc = (_BEMATECH_FI_LEITURAMEMORIAFISCALSERIALREDUCAOMFD) GetProcAddress(handle, "Bematech_FI_LeituraMemoriaFiscalSerialReducaoMFD");
        hb_retni(pFunc( ReducaoInicial , ReducaoFinal, FlagLeitura  ));
        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_s( IndiceTotalizador, sizeof(IndiceTotalizador), hb_parcx( 1 ) );
        strcpy_s( Valor, sizeof(Valor), hb_parcx( 2 ) );
        strcpy_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 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[ 150 ] =  { 0 } ;
        char Valor[ 150 ] =  { 0 } ;
        char NumeroCupom[ 150 ] =  { 0 } ;

        _BEMATECH_FI_ABRECOMPROVANTENAOFISCALVINCULADO pFunc;
        strcpy_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( Valor, sizeof(Valor), hb_parcx( 2 ) );
        strcpy_s( NumeroCupom, sizeof(NumeroCupom), hb_parcx( 3 ) );

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

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

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

        _BEMATECH_FI_USACOMPROVANTENAOFISCALVINCULADO pFunc;
        strcpy_s( Texto, sizeof(Texto), hb_parcx( 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_s( Valor, sizeof(Valor), hb_parcx( 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_s( Valor, sizeof(Valor), hb_parcx( 1 ) );
        strcpy_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 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)
    {
        _BEMATECH_FI_NUMEROSERIE pFunc;
        char a[ 150 ] = { 0 };
        pFunc = (_BEMATECH_FI_NUMEROSERIE) GetProcAddress(handle, "Bematech_FI_NumeroSerie");
        strcpy_s( a, sizeof(a), hb_parcx( 1 ));
        hb_retni(pFunc( a));
        hb_storc((char*)a,1);
        FreeLibrary( handle );
    }
}

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

    if (handle)
    {
        _BEMATECH_FI_NUMEROSERIEMFD pFunc;
        char a[ 150 ] = { 0 };
        pFunc = (_BEMATECH_FI_NUMEROSERIEMFD) GetProcAddress(handle, "Bematech_FI_NumeroSerieMFD");
        strcpy_s( a, sizeof(a), hb_parcx( 1 ));
        hb_retni(pFunc( a));
        hb_storc((char*)a,1);
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_SUBTOTAL pFunc;
        strcpy_s( SubTotal, sizeof(SubTotal), hb_parcx( 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;
        strcpy_s( NumeroCupom, sizeof(NumeroCupom), hb_parcx( 1 ) );

        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_s( SimboloMoeda, sizeof(SimboloMoeda), hb_parcx( 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_s( Minutos, sizeof(Minutos), hb_parcx( 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_s( Minutos, sizeof(Minutos), hb_parcx( 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_s( Modo, sizeof(Modo), hb_parcx( 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_s( Flag, sizeof(Flag), hb_parcx( 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[ 150 ] =  { 0 } ;

        _BEMATECH_FI_VALORPAGOULTIMOCUPOM pFunc;
        strcpy_s( ValorCupom, sizeof(ValorCupom), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_VALORPAGOULTIMOCUPOM) GetProcAddress(handle, "Bematech_FI_ValorPagoUltimoCupom");
        hb_retni(pFunc( ValorCupom  ));
        FreeLibrary( handle );
    }
}

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

    if (handle)
    {
        _BEMATECH_FI_DATAHORAIMPRESSORA pFunc;
        char a[ 150 ] = { 0 };
        char b[ 150 ] = { 0 };
        pFunc = (_BEMATECH_FI_DATAHORAIMPRESSORA) GetProcAddress(handle, "Bematech_FI_DataHoraImpressora");
        strcpy_s( a, sizeof(a), hb_parcx( 1 ));
        strcpy_s( b, sizeof(b), hb_parcx( 2 ));
        hb_retni(pFunc( a, b));
        hb_storc( ( char * ) a , 1 );
        hb_storc( ( char * ) b , 2 );
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_CONTADORESTOTALIZADORESNAOFISCAIS pFunc;
        strcpy_s( Contadores, sizeof(Contadores), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_CONTADORESTOTALIZADORESNAOFISCAIS) GetProcAddress(handle, "Bematech_FI_ContadoresTotalizadoresNaoFiscais");
        hb_retni(pFunc( Contadores  ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_VERIFICATOTALIZADORESNAOFISCAIS pFunc;
        strcpy_s( Totalizadores, sizeof(Totalizadores), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICATOTALIZADORESNAOFISCAIS) GetProcAddress(handle, "Bematech_FI_VerificaTotalizadoresNaoFiscais");
        hb_retni(pFunc( Totalizadores  ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_DATAHORAREDUCAO pFunc;
        strcpy_s( Data, sizeof(Data), hb_parcx( 1 ) );
        strcpy_s( Hora, sizeof(Hora), hb_parcx( 2 ) );

        pFunc = (_BEMATECH_FI_DATAHORAREDUCAO) GetProcAddress(handle, "Bematech_FI_DataHoraReducao");
        hb_retni(pFunc( Data , Hora  ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_DATAMOVIMENTO pFunc;
        strcpy_s( Data, sizeof(Data), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_DATAMOVIMENTO) GetProcAddress(handle, "Bematech_FI_DataMovimento");
        hb_retni(pFunc( Data  ));
        hb_storc((char*)Data,1);
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_VERIFICATRUNCAMENTO pFunc;
        strcpy_s( Flag, sizeof(Flag), hb_parcx( 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_s( ValorAcrescimos, sizeof(ValorAcrescimos), hb_parcx( 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_s( ContadorPa, sizeof(ContadorPa), hb_parcx( 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_s( Flag, sizeof(Flag), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICAALIQUOTAISS) GetProcAddress(handle, "Bematech_FI_VerificaAliquotaIss");
        hb_retni(pFunc( Flag  ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_VERIFICAFORMASPAGAMENTO pFunc;
        strcpy_s( Forma, sizeof(Forma), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICAFORMASPAGAMENTO) GetProcAddress(handle, "Bematech_FI_VerificaFormasPagamento");
        hb_retni(pFunc( Forma  ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_VERIFICARECEBIMENTONAOFISCAL pFunc;
        strcpy_s( Recebimentos, sizeof(Recebimentos), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_VERIFICARECEBIMENTONAOFISCAL) GetProcAddress(handle, "Bematech_FI_VerificaRecebimentoNaoFiscal");
        hb_retni(pFunc( Recebimentos  ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_VERIFICADEPARTAMENTOS pFunc;
        strcpy_s( Departamentos, sizeof(Departamentos), hb_parcx( 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_ACIONAGUILHOTINAMFD )
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        short Tipo_Impr =  hb_parni( 1 );

        _BEMATECH_FI_ACIONAGUILHOTINAMFD pFunc;

        pFunc = (_BEMATECH_FI_ACIONAGUILHOTINAMFD) GetProcAddress(handle, "Bematech_FI_AcionaGuilhotinaMFD");
        hb_retni(pFunc( &Tipo_Impr ));
        hb_storni( ( short ) Tipo_Impr, 1 );
        FreeLibrary( handle );

    }
}

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

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

        _BEMATECH_FI_VERIFICATOTALIZADORESPARCIAIS pFunc;
        strcpy_s( Totalizadores, sizeof(Totalizadores), hb_parcx( 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 Aliquota[ 150 ] =  { 0 } ;

        _BEMATECH_FI_RETORNOALIQUOTAS pFunc;
        strcpy_s( Aliquota, sizeof(Aliquota), hb_parcx( 1 ) );

        pFunc = (_BEMATECH_FI_RETORNOALIQUOTAS) GetProcAddress(handle, "Bematech_FI_RetornoAliquotas");
        hb_retni(pFunc( Aliquota  ));
        hb_storc( (char*)Aliquota,1);
        FreeLibrary( handle );
    }
}

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

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

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

    if (handle)
    {
        char DadosReducao[ 1279 ] =  { 0 } ;
        _BEMATECH_FI_DADOSULTIMAREDUCAOMFD  pFunc;
        pFunc = (_BEMATECH_FI_DADOSULTIMAREDUCAOMFD) GetProcAddress(handle, "Bematech_FI_DadosUltimaReducaoMFD");
        hb_retni(pFunc( DadosReducao  ));
        hb_storc( (char*)DadosReducao,1);
        FreeLibrary( handle );
    }
}

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

    if (handle)
    {
        char DataMovimento[ 7 ] =  { 0 } ;
        _BEMATECH_FI_DATAMOVIMENTOULTIMAREDUCAOMFD  pFunc;
        pFunc = (_BEMATECH_FI_DATAMOVIMENTOULTIMAREDUCAOMFD) GetProcAddress(handle, "Bematech_FI_DataMovimentoUltimaReducaoMFD");
        hb_retni(pFunc( DataMovimento ));
        hb_storc( (char*)DataMovimento,1);
        FreeLibrary( handle );
    }
}


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

    if (handle)
    {
        char FormasPagamento[ 920 ] =  { 0 } ;
        _BEMATECH_FI_VERIFICAFORMASPAGAMENTOMFD  pFunc;
        pFunc = (_BEMATECH_FI_VERIFICAFORMASPAGAMENTOMFD) GetProcAddress(handle, "Bematech_FI_VerificaFormasPagamentoMFD");
        hb_retni(pFunc( FormasPagamento ));
        hb_storc( (char*)FormasPagamento,1);
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_VERIFICAINDICEALIQUOTASISS pFunc;
        strcpy_s( Flag, sizeof(Flag), hb_parcx( 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_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( Valor, sizeof(Valor), hb_parcx( 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_s( Totalizador, sizeof(Totalizador), hb_parcx( 1 ) );
        strcpy_s( Valor, sizeof(Valor), hb_parcx( 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_s( Parametros, sizeof(Parametros), hb_parcx( 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_s( Mesa, sizeof(Mesa), hb_parcx( 1 ) );
        strcpy_s( CGC_CPF, sizeof(CGC_CPF), hb_parcx( 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_s( Mesa, sizeof(Mesa), hb_parcx( 1 ) );
        strcpy_s( Codigo, sizeof(Codigo), hb_parcx( 2 ) );
        strcpy_s( Descricao, sizeof(Descricao), hb_parcx( 3 ) );
        strcpy_s( Aliquota, sizeof(Aliquota), hb_parcx( 4 ) );
        strcpy_s( Quantidade, sizeof(Quantidade), hb_parcx( 5 ) );
        strcpy_s( ValorUnitario, sizeof(ValorUnitario), hb_parcx( 6 ) );
        strcpy_s( FlagAcrescimoDesconto, sizeof(FlagAcrescimoDesconto), hb_parcx( 7 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 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_s( Mesa, sizeof(Mesa), hb_parcx( 1 ) );
        strcpy_s( Codigo, sizeof(Codigo), hb_parcx( 2 ) );
        strcpy_s( Descricao, sizeof(Descricao), hb_parcx( 3 ) );
        strcpy_s( Aliquota, sizeof(Aliquota), hb_parcx( 4 ) );
        strcpy_s( Quantidade, sizeof(Quantidade), hb_parcx( 5 ) );
        strcpy_s( ValorUnitario, sizeof(ValorUnitario), hb_parcx( 6 ) );
        strcpy_s( FlagAcrescimoDesconto, sizeof(FlagAcrescimoDesconto), hb_parcx( 7 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 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_s( Mesa, sizeof(Mesa), hb_parcx( 1 ) );
        strcpy_s( FlagAcrescimoDesconto, sizeof(FlagAcrescimoDesconto), hb_parcx( 2 ) );
        strcpy_s( TipoAcrescimoDesconto, sizeof(TipoAcrescimoDesconto), hb_parcx( 3 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 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_s( Mesa, sizeof(Mesa), hb_parcx( 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_s( FlagAcrescimoDesconto, sizeof(FlagAcrescimoDesconto), hb_parcx( 1 ) );
        strcpy_s( TipoAcrescimoDesconto, sizeof(TipoAcrescimoDesconto), hb_parcx( 2 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 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_s( MesaOrigem, sizeof(MesaOrigem), hb_parcx( 1 ) );
        strcpy_s( MesaDestino,sizeof(MesaDestino),  hb_parcx( 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_s( NumeroCup, sizeof(NumeroCup), hb_parcx( 1 ) );
        strcpy_s( ValorPago, sizeof(ValorPago), hb_parcx( 2 ) );
        strcpy_s( CGC_CPF, sizeof(CGC_CPF), hb_parcx( 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_s( NumeroCupons, sizeof(NumeroCupons), hb_parcx( 1 ) );
        strcpy_s( FlagAcrescimoDesconto, sizeof(FlagAcrescimoDesconto), hb_parcx( 2 ) );
        strcpy_s( TipoAcrescimoDesconto, sizeof(TipoAcrescimoDesconto), hb_parcx( 3 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 4 ) );
        strcpy_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 5 ) );
        strcpy_s( ValorFormaPagamento, sizeof(ValorFormaPagamento), hb_parcx( 6 ) );
        strcpy_s( ValorPagoCliente, sizeof(ValorPagoCliente), hb_parcx( 7 ) );
        strcpy_s( CGC_CPF, sizeof(CGC_CPF), hb_parcx( 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_s( MesaOrigem, sizeof(MesaOrigem), hb_parcx( 1 ) );
        strcpy_s( Codigo, sizeof(Codigo), hb_parcx( 2 ) );
        strcpy_s( Descricao, sizeof(Descricao), hb_parcx( 3 ) );
        strcpy_s( Aliquota, sizeof(Aliquota), hb_parcx( 4 ) );
        strcpy_s( Quantidade, sizeof(Quantidade), hb_parcx( 5 ) );
        strcpy_s( ValorUnitario, sizeof(ValorUnitario), hb_parcx( 6 ) );
        strcpy_s( FlagAcrescimoDesconto, sizeof(FlagAcrescimoDesconto), hb_parcx( 7 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 8 ) );
        strcpy_s( MesaDestino, sizeof(MesaDestino), hb_parcx( 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_s( Mesa, sizeof(Mesa), hb_parcx( 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_s( Bytes, sizeof(Bytes), hb_parcx( 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_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( FlagAcrescimoDesconto, sizeof(FlagAcrescimoDesconto), hb_parcx( 2 ) );
        strcpy_s( TipoAcrescimoDesconto, sizeof(TipoAcrescimoDesconto), hb_parcx( 3 ) );
        strcpy_s( ValorAcrescimoDesconto, sizeof(ValorAcrescimoDesconto), hb_parcx( 4 ) );
        strcpy_s( ValorFormaPagto, sizeof(ValorFormaPagto), hb_parcx( 5 ) );
        strcpy_s( Mensagem, sizeof(Mensagem), hb_parcx( 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_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 1 ) );
        strcpy_s( Mensagem, sizeof(Mensagem), hb_parcx( 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_s( ImprimeValorFinal, sizeof(ImprimeValorFinal), hb_parcx( 1 ) );
        strcpy_s( ImprimeEnfatizado, sizeof(ImprimeEnfatizado), hb_parcx( 2 ) );
        strcpy_s( Embarque, sizeof(Embarque), hb_parcx( 3 ) );
        strcpy_s( Destino, sizeof(Destino), hb_parcx( 4 ) );
        strcpy_s( Linha, sizeof(Linha), hb_parcx( 5 ) );
        strcpy_s( Prefixo, sizeof(Prefixo), hb_parcx( 6 ) );
        strcpy_s( Agente, sizeof(Agente), hb_parcx( 7 ) );
        strcpy_s( Agencia, sizeof(Agencia), hb_parcx( 8 ) );
        strcpy_s( Data, sizeof(Data), hb_parcx( 9 ) );
        strcpy_s( Hora, sizeof(Hora), hb_parcx( 10 ) );
        strcpy_s( Poltrona, sizeof(Poltrona), hb_parcx( 11 ) );
        strcpy_s( Plataforma, sizeof(Plataforma), hb_parcx( 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_s( MoedaSingular, sizeof(MoedaSingular), hb_parcx( 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_s( MoedaPlural, sizeof(MoedaPlural), hb_parcx( 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_s( Banco, sizeof(Banco), hb_parcx( 1 ) );
        strcpy_s( Valor, sizeof(Valor), hb_parcx( 2 ) );
        strcpy_s( Favorecido, sizeof(Favorecido), hb_parcx( 3 ) );
        strcpy_s( Cidade, sizeof(Cidade), hb_parcx( 4 ) );
        strcpy_s( Data, sizeof(Data), hb_parcx( 5 ) );
        strcpy_s( Mensagem, sizeof(Mensagem), hb_parcx( 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_s( Cidade, sizeof(Cidade), hb_parcx( 1 ) );
        strcpy_s( Favorecido, sizeof(Favorecido), hb_parcx( 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_s( ValorCompra, sizeof(ValorCompra), hb_parcx( 1 ) );
        strcpy_s( FormaPagamento, sizeof(FormaPagamento), hb_parcx( 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_s( sRetorno, sizeof(sRetorno), hb_parcx( 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)
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.DLL");

    if (handle)
    {
        int a = hb_parni( 1 );
        int b = hb_parni( 2 );
        int c = hb_parni( 3 );
        _BEMATECH_FI_RETORNOIMPRESSORA pFunc;
        pFunc = (_BEMATECH_FI_RETORNOIMPRESSORA) GetProcAddress(handle, "Bematech_FI_RetornoImpressora");
        hb_retni(pFunc(  &a, &b, &c ));
        hb_storni( a, 1);
        hb_storni( b, 2);
        hb_storni( c, 3);
        FreeLibrary( handle );
    }
}


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

    if (handle)
    {
        _BEMATECH_FI_VERIFICAESTADOIMPRESSORA pFunc;

        short int AckNak= hb_parni( 1 ) ;
        short int ST1   = hb_parni( 2 ) ;
        short int ST2   = hb_parni( 3 ) ;
        pFunc = (_BEMATECH_FI_VERIFICAESTADOIMPRESSORA) GetProcAddress(handle, "Bematech_FI_VerificaEstadoImpressora");
        hb_retni(pFunc( &AckNak, &ST1, &ST2 ));
        hb_storni( ( short int ) AckNak, 1 );
        hb_storni( ( short int ) ST1, 2 );
        hb_storni( ( short int ) ST2, 3 );
        FreeLibrary( handle );
    }
}

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_s( a, sizeof(a), hb_parcx( 1 ) ) ;
        strcpy_s( s, sizeof(s), hb_parcx( 2 ) ) ;
        strcpy_s( d, sizeof(d), hb_parcx( 3 ) ) ;
        strcpy_s( f, sizeof(f), hb_parcx( 4 ) ) ;
        strcpy_s( g, sizeof(g), hb_parcx( 5 ) ) ;
        strcpy_s( h, sizeof(h), hb_parcx( 7 ) ) ;
        strcpy_s( j, sizeof(j), hb_parcx( 8 ) ) ;
        strcpy_s( k, sizeof(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_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_s( a, sizeof(a), hb_parcx( 1 ) ) ;
        strcpy_s( s, sizeof(s), hb_parcx( 2 ) ) ;
        strcpy_s( d, sizeof(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_INICIAFECHAMENTOCUPOMMFD )
{

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

    if (handle)
    {
        _BEMATECH_FI_INICIAFECHAMENTOCUPOMMFD pFunc;
        char a[150] = { 0 };
        char s[150] = { 0 };
        char d[150] = { 0 };
        char f[150] = { 0 };
        strcpy_s( a, sizeof(a), hb_parcx( 1 ) ) ;
        strcpy_s( s, sizeof(s), hb_parcx( 2 ) ) ;
        strcpy_s( d, sizeof(d), hb_parcx( 3 ) ) ;
        strcpy_s( f, sizeof(f), hb_parcx( 4 ) ) ;


        pFunc = (_BEMATECH_FI_INICIAFECHAMENTOCUPOMMFD) GetProcAddress(handle, "Bematech_FI_IniciaFechamentoCupomMFD");
        hb_retni(pFunc( a, s, d, f ));


        FreeLibrary( handle );
    }

}

HB_FUNC( BEMATECH_FI_ALTERASIMBOLOMOEDA)
{
    HINSTANCE handle = LoadLibrary("BEMAFI32.dll");

    if (handle)
    {
        _BEMATECH_FI_ALTERASIMBOLOMOEDA pFunc;
        char a[ 150 ] = { 0 };
        pFunc = (_BEMATECH_FI_ALTERASIMBOLOMOEDA) GetProcAddress(handle, "Bematech_FI_AlteraSimboloMoeda");
        strcpy_s( a , sizeof(a), hb_parcx( 1 ));
        hb_retni(pFunc( a ));
        FreeLibrary( handle );
    }
}

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

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

        _BEMATECH_FI_RELATORIOGERENCIALTEF pFunc;
        strcpy_s( Texto, sizeof(Texto), hb_parcx( 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_s( Texto, sizeof(Texto),hb_parcx( 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 );
    }
}