typedef struct {
      int   reservado           (GERAL);
      int   pagina              (GERAL);
      int   contador            (GERAL);
      int   dia                 (GERAL);
      int   mes                 (GERAL);
      int   ano                 (GERAL);
      char  mes_extenso         (GERAL)[20];
      data  d1                  (GERAL);
      data  d2                  (GERAL);
      tipo_horas  h1            (GERAL);
      tipo_horas  h2            (GERAL);
      char  aux1                (GERAL)[80];
      char  aux2                (GERAL)[80];
      char  original            (GERAL)[80];
      int   num_via             (GERAL);
      int   linha               (GERAL);
      double euro               (GERAL);
      char   hash               (GERAL)[10];
      char   processado         (GERAL)[80];
      char  processado1         (GERAL)[80];
      char  processado2         (GERAL)[80];
      char  aviso               (GERAL)[80];
      char  SerDoc              (GERAL)[6];
      char  numero2             (GERAL)[20];
      char  aviso2              (GERAL)[80];
     } Geral;


typedef struct {                // 1
        int   existe            (EMPRESA);
        int   numero            (EMPRESA);
        char  nome              (EMPRESA)[72];
        char  directoria        (EMPRESA)[20];
        char  password          (EMPRESA)[20];
        char  contribuinte      (EMPRESA)[15];
        char  dados0           (EMPRESA)[72];
        char  dados1           (EMPRESA)[72];
        char  dados2           (EMPRESA)[72];
        char  dados3           (EMPRESA)[72];
        char  dados4           (EMPRESA)[72];
        char  dados5           (EMPRESA)[72];
        char  dados6           (EMPRESA)[72];
        char  dados7           (EMPRESA)[72];
        char  MensAnual         (EMPRESA)[2];
        char  MensTrim          (EMPRESA)[2];
        char  Regime            (EMPRESA)[2];
        char  flg_s             (EMPRESA)[2];
        char  drive             (EMPRESA)[6];
        int   ano               (EMPRESA);
        char  flg_r             (EMPRESA)[2];
        char  flg_grl           (EMPRESA)[2];
        char  rsv               (EMPRESA)[297];
        int   existe            (OPERADORES);
        int   numero            (OPERADORES);
        char  nome              (OPERADORES)[41];
        char  password          (OPERADORES)[20];
        char  flg_pswd          (OPERADORES)[2];
        int   nivel             (OPERADORES);
        char  rsv               (OPERADORES)[187];
        char nome               (PROGRAMA)[15];
        char versao             (PROGRAMA)[10];
        int  demo               (PROGRAMA);
        char fic                (PROGRAMA)[9];
        char path               (PROGRAMA)[40];
        char driver             (PORTA)[15];
        char form_pagina        (PORTA)[2];
        char cpi_15             (PORTA)[2];
        char select             (PORTA)[2];
        char rsv                (PORTA)[29];
        data  d1                (AMBIENTE);
        data  d2                (AMBIENTE);
        data  d3                (AMBIENTE);
        data  d4                (AMBIENTE);
        data  d5                (AMBIENTE);
        data  dc                (AMBIENTE);
        char  st1               (AMBIENTE)[80];
        char  st2               (AMBIENTE)[80];
        char  st3               (AMBIENTE)[80];
        char  st4               (AMBIENTE)[80];
        int   flc               (AMBIENTE);
        int   oldc              (AMBIENTE);
        int   ins_mode          (AMBIENTE);
        int   pede_empresa      (AMBIENTE);
        int   pede_operador     (AMBIENTE);
        int   beep_activo       (AMBIENTE);
        char  edita_temp        (AMBIENTE)[2];
        char  a_utilizar        (AMBIENTE)[2];
        int   p_via             (AMBIENTE);
        int   n_via             (AMBIENTE);
        double tela             (AMBIENTE);
        int   lpt               (AMBIENTE);
        char  KeySound          (AMBIENTE);
  tipo_horas  h1                (AMBIENTE);
        int   posto             (AMBIENTE);
        char  moeda             (AMBIENTE)[10];
        char  moeda_abr         (AMBIENTE)[10];
        char  moeda_simb        (AMBIENTE)[2];
        char  moeda_alt         (AMBIENTE)[10];
        char  moeda_alt_abr     (AMBIENTE)[10];
        char  moeda_alt_simb    (AMBIENTE)[2];
        char  rsv               (AMBIENTE)[269];
    } Empresa;             // 1

