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);
     } tipo_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  dados 0           (EMPRESA)[72];
        char  dados 1           (EMPRESA)[72];
        char  dados 2           (EMPRESA)[72];
        char  dados 3           (EMPRESA)[72];
        char  dados 4           (EMPRESA)[72];
        char  dados 5           (EMPRESA)[72];
        char  dados 6           (EMPRESA)[72];
        char  dados 7           (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];
        int   p_via             (AMBIENTE);
        int   n_via             (AMBIENTE);
        double tela             (AMBIENTE);
        int   lpt               (AMBIENTE);
        char  KeySound          (AMBIENTE);
        char  rsv               (AMBIENTE)[269];
    } tipo_ambiente;             // 1

typedef struct {                // 2
      int    existe             (TALOES);
      int    linhas             (TALOES);
      data   d_doc              (TALOES);
      long   numero             (TALOES);
      int    tipo_doc           (TALOES);
      int    emitido            (TALOES);
      long   num_doc            (TALOES);
      tipo_horas h_doc          (TALOES);
      char   cf                 (TALOES)[2];
      long   num_cf             (TALOES);
      char   nome_cf            (TALOES)[41];
      double perc_desc          (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);
      int    mesa               (TALOES);
     } tipo_taloes;             // 2

typedef struct {                // 3
      int    existe             (TALOES-LNH);
      int    linha_f            (TALOES-LNH);
      int    cor                (TALOES-LNH);
      data   d_doc              (TALOES-LNH);
      long   numero             (TALOES-LNH);
      char   codigo             (TALOES-LNH)[15];
      char   designacao         (TALOES-LNH)[41];
      char   abreviatura        (TALOES-LNH)[15];
      char   unidade            (TALOES-LNH)[7];
      char   com_iva            (TALOES-LNH);
      double QTD:               (TALOES-LNH);
      double preco_unit         (TALOES-LNH);
      double perc_desc1         (TALOES-LNH);
      double desconto1          (TALOES-LNH);
      double perc_desc2         (TALOES-LNH);
      double desconto2          (TALOES-LNH);
      double IVA:               (TALOES-LNH);
      double valor              (TALOES-LNH);
      double ultimo_custo       (TALOES-LNH);
      double custo_medio        (TALOES-LNH);
     } tipo_taloes_lnh;        // 3

typedef struct {               //4
       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];
      } tipos_docs;            //4

typedef struct {               //5
    data  pd                   (INTERVALOS);
    data  ud                   (INTERVALOS);
    tipo_horas ph              (INTERVALOS);
    tipo_horas uh              (INTERVALOS);
    long  pg                   (INTERVALOS);
    long  ug                   (INTERVALOS);
    int   pv                   (INTERVALOS);
    int   uv                   (INTERVALOS);
    char  pa                   (INTERVALOS)[15];
    char  ua                   (INTERVALOS)[15];
    char  ps                   (INTERVALOS)[15];
    char  us                   (INTERVALOS)[15];
    char  resumo               (INTERVALOS);
    char  map                  (INTERVALOS);
   } tipo_mps;                 //5

typedef struct {               //6
      int    existe            (MAP-ART);
      char   dcm               (MAP-ART)[5];
      long   numero            (MAP-ART);
      data   d                 (MAP-ART);
      long   numero_cf         (MAP-ART);
      char   nome_cf           (MAP-ART)[41];
      char   codigo            (MAP-ART)[15];
      char   designacao        (MAP-ART)[41];
      char   unidades          (MAP-ART)[7];
      char   familia           (MAP-ART)[15];
      double quantidade        (MAP-ART);
      double preco_uni         (MAP-ART);
      double valor_iliquido    (MAP-ART);
      double valor_desconto    (MAP-ART);
      double valor_sujeito     (MAP-ART);
      double iva               (MAP-ART);
      double valor_iva         (MAP-ART);
      double valor_total       (MAP-ART);
      double ultimo_custo      (MAP-ART);
      double margem1           (MAP-ART);
      double lucro_u1          (MAP-ART);
      double lucro1            (MAP-ART);
      double custo_medio       (MAP-ART);
      double margem2           (MAP-ART);
      double lucro_u2          (MAP-ART);
      double lucro2            (MAP-ART);
      int    num_vendedor      (MAP-ART);
      char   nome_vendedor     (MAP-ART)[41];
      double comissao          (MAP-ART);
      double val_com           (MAP-ART);
     } tipo_wra;               //6