typedef struct {               // 2
      int    reservado         (DOCUMENTO);
      int    linhas            (DOCUMENTO);
      long   numero            (DOCUMENTO);
      int    emitido           (DOCUMENTO);
      char   anulado           (DOCUMENTO)[2];
      char   historico         (DOCUMENTO)[2];
      long   convertido        (DOCUMENTO);
      char   referencia        (DOCUMENTO)[21];
      data   data_doc        (DOCUMENTO);
      data   data_venc       (DOCUMENTO);
      tipo_horas hora_doc    (DOCUMENTO);
      long   numero_Cli      (DOCUMENTO);
      char   nome_cli        (DOCUMENTO)[41];
      double desconto          (DOCUMENTO);
      int    linha_de_precos  (DOCUMENTO);
      char   observacoes       (DOCUMENTO)[41];
      int    operador          (DOCUMENTO);
      int    NumVend   (DOCUMENTO);
      double comissao          (DOCUMENTO);
      int    NUmCondPag     (DOCUMENTO);
      char   NomePag          (DOCUMENTO)[21];
      int    prazo             (DOCUMENTO);
      int    NumFormaPag     (DOCUMENTO);
      char   DesForma1         (DOCUMENTO)[21];
      char   DesForma2        (DOCUMENTO)[21];
      long   NumBanco          (DOCUMENTO);
      char   NomeBanco        (DOCUMENTO)[41];
      double tot_material    (DOCUMENTO);
      double tot_desconto      (DOCUMENTO);
      double tot_liquido       (DOCUMENTO);
      double tot_iva           (DOCUMENTO);
      double tot_valor         (DOCUMENTO);
      double pago              (DOCUMENTO);
      double pendente          (DOCUMENTO);
      double suj_valor1        (DOCUMENTO);
      double suj_valor2        (DOCUMENTO);
      double suj_valor3        (DOCUMENTO);
      double suj_valor4        (DOCUMENTO);
      double suj_taxa1         (DOCUMENTO);
      double suj_taxa2         (DOCUMENTO);
      double suj_taxa3         (DOCUMENTO);
      double suj_taxa4         (DOCUMENTO);
      double suj_iva1          (DOCUMENTO);
      double suj_iva2          (DOCUMENTO);
      double suj_iva3          (DOCUMENTO);
      double suj_iva4          (DOCUMENTO);
      int    tipo_doc_conv     (DOCUMENTO);
      char   estado            (DOCUMENTO)[2];
      data   d_lanc            (DOCUMENTO);
      char   moeda             (DOCUMENTO)[11];
      double cambio            (DOCUMENTO);
      char   doc_mov_conv      (DOCUMENTO)[2];
      short  linhas_pgm        (DOCUMENTO);
      double recebido2         (DOCUMENTO);
      double bruto             (DOCUMENTO);
      double irs               (DOCUMENTO);
      int    morada            (DOCUMENTO);
      double custos            (DOCUMENTO);
      char   serdoc            (DOCUMENTO)[6];
      int    tpdoc             (DOCUMENTO);
      char   rsv               (DOCUMENTO)[48];
     } Doc;             //2

typedef struct {               //3
      int    reservado         (LINHAS DOC.);
      int    reservado         (LINHAS DOC.);
      int    reservado         (LINHAS DOC.);
      long   numero     (LINHAS DOC.);
      char   codigo            (LINHAS DOC.)[15];
      char   designacao        (LINHAS DOC.)[41];
      char   unidade           (LINHAS DOC.)[7];
      char   iva_inc           (LINHAS DOC.)[1];
      double quantidade        (LINHAS DOC.);
      double preco_unit        (LINHAS DOC.);
      double perc_desc1        (LINHAS DOC.);
      double desconto1         (LINHAS DOC.);
      double perc_desc2        (LINHAS DOC.);
      double desconto2         (LINHAS DOC.);
      double iva               (LINHAS DOC.);
      double valor             (LINHAS DOC.);
      double ultimo_custo      (LINHAS DOC.);
      double custo_medio       (LINHAS DOC.);
      int    NumArmz           (LINHAS DOC.);
      int    grupo             (LINHAS DOC.);
      int    ext               (LINHAS DOC.);
      char   flag              (LINHAS DOC.); 
      char   sem_stk           (LINHAS DOC.);
      double m_qtd             (LINHAS DOC.);
      double m_altura          (LINHAS DOC.);
      double m_largura         (LINHAS DOC.);
      double m_extra           (LINHAS DOC.); 
      double preco_servico     (LINHAS DOC.);
      data   d_val             (LINHAS DOC.);   
      long   num_enc           (LINHAS DOC.); 
      int    linha_enc         (LINHAS DOC.);
      double qtd_por_emb       (LINHAS DOC.);
      long   n_guia            (LINHAS DOC.);  
      char   tipo_enc          (LINHAS DOC.);
      char   serie             (LINHAS DOC.)[20];
      long   n_arm             (LINHAS DOC.);/PORTA21 char cor1[10];char cor2[10];
      char   serdoc            (LINHAS DOC.)[6];
      int    tpdoc             (LINHAS DOC.);
      int    miva              (LINHAS DOC.); 
      char   rsv               (LINHAS DOC.)[16];
     } DocLin;         //3

typedef struct {               // 4
      int    existe            (LINHAS REC);
      int    linha             (LINHAS REC);
      int    cor               (LINHAS REC);
      long   numero            (LINHAS REC);
      char   doc_mov           (LINHAS REC)[2];
      int    tipo_doc          (LINHAS REC);
      char   documento         (LINHAS REC)[21];
      long   NumeroDoc         (LINHAS REC);
      data   DataDoc           (LINHAS REC);
      data   DataVenc          (LINHAS REC);
      char   referencia        (LINHAS REC)[21];
      char   dc                (LINHAS REC)[2];
      double ValDoc            (LINHAS REC);
      double ValPend           (LINHAS REC);
      double valor_base        (LINHAS REC);
      double perc_desc         (LINHAS REC);
      double ValDesc           (LINHAS REC);
      double ValRec            (LINHAS REC);
      double ValIva            (LINHAS REC);
      double irs               (LINHAS REC);
      int    prest             (LINHAS REC);
      char   serdoc            (LINHAS REC)[6];
      double tot_liquido       (DOCUMENTO);
      double tot_iva           (DOCUMENTO);
      double tot_valor         (DOCUMENTO);
      double suj_valor1        (DOCUMENTO);
      double suj_valor2        (DOCUMENTO);
      double suj_valor3        (DOCUMENTO);
      double suj_valor4        (DOCUMENTO);
      double suj_taxa1         (DOCUMENTO);
      double suj_taxa2         (DOCUMENTO);
      double suj_taxa3         (DOCUMENTO);
      double suj_taxa4         (DOCUMENTO);
      double suj_iva1          (DOCUMENTO);
      double suj_iva2          (DOCUMENTO);
      double suj_iva3          (DOCUMENTO);
      double suj_iva4          (DOCUMENTO);
      int    miva              (LINHAS DOC.); 
      char   rsv               (LINHAS DOC.)[16];
     } RecLin;       // 4


typedef struct {               // 5
      int    existe            (EXTRA-DOCS);
      long   numero            (EXTRA-DOCS);
      char   loc_carga         (EXTRA-DOCS)[41];
      data   data_carga        (EXTRA-DOCS);
      tipo_horas hora_carga    (EXTRA-DOCS);
      char   motorista         (EXTRA-DOCS)[41];
      char   matricula         (EXTRA-DOCS)[21];
      char   loc_descarga      (EXTRA-DOCS)[41];
      char   embalagem         (EXTRA-DOCS)[41];
      char   transporte        (EXTRA-DOCS)[41];
      char   campo0           (EXTRA-DOCS)[41];
      char   campo1           (EXTRA-DOCS)[41];
      char   campo2           (EXTRA-DOCS)[41];
      char   campo3           (EXTRA-DOCS)[41];
      char   campo4           (EXTRA-DOCS)[41];
      char   campo5           (EXTRA-DOCS)[41];
      char   infor0           (EXTRA-DOCS)[41];
      char   infor1           (EXTRA-DOCS)[41];
      char   infor2           (EXTRA-DOCS)[41];
      char   infor3           (EXTRA-DOCS)[41];
      char   infor4           (EXTRA-DOCS)[41];
      char   infor5           (EXTRA-DOCS)[41];
      char   rsv               (EXTRA-DOCS)[250];
     } Extra;        // 5


typedef struct {               // 6
       int    existe           (TIPOS DOCS);
       int    numero           (TIPOS DOCS);
       char   designacao       (TIPOS DOCS)[21];
       char   cf               (TIPOS DOCS)[2];
       char   tipo_desconto    (TIPOS DOCS)[2];
       int    n_vias           (TIPOS DOCS);
       char   ficheiro         (TIPOS DOCS)[21];
       int    porta            (TIPOS DOCS);
       char   flg_cco          (TIPOS DOCS)[2];
       char   ctrl_sequencia   (TIPOS DOCS)[2];
       char   movimento_stock  (TIPOS DOCS)[2];
       char   ecr              (TIPOS DOCS)[10];
       char   rsv              (TIPOS DOCS)[186];
      } Docs;            // 6