typedef struct {               //7
   data   d                    (RES-CAIXA);
   char   str                  (RES-CAIXA)[60];
   char   descricao            (RES-CAIXA)[21];
   double valor                (RES-CAIXA);
   double perc_custo           (RES-CAIXA);
   double custos               (RES-CAIXA);
   double val_custo            (RES-CAIXA);
   double val_caixa            (RES-CAIXA);
   double val_reembolso        (RES-CAIXA);
   double val_caixa_reembolso  (RES-CAIXA);
   double val_prazo            (RES-CAIXA);
   double val_total            (RES-CAIXA);
  } tipo_imp_resumo_caixa;      //7

typedef struct {                //8
    int    existe               (MOV-CAIXA);
    int    num_operador         (MOV-CAIXA);
    data   d                    (MOV-CAIXA);
    tipo_horas h                (MOV-CAIXA);
    char   descricao            (MOV-CAIXA)[35];
    char   meio                 (MOV-CAIXA)[21];
    double valor                (MOV-CAIXA);
    double total                (MOV-CAIXA);
    double val_caixa            (MOV-CAIXA);
    double val_reembolso        (MOV-CAIXA);
    double val_caixa_reembolso  (MOV-CAIXA);
    double val_prazo            (MOV-CAIXA);
    double val_total            (MOV-CAIXA);
   } tipo_imp_ent_sai;          //8

typedef struct {                //9
      int    existe             (MAP-GRL);
      long   numero             (MAP-GRL);
      data   d_doc              (MAP-GRL);
      char   dcm                (MAP-GRL)[5];
      long   numero_cf          (MAP-GRL);
      char   nome_cf            (MAP-GRL)[41];
      double tot_material       (MAP-GRL);
      double tot_desconto       (MAP-GRL);
      double tot_liquido        (MAP-GRL);
      double tot_iva            (MAP-GRL);
      double tot_valor          (MAP-GRL);
      double sujeito            (MAP-GRL)[4];
      double taxa               (MAP-GRL)[4];
      double iva                (MAP-GRL)[4];
      int    num_vendedor       (MAP-GRL);
      char   nome_vendedor      (MAP-GRL)[41];
      double comissao           (MAP-GRL);
      double val_com            (MAP-GRL);
     } tipo_wrg;                //9

typedef struct {                //10
      int    existe             (MAP-IVA);
      int    tipo_doc           (MAP-IVA);
      char   documento          (MAP-IVA)[21];
      char   dcm                (MAP-IVA)[5];
      data   d                  (MAP-IVA);
      char   familia            (MAP-IVA)[15];
      double valor_iliquido     (MAP-IVA);
      double valor_desconto     (MAP-IVA);
      double valor_sujeito      (MAP-IVA);
      double iva                (MAP-IVA);
      double valor_iva          (MAP-IVA);
      double valor_total        (MAP-IVA);
     } tipo_wri;                //10

typedef struct {                // 11
      int    existe             (PROMOCOES);
      int    linhas             (PROMOCOES);
      long   numero             (PROMOCOES);
      data   d_i                (PROMOCOES);
      data   d_f                (PROMOCOES);
      char   obs                (PROMOCOES)[51];
      char   rsv                (PROMOCOES)[13];
     } tipo_promocoes;          // 11

typedef struct {                // 12
      int    existe             (PROMOCOES-LNH);
      int    linha_f            (PROMOCOES-LNH);
      int    cor                (PROMOCOES-LNH);
      long   numero             (PROMOCOES-LNH);
      char   codigo             (PROMOCOES-LNH)[15];
      char   descricao          (PROMOCOES-LNH)[41];
      char   abreviatura        (PROMOCOES-LNH)[15];
      char   unidades           (PROMOCOES-LNH)[7];
      double preco              (PROMOCOES-LNH);
      char   rsv                (PROMOCOES-LNH)[16];
     } tipo_promocoes_lnh;      // 12