typedef struct {               // 7
      int    existe             (TALOES);
      int    linha              (TALOES);
      data   Data              (TALOES);
      long   numero             (TALOES);
      int    tipo_doc           (TALOES);
      int    emitido            (TALOES);
      long   numero             (TALOES);
      tipo_horas hora           (TALOES);
      char   cf                 (TALOES)[2];
      long   NumCli             (TALOES);
      char   NomeCli            (TALOES)[41];
      double PercDesc           (TALOES);
      int    linha_precos       (TALOES);
      int    num_operador       (TALOES);
      int    num_vendedor       (TALOES);
      double tot_material       (TALOES);
      double tot_desconto       (TALOES);
      double tot_liquido        (TALOES);
      double tot_iva            (TALOES);
      double tot_valor          (TALOES);
      double val_recebido       (TALOES);
      double val_troco          (TALOES);
      double suj_valor1         (TALOES);
      double suj_valor2         (TALOES);
      double suj_valor3         (TALOES);
      double suj_valor4         (TALOES);
      double suj_taxa1          (TALOES);
      double suj_taxa2          (TALOES);
      double suj_taxa3          (TALOES);
      double suj_taxa4          (TALOES);
      double suj_iva1           (TALOES);
      double suj_iva2           (TALOES);
      double suj_iva3           (TALOES);
      double suj_iva4           (TALOES);
  } Talao;               // 7

typedef struct {               // 8
  int    reservado             (CLI-FORN);
  int    linhas_cco            (CLI-FORN);
  int    linhas_cnt            (CLI-FORN);
  int    linhas_art            (CLI-FORN);
  int    linhas_cmp            (CLI-FORN);
  long   numero                (CLI-FORN);
  char   nome1               (CLI-FORN)[41];
  char   nome2               (CLI-FORN)[41];
  char   morada                (CLI-FORN)[51];
  char   localidade            (CLI-FORN)[31];
  char   cod_postal         (CLI-FORN)[11];
  char   concelho              (CLI-FORN)[31];
  char   distrito              (CLI-FORN)[31];
  char   zona                  (CLI-FORN)[21];
  int    num_pais              (CLI-FORN);
  char   pais                  (CLI-FORN)[21];
  char   contribuinte          (CLI-FORN)[16];
  char   telefone              (CLI-FORN)[31];
  char   fax                   (CLI-FORN)[31];
  int    num_cond_pag          (CLI-FORN);
  char   cond_pagamento        (CLI-FORN)[21];
  int    prazo                 (CLI-FORN);
  double desconto_global       (CLI-FORN);
  int    linha_precos          (CLI-FORN);
  long   num_banco             (CLI-FORN);
  char   banco                 (CLI-FORN)[41];
  char   conta                 (CLI-FORN)[21];
  int    num_vendedor          (CLI-FORN);
  char   vendedor              (CLI-FORN)[41];
  double comissao              (CLI-FORN);
  char   dff                   (CLI-FORN)[2];
  double saldo                 (CLI-FORN)[2];
  char   obs                   (CLI-FORN)[41];
  double desconto_linha        (CLI-FORN);
  double plafont               (CLI-FORN);
  int    num_classe            (CLI-FORN);
  char   des_classe            (CLI-FORN)[21];
  char   rsv                   (CLI-FORN)[17];
  char   cont_compras          (CLI-FORN)[41];
  char   cont_tesouraria       (CLI-FORN)[41];
  char   vol_negocios1         (CLI-FORN)[21];
  char   vol_negocios2         (CLI-FORN)[21];
  char   objectivo_ferril      (CLI-FORN)[21];
  char   cheques               (CLI-FORN)[2];
  char   letras                (CLI-FORN)[2];
  char   rsv2                  (CLI-FORN)[43];
 } Cliente;                   // 8

typedef struct {               // 9
       int    existe           (PAISES);
       int    numero           (PAISES);
       char   designacao       (PAISES)[21];
       char   moeda            (PAISES)[11];
       double cambio           (PAISES);
       char   rsv              (PAISES)[74];
      } Pais;           // 9

typedef struct {               // 10
       int    existe           (VENDEDOR);
       int    numero           (VENDEDOR);
       char   nome             (VENDEDOR)[41];
       double comissao         (VENDEDOR);
       char   telefone         (VENDEDOR)[31];
       char   rsv              (VENDEDOR)[428];
      } Vend;       // 10



typedef struct {               // 11
      int  existe            (CCO-LNH-11);
      int  cor               (CCO-LNH);
      int  linha           (CCO-LNH);
      long   numero            (CCO-LNH);
      char   doc_mov           (CCO-LNH)[2];
      int    tipo_doc          (CCO-LNH);
      char   descricao         (CCO-LNH)[21];
      long   numero_doc        (CCO-LNH);
      data   d_doc             (CCO-LNH);
      data   d_venc            (CCO-LNH);
      char   referencia        (CCO-LNH)[21];
      char   obs               (CCO-LNH)[41];
      double valor             (CCO-LNH);
      double pendente          (CCO-LNH);
      char   dc                (CCO-LNH)[2];
      double debito            (CCO-LNH);
      double credito           (CCO-LNH);
      double acumulado         (CCO-LNH);
      double valor_iva         (CCO-LNH);
      double pendente_recibo   (CCO-LNH);
      double cambio            (CCO-LNH);
      int  num_moeda         (CCO-LNH);
      char   rsv               (CCO-LNH)[19];
     } Cco;     // 11


typedef struct {               // 12
      int    existe            (CCO-AUX);
      double debito            (CCO-AUX);
      double credito           (CCO-AUX);
      double acumulado         (CCO-AUX);
     } Cco2;           // 12

typedef struct {               // 13
      int    existe            (RES-DOCS);
      int    linhas            (RES-DOCS);
      long   numero            (RES-DOCS);
      int    emitido           (RES-DOCS);
      data   d_doc             (RES-DOCS);
      tipo_horas h_doc         (RES-DOCS);
      data   pd                (RES-DOCS);
      data   ud                (RES-DOCS);
      long   num_cf            (RES-DOCS);
      char   nome_cf           (RES-DOCS)[41];
      char   obs               (RES-DOCS)[41];
      int    num_operador      (RES-DOCS);
      double tot_material      (RES-DOCS);
      double tot_desconto      (RES-DOCS);
      double tot_liquido       (RES-DOCS);
      double tot_iva           (RES-DOCS);
      double tot_valor         (RES-DOCS);
      double pago              (RES-DOCS);
      double pendente          (RES-DOCS);
      double suj_valor1        (RES-DOCS);
      double suj_valor2        (RES-DOCS);
      double suj_valor3        (RES-DOCS);
      double suj_valor4        (RES-DOCS);
      double suj_taxa1         (RES-DOCS);
      double suj_taxa2         (RES-DOCS);
      double suj_taxa3         (RES-DOCS);
      double suj_taxa4         (RES-DOCS);
      double suj_iva1          (RES-DOCS);
      double suj_iva2          (RES-DOCS);
      double suj_iva3          (RES-DOCS);
      double suj_iva4          (RES-DOCS);
      char   rsv               (RES-DOCS)[55];
     } ResDoc;          // 13

typedef struct {               // 14
      int    existe            (RES-DOCS-LNH);
      int    linha             (RES-DOCS-LNH);
      int    cor               (RES-DOCS-LNH);
      long   numero            (RES-DOCS-LNH);
      int    tipo_doc          (RES-DOCS-LNH);
      char   document          (RES-DOCS-LNH)[21];
      long   num_doc           (RES-DOCS-LNH);
      data   d_doc             (RES-DOCS-LNH);
      data   d_venc            (RES-DOCS-LNH);
      double tot_material      (RES-DOCS-LNH);
      double tot_descont       (RES-DOCS-LNH);
      double tot_liquido       (RES-DOCS-LNH);
      double tot_iva           (RES-DOCS-LNH);
      double tot_valor         (RES-DOCS-LNH);
      double pago              (RES-DOCS-LNH);
      double pendente          (RES-DOCS-LNH);
      char   rsv               (RES-DOCS-LNH)[27];
     } ResDoclin;      // 14

typedef struct {               // 15
       int    existe           (GRP-DSC);
       char   codigo           (GRP-DSC)[11];
       char   descricao        (GRP-DSC)[21];
       double desconto1        (GRP-DSC);
       double desconto2        (GRP-DSC);
       char   rsv              (GRP-DSC)[14];
      } GrpDesc;  // 15

typedef struct {               // 16
       char   codigo0      (RES-GRP-DSC)[11];
       char   codigo1      (RES-GRP-DSC)[11];
       char   codigo2      (RES-GRP-DSC)[11];
       char   codigo3      (RES-GRP-DSC)[11];
       char   codigo4      (RES-GRP-DSC)[11];
       char   codigo5      (RES-GRP-DSC)[11];
       char   descricao0      (RES-GRP-DSC)[21];
       char   descricao1      (RES-GRP-DSC)[21];
       char   descricao2      (RES-GRP-DSC)[21];
       char   descricao3      (RES-GRP-DSC)[21];
       char   descricao4      (RES-GRP-DSC)[21];
       char   descricao5      (RES-GRP-DSC)[21];
       double desconto10      (RES-GRP-DSC);
       double desconto11      (RES-GRP-DSC);
       double desconto12      (RES-GRP-DSC);
       double desconto13      (RES-GRP-DSC);
       double desconto14      (RES-GRP-DSC);
       double desconto15      (RES-GRP-DSC);
       double desconto20      (RES-GRP-DSC);
       double desconto21      (RES-GRP-DSC);
       double desconto22      (RES-GRP-DSC);
       double desconto23      (RES-GRP-DSC);
       double desconto24      (RES-GRP-DSC);
       double desconto25      (RES-GRP-DSC);
      } GrpDesc2;  // 16

typedef struct {                // 17
    int           existe       (HST-ART);
    char          abrv         (HST-ART)[5];
    long          numero       (HST-ART);
    data          d            (HST-ART);
    char          codigo       (HST-ART)[15];
    char          descricao    (HST-ART)[41];
    int           n_arm        (HST-ART);
    double        qtd_in       (HST-ART);
    double        custo_in     (HST-ART);
    double        valor_in     (HST-ART);
    double        qtd_out      (HST-ART);
    double        custo_out    (HST-ART);
    double        valor_out    (HST-ART);
    double        qtd_ex       (HST-ART);
    double        custo_ex     (HST-ART);
    double        valor_ex     (HST-ART);
   } Stock;             // 17

typedef struct {               // 18
      int    existe            (CCO-CARTAS);
      long   numero            (CCO-CARTAS);
      char   abrv              (CCO-CARTAS)[5];
      data   d_doc             (CCO-CARTAS);
      data   d_venc            (CCO-CARTAS);
      tipo_horas h_doc         (CCO-CARTAS);
      char   referencia        (CCO-CARTAS)[21];
      long   num_cf            (CCO-CARTAS);
      char   nome_cf           (CCO-CARTAS)[41];
      char   cp                (CCO-CARTAS)[11];
      char   concelho          (CCO-CARTAS)[31];
      char   zona              (CCO-CARTAS)[21];
      int    num_vendedor      (CCO-CARTAS);
      char   nome_vendedor     (CCO-CARTAS)[31];
      double comissao          (CCO-CARTAS);
      double comissao_pendente (CCO-CARTAS);
      double tot_material      (CCO-CARTAS);
      double tot_desconto      (CCO-CARTAS);
      double tot_liquido       (CCO-CARTAS);
      double tot_iva           (CCO-CARTAS);
      double tot_valor         (CCO-CARTAS);
      double pago              (CCO-CARTAS);
      double pendente          (CCO-CARTAS);
      char   documento         (CCO-CARTAS)[25];
     } Cartas;  // 18

typedef struct {               // 19
      int    reservado         (DOCUMENTOX);
      int    linhas            (DOCUMENTOX);
      long   numero            (DOCUMENTOX);
      int    emitido           (DOCUMENTOX);
      char   anulado           (DOCUMENTOX)[2];
      char   historico         (DOCUMENTOX)[2];
      long   convertido        (DOCUMENTOX);
      char   referencia        (DOCUMENTOX)[21];
      data   data_documento    (DOCUMENTOX);
      data   data_vencimento   (DOCUMENTOX);
      tipo_horas hora_doc     (DOCUMENTOX);
      long   num_cli        (DOCUMENTOX);
      char   nome_cli          (DOCUMENTOX)[41];
      double desconto          (DOCUMENTOX);
      int    linha_precos   (DOCUMENTOX);
      char   observacoes       (DOCUMENTOX)[41];
      int    operador          (DOCUMENTOX);
      int    numero_vendedor   (DOCUMENTOX);
      double comissao          (DOCUMENTOX);
      int    n§ cond. pag.     (DOCUMENTOX);
      char   pagamento         (DOCUMENTOX)[21];
      int    prazo             (DOCUMENTOX);
      int    n§ form. pag.     (DOCUMENTOX);
      char   des. form         (DOCUMENTOX)[21];
      char   com. form         (DOCUMENTOX)[21];
      long   n§ banco          (DOCUMENTOX);
      char   nome banco        (DOCUMENTOX)[41];
      double total material    (DOCUMENTOX);
      double tot_desconto      (DOCUMENTOX);
      double tot_liquido       (DOCUMENTOX);
      double tot_iva           (DOCUMENTOX);
      double tot_valor         (DOCUMENTOX);
      double pago              (DOCUMENTOX);
      double pendente          (DOCUMENTOX);
      double suj_valor1        (DOCUMENTOX);
      double suj_valor2        (DOCUMENTOX);
      double suj_valor3        (DOCUMENTOX);
      double suj_valor4        (DOCUMENTOX);
      double suj_taxa1         (DOCUMENTOX);
      double suj_taxa2         (DOCUMENTOX);
      double suj_taxa3         (DOCUMENTOX);
      double suj_taxa4         (DOCUMENTOX);
      double suj_iva1          (DOCUMENTOX);
      double suj_iva2          (DOCUMENTOX);
      double suj_iva3          (DOCUMENTOX);
      double suj_iva4          (DOCUMENTOX);
      char   rsv               (DOCUMENTOX)[48];
     } Doc2;             //19

typedef struct {               //20
  int    existe                (CONTAS);
  int    linhas                (CONTAS);
  int    numero                (CONTAS);
  char   referencia            (CONTAS)[21];
  char   descricao             (CONTAS)[41];
  char   cod_banco             (CONTAS)[11];
  char   obs                   (CONTAS)[41];
  double debito                (CONTAS);
  double credit                (CONTAS);
  double saldo                 (CONTAS);
  char   rsv                   (CONTAS)[48];
 } Contas;                // 20

typedef struct {               //21
      int    existe            (EXT-CONTAS);
      int    numero            (EXT-CONTAS);
      data   d_mov             (EXT-CONTAS);
      char   doc_mov           (EXT-CONTAS)[2];
      int    tipo_doc          (EXT-CONTAS);
      long   num_doc           (EXT-CONTAS);
      int    linha             (EXT-CONTAS);
      int    num_form          (EXT-CONTAS);
      char   des_form          (EXT-CONTAS)[21];
      data   d_form            (EXT-CONTAS);
      char   ref_form          (EXT-CONTAS)[21];
      double debito            (EXT-CONTAS);
      double credito           (EXT-CONTAS);
      double acumulado         (EXT-CONTAS);
      char   flag              (EXT-CONTAS)[2];
      char   rsv               (EXT-CONTAS)[20];
     } CcoContas;        // 21

typedef struct {               // 22
    int   num0                 (DOCS-PGMS);
    int   num1                 (DOCS-PGMS);
    int   num2                 (DOCS-PGMS);
    int   num3                 (DOCS-PGMS);
    int   num4                 (DOCS-PGMS);
    int   num5                 (DOCS-PGMS);
    char  des0                 (DOCS-PGMS)[21];
    char  des1                 (DOCS-PGMS)[21];
    char  des2                 (DOCS-PGMS)[21];
    char  des3                 (DOCS-PGMS)[21];
    char  des4                 (DOCS-PGMS)[21];
    char  des5                 (DOCS-PGMS)[21];
    char  ref0                 (DOCS-PGMS)[81];
    char  ref1                 (DOCS-PGMS)[81];
    char  ref2                 (DOCS-PGMS)[81];
    char  ref3                 (DOCS-PGMS)[81];
    char  ref4                 (DOCS-PGMS)[81];
    char  ref5                 (DOCS-PGMS)[81];
   } Pag;                // 22

typedef struct {               // 23
      int    existe            (ARTIGOS);
      int    linhas_des        (ARTIGOS);
      int    linhas_arm        (ARTIGOS);
      int    linhas_cmp        (ARTIGOS);
      int    linhas_equ        (ARTIGOS);
      char   codigo            (ARTIGOS)[15];
      char   codigo2           (ARTIGOS)[15];
      char   Nome          (ARTIGOS)[41];
      char   Nome2         (ARTIGOS)[41];
      char   Abrev          (ARTIGOS)[15];
      int    cod_unid       (ARTIGOS);
      char   DesUnid       (ARTIGOS)[7];
      char   Armazem           (ARTIGOS)[15];
      char   Familia           (ARTIGOS)[15];
      double UltCusto       (ARTIGOS);
      double CustoMed       (ARTIGOS);
      double ValorMed        (ARTIGOS);
      int    CodIva             (ARTIGOS);
      double Iva             (ARTIGOS);
      double Margem1          (ARTIGOS);
      double Margem2          (ARTIGOS);
      double Preco_SIva1       (ARTIGOS);
      double Preco_SIva2       (ARTIGOS);
      double Preco_CIva1       (ARTIGOS);
      double Preco_CIva2       (ARTIGOS);
      double StockMin      (ARTIGOS);
      double Stock             (ARTIGOS);
      double StockMax       (ARTIGOS);
      long   CodForn         (ARTIGOS);
      data   DataEntr         (ARTIGOS);
      data   DataSaida        (ARTIGOS);
      char   BaixaStk        (ARTIGOS)[2];
      int    linhas_obs        (ARTIGOS);
      double Stock2            (ARTIGOS);
      char   rsv               (ARTIGOS)[14];
   } Art;             // 23

typedef struct {               // 24
       int    existe           (MOEDAS);
       int    numero           (MOEDAS);
       char   designacao       (MOEDAS)[11];
       char   abrv             (MOEDAS)[7];
       double cambio_v         (MOEDAS);
       double cambio_c         (MOEDAS);
       double euro             (MOEDAS);
       char   rsv              (MOEDAS)[2];
      } Moeda;           // 24

typedef struct {              // 22
  char idx                       (fun)[2];
  char numero                    (fun)[2];
  char nome                      (fun)[2];
  char nome2                     (fun)[2];
  char nome_solt                 (fun)[2];
  char prenome                   (fun)[2];
  char nasc                      (fun)[2];
  char local_nas                 (fun)[2];
  char profissao1                (fun)[2];
  char profissao2                (fun)[2];
  char profissao3                (fun)[2];
  char qualif1                   (fun)[2];
  char qualif2                   (fun)[2];
  char qualif3                   (fun)[2];
  char especial1                 (fun)[2];
  char especial2                 (fun)[2];
  char especial3                 (fun)[2];
  char morada                    (fun)[2];
  char localidade                (fun)[2];
  char cp                        (fun)[2];
  char concelho                  (fun)[2];
  char distrito                  (fun)[2];
  char zona                      (fun)[2];
  char pais                      (fun)[2];
  char nacionalidade             (fun)[2];
  char contribuinte              (fun)[2];
  char telefone                  (fun)[2];
  char candidatura               (fun)[2];
  char fax                       (fun)[2];
  char num_ss                    (fun)[2];
  char estado_civil              (fun)[2];
  char num_filhos                (fun)[2];
  char transporte                (fun)[2];
  char nome_acid                 (fun)[2];
  char telef_aci                 (fun)[2];
  char medica                    (fun)[2];
  char desloca                   (fun)[2];
  char des_conce                 (fun)[2];
  char des_distr                 (fun)[2];
  char des_odist                 (fun)[2];
  char des_estrang               (fun)[2];
  char empresa_u                 (fun)[2];
  char morada_ul                 (fun)[2];
  char morada2_u                 (fun)[2];
  char data_entr_u               (fun)[2];
  char data_said_u               (fun)[2];
  char qualif_ul                 (fun)[2];
  char salario_u                 (fun)[2];
  char des_posto_u1              (fun)[2];
  char des_posto_u2              (fun)[2];
  char des_posto_u3              (fun)[2];
  char motivo_saida_u            (fun)[2];
  char empresa_cv1               (fun)[2];
  char data_entr_cv1             (fun)[2];
  char data_said_cv1             (fun)[2];
  char qualif_cv1                (fun)[2];
  char salario_cv1               (fun)[2];
  char motivo_cv1                (fun)[2];
  char empresa_cv2               (fun)[2];
  char data_entr_cv2             (fun)[2];
  char data_said_cv2             (fun)[2];
  char qualif_cv2                (fun)[2];
  char salario_cv2               (fun)[2];
  char motivo_cv2                (fun)[2];
  char empresa_cv3               (fun)[2];
  char data_entr_cv3             (fun)[2];
  char data_said_cv3             (fun)[2];
  char qualif_cv3                (fun)[2];
  char salario_c3                (fun)[2];
  char motivo_cv3                (fun)[2];
  char empresa_cv4               (fun)[2];
  char data_entr_cv4             (fun)[2];
  char data_said_cv4             (fun)[2];
  char qualif_cv4                (fun)[2];
  char salario_cv4               (fun)[2];
  char motivo_cv4                (fun)[2];
  char form_base                 (fun)[2];
  char diplomas                  (fun)[2];
  char form_org1                 (fun)[2];
  char form1                     (fun)[2];
  char duracao1                  (fun)[2];
  char conteudo1                 (fun)[2];
  char form_org2                 (fun)[2];
  char form2                     (fun)[2];
  char duracao2                  (fun)[2];
  char conteudo2                 (fun)[2];
  char form_org3                 (fun)[2];
  char form3                     (fun)[2];
  char duracao3                  (fun)[2];
  char conteudo3                 (fun)[2];
  char form_org4                 (fun)[2];
  char form4                     (fun)[2];
  char duracao4                  (fun)[2];
  char conteudo4                 (fun)[2];
  char lingua1                   (fun)[2];
  char lingua2                   (fun)[2];
  char lingua3                   (fun)[2];
  char lingua4                   (fun)[2];
  char nome_ref                  (fun)[2];
  char telef_ref                 (fun)[2];
  char morada_re                 (fun)[2];
  char aut_ref                   (fun)[2];
  char obs                       (fun)[2];
  char rsv                       (fun)[2];
   }Map;

