// Форма - 4 ФСС. Расчетная ведомость.

var xls,   // объект Excel.Application
    wsh,   // объект WorkSheet
    Tabl,  // объект для работы с таблицей
    File;  // обект для работы с файлом печати

var CMsg=0;         // Процент выполненной работы
int bTime  = false; // false-показывать процент,
                    // true-показывать оставшееся время

int cPay = 13; // количество выплат в рашифровке (табл.5 - 
               // "Расшифровка выплат на цели обязательного государственного страхования")

// константы для строк
int len = 256, // длина строки
      W = 250, // не менее символов
      A = 250, // не более символов
     _w = 25,  // размерность
     _a = 2;   // точность

char str[len],
     arg[len],
     buf[len],
      ts[len];

double tmp  =  0.0,
       tmp1 =  0.0,
       eps  =  0.001;

double rz = 0.0;
int   _do = 5; // до скольки знаков округлять при расчете отчислений по травматизму с каждого ЛС (TM=0)

int flTravmaOld = 0;

// Параметры ///////////////////////////////////////////////////////////////////////////////////////

double procInv = 60.0;
int strInv = 0;
int blvmen = 0;
int TM = 1;
int TypeCalcCount1_5 = 0; // 0 - учитываем в качестве получателей "физическое лицо"
                          // 1 - учитываем в качестве получателей детей.
int SrzCount1_5 = 0; // для таблицы среднего заработка
                     // 0 - учитываем в качестве получателей "физическое лицо"
                     // 1 - учитываем в качестве получателей детей.
int filtrInv = 0; // 1 - не включать инвалидов с группой > 3 в список; 0 - включать всех
// !!! ВАЖНО !!! - присваивать переменной exeptInv значение 1 можно только в случае если для лиц с группой инвалидности > 3 процент с выплат для начисления взносов по травматизму равен 100
int exeptInv = 0; // 1 - для инвалидов с группой > 3 procInv = 100; 0 - значение procInv одинаково для всех групп инвалидов
int MilTr = 1; // 1 - аттестованные военные не учитываются в табл.9; 0 - учитываюстя


KorParam()
{
  if ( exeptInv < 0 ) exeptInv = 0; if ( exeptInv > 1 ) exeptInv = 1;
  if ( filtrInv < 0 ) filtrInv = 0; if ( filtrInv > 1 ) filtrInv = 1;
  if ( procInv < eps ) procInv = 0.0; if ( procInv > 100.0 ) procInv = 100.0;
  if ( strInv < 0 ) strInv = 0; if ( strInv > 1 ) strInv = 1;
  if ( blvmen < 0 ) blvmen = 0; if ( blvmen > 1 ) blvmen = 1;
  if ( TM < 0 ) TM = 0; if ( TM > 1 ) TM = 1;

  return 0;
}

//=====================================================================================================================

ReadParam(&param,np)
// чтение параметров
{
  if ( np > 0 ) procInv = atoi(param[0]);
  if ( np > 1 ) strInv  = atoi(param[1]);
  if ( np > 2 ) blvmen  = atoi(param[2]);
  if ( np > 3 ) TM      = atoi(param[3]);
  if ( np > 4 ) TypeCalcCount1_5 = atoi(param[4]);
  if ( np > 5 ) SrzCount1_5 = atoi(param[5]);
  if ( np > 6 ) filtrInv = atoi(param[6]);
  if ( np > 7 ) exeptInv = atoi(param[7]);
  if ( np > 8 ) MilTr    = atoi(param[8]);

  KorParam();

  return 0;
}

//=====================================================================================================================

fss4(&param,np)
{
  ReadParam(param,np);

  File = CreateObject("CurPrnFile");
  File.SetFlagBrowse(0);

  table();
}

// Объявление переменных - begin ////////////////////////////////////////////////////////////////////

string mn2 = "", mn1 = "", mn0 = ""; // названия месяцев
int m2, m1, m0; // месяцы квартала (относительные)

int dper = 36;
double sttar[dper], // % страхового тарифа
       inctr[dper], // выплаты для начисления взносов по травматизму
       taxtr[dper], // страховые взносы по травматизму
       tmtra[dper], // страховые взносы по травматизму для случая когда взносы считаются по каждому ЛС
       st5,         // Класс профессионального риска
       st6,         // Размер страхового тарифа в соответствии с классом профессио-нального риска (%)
       st7,         // Скидка к страховому тарифу (%)
       st8,         // Надбавка к страховому тарифу дата установления
       st9;         // Надбавка к страховому тарифу процент (%)

char dst[len]; // дата установления надбавки к страховому тарифу 

// среднесписочная численность невмененщиков
double ssc = 0.0, // все
       ssw = 0.0, // женщины
       ssi = 0.0; // инвалиды

// среднесписочная численность для вмененщиков
double sscv = 0.0, // все
       sswv = 0.0; // женщины

// среднесписочная численность для всех
double sscc = 0.0, // все
       sswc = 0.0, // женщины
       ssbf = 0.0, // занятые на работе с вредными факторами
       ssic = 0.0; // инвалиды

double IncP = 0.0, Inc2 = 0.0, Inc1 = 0.0, Inc0 = 0.0, // база для исчисления ЕСН ФСС
       TaxP = 0.0, Tax2 = 0.0, Tax1 = 0.0, Tax0 = 0.0, // ЕСН ФСС 
       SocP = 0.0, Soc2 = 0.0, Soc1 = 0.0, Soc0 = 0.0, // соц.выплаты
       SovP = 0.0, Sov2 = 0.0, Sov1 = 0.0, Sov0 = 0.0, // соц.выплаты с вмененщиков
       TraP = 0.0, Tra2 = 0.0, Tra1 = 0.0, Tra0 = 0.0, // база по травме
       TriP = 0.0, Tri2 = 0.0, Tri1 = 0.0, Tri0 = 0.0, // база по травме с инвалидов
       TrnP = 0.0, Trn2 = 0.0, Trn1 = 0.0, Trn0 = 0.0, // инвалидские выплаты на которые не начисляются взносы по травме
       TrbP = 0.0, Trb2 = 0.0, Trb1 = 0.0, Trb0 = 0.0, // выплаты на которые не начисляются взносы по травме
       TtrP = 0.0, Ttr2 = 0.0, Ttr1 = 0.0, Ttr0 = 0.0, // сумма отчислений по травме
       TroP = 0.0, Tro2 = 0.0, Tro1 = 0.0, Tro0 = 0.0, // сумма БЛ по травме
       TrdP = 0.0, Trd2 = 0.0, Trd1 = 0.0, Trd0 = 0.0, // дни БЛ по травме

       MtrP = 0.0, Mtr2 = 0.0, Mtr1 = 0.0, Mtr0 = 0.0, // предупредительные меры
       UtrP = 0.0, Utr2 = 0.0, Utr1 = 0.0, Utr0 = 0.0, // углубленные осмотры

       PrdP = 0.0, PrsP = 0.0,            // дни и сумма по профзаболеванию
       Prs2 = 0.0, Prs1 = 0.0, Prs0 = 0.0,

       OtdP = 0.0, OtsP = 0.0,            // дни и сумма по леч.отпускам
       Ots2 = 0.0, Ots1 = 0.0, Ots0 = 0.0,

       TrdS = 0.0, TroS = 0.0,
       PrdS = 0.0, PrsS = 0.0,
       OtdS = 0.0, OtsS = 0.0,

       R14 = 0.0, R24 = 0.0, R34 = 0.0, R44 = 0.0, R54 = 0.0, R64 = 0.0, R74 = 0.0, R84 = 0.0,

       NalBase = 0.0,
       NalLgot = 0.0,

       tax3 = 0.0, tax4 = 0.0, tax5 = 0.0, tax6 = 0.0, tax7 = 0.0, tax8 = 0.0, tax9 = 0.0;

int ChpT = 0; // численность пострадавших по травматизму
int ChpP = 0; // численность пострадавших по профзаболеваниям

int S14 = 0, S24 = 0, S54 = 0, S84 = 0,
    w14 = 0, w24 = 0, w54 = 0, w84 = 0;

int Cnt[cPay], // число случаев
    Dni[cPay], // число дней
    Cnv[cPay], // число случаев для вмененщиков
    Dnv[cPay]; // число дней для вмененщиков

double Sum[cPay], // сумма выплат
       Suv[cPay]; // сумма выплат, приходящаяся на вмененный доход

double SumVme = 0.0; // сумма вмененного дохода

int Cnts = 0, // число случаев                 | совместительство
    Dnis = 0, // число дней                    |
    Cnvs = 0, // число случаев для вмененщиков |
    Dnvs = 0; // число дней для вмененщиков    |

double Sums = 0.0, // сумма выплат                                  | совместительство
       Suvs = 0.0; // сумма выплат, приходящаяся на вмененный доход |

int Cnt9 = 0, // число случаев                 | совместительство
    Dni9 = 0, // число дней                    |
    Cnv9 = 0, // число случаев для вмененщиков |
    Dnv9 = 0; // число дней для вмененщиков    |

double Sum9 = 0.0, // сумма выплат                                  | совместительство
       Suv9 = 0.0; // сумма выплат, приходящаяся на вмененный доход |


int Cnt1[2]  ,// число случаев                 | 1.5 1-й ребенок 
    Dni1[2]  ,// число дней                    |
    cntLS0[2],// кол-во получателей "итого" по работ. и студентам
    cntLS1[2],// кол-во получателей (ЛС) работ. и студентов
    Cnv1 = 0, // число случаев для вмененщиков |
    Dnv1 = 0, // число дней для вмененщиков    |
    cnvLS0=0,
    cnvLS1=0;

double Sum1[2],    // сумма выплат                                  | 1.5 1-й ребенок
       Suv1 = 0.0; // сумма выплат, приходящаяся на вмененный доход |

int Cnt2[2]  ,// число случаев                 | 1.5 2-й ребенок 
    Dni2[2]  ,// число дней                    |
    cntLS2[2], // кол-во получателей (ЛС) работ. и студентов
    Cnv2 = 0, // число случаев для вмененщиков |
    Dnv2 = 0, // число дней для вмененщиков    |
    cnvLS2=0;

double Sum2[2],    // сумма выплат                                  | 1.5 2-й ребенок
       Suv2 = 0.0; // сумма выплат, приходящаяся на вмененный доход |

string data_att = "00.00.0000";

double FssPays[12];

// Объявление переменных - end   ////////////////////////////////////////////////////////////////////


table()
{
  CMsg = CreateObject("ProgressBar");
  CMsg.Initial(0,100,1);
  CMsg.SetShowTime(static_cast_to_int(bTime));

  Tabl = CreateObject("CurPrnTbl");
  int cr = Tabl.Count_Rcr();  // число рабочих зaписей в таблице   

  string INV_FIO[cr];
  string INV_DAT[cr];
  string INV_KON[cr];
  string INV_GRU[cr];
  string INV_NOM[cr];
  string INV_SER[cr];
  string INV_NAC[cr];

  double INV_VSE[cr];
  double INV_1ME[cr];
  double INV_2ME[cr];
  double INV_3ME[cr];

  for ( int i=0; i<2; ++i )
  {
    Cnt1[i]=Dni1[i]=cntLS1[i]=cntLS0[i]=0;
    Cnt2[i]=Dni2[i]=cntLS2[i]=0;
    Sum1[i]=Sum2[i]=0.0;
  }
  for ( int i = 0; i < cr; i++ )
  {
    INV_FIO[i] = "";
    INV_DAT[i] = "";
    INV_KON[i] = "";
    INV_GRU[i] = "";
    INV_NOM[i] = "";
    INV_SER[i] = "";
    INV_NAC[i] = "";
    INV_VSE[i] = 0.0;
    INV_1ME[i] = 0.0;
    INV_2ME[i] = 0.0;
    INV_3ME[i] = 0.0;
  }

  for ( int i=0; i < dper; i++ )
  {
    inctr[i] = 0.0;
    taxtr[i] = 0.0;
    tmtra[i] = 0.0;
  }

  int CI = 0; // счетчик инвалидов

  int CrIns = Tabl.GetCountInsertRcr(); // число выделенных записей

  FillFld(); // находим поля в таблице

  if ( -1 == fld[idxTRASUM01] ) flTravmaOld = 1;

  int m2 = atoi(Tabl.Text(fld[idxM2],0)), // 1-й месяц квартала (относительный)
      m1 = atoi(Tabl.Text(fld[idxM1],0)), // 2-й месяц квартала
      m0 = atoi(Tabl.Text(fld[idxM0],0)); // 3-й месяц квартала

  MonthName(mn2,m2); // название 1-го месяца квартала
  MonthName(mn1,m1); // название 2-го месяца квартала
  MonthName(mn0,m0); // название 3-го месяца квартала

  int NomKvart = atoi(Tabl.Text(fld[idxENDKVL],0)); // Квартал для месяца конца периода

  int endotek = atoi(Tabl.Text(fld[idxENDOTNTEK],0)); // Относительный месяц конца периода

  string period = "";

  if ( NomKvart == 1 ) period = OemToAnsi("I квартал");
  if ( NomKvart == 2 ) period = OemToAnsi("полугодие");
  if ( NomKvart == 3 ) period = OemToAnsi("9 месяцев");
  if ( NomKvart == 4 ) period = OemToAnsi("год");

  char year[5];
  sprintf(str,"%-7.7s",Tabl.Text(fld[idxEDAT],0)); // месяц конца периода (ММ.ГГГГ)
  sprintf(year,"%c",str[6]);

  int edat = atoi(Tabl.Text(fld[idxAEDAT],0)), // месяц конца периода (абсолютный)
      bdat = atoi(Tabl.Text(fld[idxABDAT],0)); // месяц начала периода (абсолютный)
  dper = edat - bdat + 1;                      // число месяцев в периоде

  int mkv1 = 0;
  int mkv2 = 0;
  int mkv3 = 0;

  switch (dper)
  {
    case  1: { mkv1 =  1; break; }
    case  2: { mkv1 =  1; mkv2 =  2; break; }
    case  3: { mkv1 =  1; mkv2 =  2; mkv3 =  3; break; }
    case  4: { mkv1 =  4; break; }
    case  5: { mkv1 =  4; mkv2 =  5; break; }
    case  6: { mkv1 =  4; mkv2 =  5; mkv3 =  6; break; }
    case  7: { mkv1 =  7; break; }
    case  8: { mkv1 =  7; mkv2 =  8; break; }
    case  9: { mkv1 =  7; mkv2 =  8; mkv3 =  9; break; }
    case 10: { mkv1 = 10; break; }
    case 11: { mkv1 = 10; mkv2 = 11; break; }
    case 12: { mkv1 = 10; mkv2 = 11; mkv3 = 12; break; }
  }

  for ( int i = 0; i < 12; i++ ) FssPays[i] = 0.0; 


  int abdat = 0;
  if ( -1 != fld[idxABDAT] ) abdat = atoi(Tabl.Text(fld[idxABDAT],0));

  for ( int i=0; i < dper; i++ ) sttar[i] = 0.0;

  GetEnterpriseVar("СТТАРИФ",str,W); // пытаемся номер сетки для страхового тарифа прочитать из справки о предприятии
  int tmi = atoi(str);
  if ( !tmi ) tmi = 60;

  double data = 0.0;

  for ( int mes = bdat; mes <= edat; mes++ )
  {
    data = GetDateFromFuncRWScript(mes); // дата в формате ГГГГММ.ДД
    Value_For_Table_Cod(tmi, 10, data, sttar[mes-bdat]); // Размер страхового тарифа с учетом скидки (надбавки) (%)
  }

  Value_For_Table_Cod(tmi, 5, data, st5); // Класс профессионального риска                                                 
  Value_For_Table_Cod(tmi, 6, data, st6); // Размер страхового тарифа в соответствии с классом профессио-нального риска (%)
  Value_For_Table_Cod(tmi, 7, data, st7); // Скидка к страховому тарифу (%)                                                
  Value_For_Table_Cod(tmi, 8, data, st8); // Надбавка к страховому тарифу дата установления                               
  Value_For_Table_Cod(tmi, 9, data, st9); // Надбавка к страховому тарифу процент (%)                                      

  var dst8 = CreateObject("KDate"); 
  dst8.SetDateD(st8);
  dst[0] = 0;

  if ( !dst8.IsEqI(INVALID_DATE_VALUE) )
  {
    sprintf(dst,"%02d.%02d.%4d", dst8.GetDay(), dst8.GetMonth(), dst8.GetYear());
  }

  for ( int i = 0; i < cPay; i++ ) 
  { 
    Cnt[i] = 0; Dni[i] = 0; Sum[i] = 0.0; 
    Cnv[i] = 0; Dnv[i] = 0; Suv[i] = 0.0;
  }

  // цикл по записям таблицы
  for ( int zap = 0; zap < cr; zap++ )
  {
    int RecIns = Tabl.Flag_Action_1(zap);
    
    if (CrIns && !RecIns) continue; // если какие-то записи выделены, печатаем только их

    if ( CMsg.Msg_Proc(" Подождите немного. Идет подготовка к печати. ",100.*zap/cr)==ESC ) return 0;

    int vme = atoi(Tabl.Text(fld[idxFV],zap));

    int pol = 0;
    sprintf(str,"%s", Tabl.Text(fld[idxPOL],zap));
    if ( !strcmp(str,"Ж") || !strcmp(str,"ж") ) pol = 1;

    // читаем данные по травматизму
    sprintf(str,"%s", Tabl.Text(fld[idxTRAVMA],zap));

    double atra[dper], atri[dper], atrn[dper], atrb[dper];
    int ainv[dper], aout[dper];

    for ( int i = 0; i < dper; i++ ) 
    {
      atra[i] = 0.0; atri[i] = 0.0; atrn[i] = 0.0; atrb[i] = 0.0;
      ainv[i] = 0; aout[i] = 0;
    }

    int INV = atoi(Tabl.Text(fld[idxFLGINVP],zap));

    var list = 0;
    int cl = 0;
    int ci = 0;

    if ( INV )
    {
      sprintf(buf,"%s", Tabl.Text(fld[idxINV],zap));
      list = CreateObject("ParamFuncRW");
      list.IInitial(static_cast_to_string(buf),";",100);
      cl = list.Count();

      for ( int i = cl-1; i >= 0; i-- )
      {
        char Buf[101];
        Buf = list.Get(i);
        int Group = GetGroupInv(Buf);
        if ( !Group ) { continue; }
        INV_GRU[CI] = Group;
        ci = i; break;
      }
    }

    if ( INV && filtrInv ) if ( INV_GRU[CI] > 3 ) INV = 0;

    if ( INV )
    {
      INV_FIO[CI] = OemToAnsi(Tabl.Text(fld[idxFIO],zap));

      // дата на какой срок установлена инвалидность
      var KInv = CreateObject("KDate");
      KInv.SetDateD(GetDateEndInv(list.Get(ci)));

      if ( !KInv.IsEqI(INVALID_DATE_VALUE) )
      {
        sprintf(ts,"%02d.%02d.%4d", KInv.GetDay(), KInv.GetMonth(), KInv.GetYear());
        INV_KON[CI] = static_cast_to_string(ts);
      }

      // дата начала инвалидности
      var DInv = CreateObject("KDate");

      // дата выдачи справки по инвалидности
      try 
      {
        DInv.SetDateD(GetDateSpravInv(list.Get(ci)));
      }
      catch(...)
      {
        DInv.SetDateD(GetDateBegInv(list.Get(ci)));
      }

      INV_NOM[CI] = OemToAnsi(RTrim(GetNumSpravInv(list.Get(ci),ts,20)));
      INV_SER[CI] = OemToAnsi(RTrim(GetSerSpravInv(list.Get(ci),ts,20)));

      if ( !DInv.IsEqI(INVALID_DATE_VALUE) )
      {
        sprintf(ts,"%02d.%02d.%4d", DInv.GetDay(), DInv.GetMonth(), DInv.GetYear());
        INV_DAT[CI] = ts;
      }

      // дата начала инвалидности
      DInv.SetDateD(GetDateBegInv(list.Get(ci)));

      if ( !DInv.IsEqI(INVALID_DATE_VALUE) )
      {
        sprintf(ts,"%02d.%02d.%4d", DInv.GetDay(), DInv.GetMonth(), DInv.GetYear());
        INV_NAC[CI] = ts;
      }

      INV_VSE[CI] = 0.0;
    }

    if ( -1 != fld[idxDATA_ATT] ) data_att = Tabl.Text(fld[idxDATA_ATT],zap);

    var matt = CreateObject("KMonth");
    matt.SetDate(SubStr(data_att,3));
    int amatt = nabs(matt.GetAbs());

    int tabdat = abdat - 1;

    double sum = 0.0;
    double sum1 = 0.0;
    int ginv = 0;

    var TrList = CreateObject("ParamFuncRW");
    var TrList1 = CreateObject("ParamFuncRW");

    if ( flTravmaOld ) TrList.IInitial1(static_cast_to_string(str),";",12);

    for ( int i = 1; i <= dper; i++ )
    {
      tabdat++;

      if ( MilTr ) if ( tabdat >= amatt ) continue;

      if ( !flTravmaOld )
      {
        sum = atof(Tabl.Text(fld[idxTRASUM01+i-1],zap));
        sum1 = atof(Tabl.Text(fld[idxTRABL01+i-1],zap));
        ginv = atoi(Tabl.Text(fld[idxTRAINV01+i-1],zap));
        aout[i-1] = atoi(Tabl.Text(fld[idxTRAUSL01+i-1],zap)); 
      }
      else
      {
        TrList1.IInitial1(TrList.Get(i-1),",",4);

        sum = atof(TrList1.Get(0));
        sum1 = atof(TrList1.Get(1));
        ginv = atoi(TrList1.Get(2));
        aout[i-1] = atoi(TrList1.Get(3)); 
      }

      if ( ginv > 3 && exeptInv ) ginv = 0;
      ainv[i-1] = ginv; 

      TraP += atra[i-1] = sum; 
      TrbP += atrb[i-1] = sum1; 

//    if ( nabs(sum) > eps )
      {
        tmp = atof(Tabl.Text(fld[idxSCH1+i-1],zap));
        sscc += tmp;
        if ( pol ) sswc += tmp;
        if ( ainv[i-1] ) ssic += tmp;
        if ( aout[i-1] ) ssbf += tmp;
      }

      if ( ainv[i-1] ) 
      {
        TriP += atri[i-1] = sum;
        tmp = sum * procInv / 100.0;
        round(tmp);
        TrnP += atrn[i-1] = sum - tmp;
        inctr[i-1] += tmp;
        rz = 0.0; roundd(tmp * sttar[i-1] / 100.0,_do,rz);
        tmtra[i-1] += rz;

        INV_VSE[CI] += sum;
      }
      else 
      {
        inctr[i-1] += sum;
        rz = 0.0; roundd(sum * sttar[i-1] / 100.0,_do,rz);
        tmtra[i-1] += rz;
      }
    }

    if ( INV )
    {
      if ( endotek == m0 )
      {
        INV_1ME[CI] = atri[dper-3];
        INV_2ME[CI] = atri[dper-2];
        INV_3ME[CI] = atri[dper-1];
      }

      if ( endotek == m1 )
      {
        INV_1ME[CI] = atri[dper-2];
        INV_2ME[CI] = atri[dper-1];
      }

      if ( endotek == m2 )
      {
        INV_1ME[CI] = atri[dper-1];
      }
    }

    if ( endotek == m0 )
    {
      Trn2 += atrn[dper-3];
      Trn1 += atrn[dper-2];
      Trn0 += atrn[dper-1];

      Trb2 += atrb[dper-3];
      Trb1 += atrb[dper-2];
      Trb0 += atrb[dper-1];
    }
    
    if ( endotek == m1 )
    {
      Trn2 += atrn[dper-2];
      Trn1 += atrn[dper-1];

      Trb2 += atrb[dper-2];
      Trb1 += atrb[dper-1];
    }
    
    if ( endotek == m2 )
    {
      Trn2 += atrn[dper-1];

      Trb2 += atrb[dper-1];
    }

    KorrMesPeriod(Tra2, Tra1, Tra0, 
                  Tri2, Tri1, Tri0, 
                  atra, atri, 
                  m0, m1, m2, 
                  endotek, dper);

    // доход
    double finc = atof(Tabl.Text(fld[idxINCP],zap));
    IncP += finc;
    Inc2 += atof( Tabl.Text( fld[idxINC2], zap));
    Inc1 += atof( Tabl.Text( fld[idxINC1], zap));
    Inc0 += atof( Tabl.Text( fld[idxINC0], zap));

    // налог
    TaxP += atof( Tabl.Text( fld[idxTAXP], zap));
    Tax2 += atof( Tabl.Text( fld[idxTAX2], zap));
    Tax1 += atof( Tabl.Text( fld[idxTAX1], zap));
    Tax0 += atof( Tabl.Text( fld[idxTAX0], zap));

    tmp = atof(Tabl.Text(fld[idxVMENP],zap));

    int flVme = ( nabs(tmp) < eps ) ? 0 : 1;

    // выплаты за счет соцстраха для вмененщиков и невмененщиков
    SumVme += atof(Tabl.Text(fld[idxVMENP],zap));
    sprintf(str,"%s", Tabl.Text(fld[idxSVLIST],zap));
    double tp = 0.0, asoc[dper], asov[dper];

//  var lsoc1 = CreateObject("ParamFuncRW");
//  lsoc1.IInitial1(static_cast_to_string(Tabl.Text(fld[idxSVLIST],zap)),";",100);
//
//  for ( int i = 0; i < dper; i++ )
//  {
//    var lsoc2 = CreateObject("ParamFuncRW");
//    lsoc2.IInitial1(lsoc1.Get(i),",",3);
//
//    double t1 = atof(lsoc2.Get(0)); // сумма невмененки - R_Tax(79)
//    double t2 = atof(lsoc2.Get(1)); // сумма вмененки с процента из КЧ
//    double t3 = atof(lsoc2.Get(2)); // сумма вмененки с видов
//
//    SocP += asoc[i] = t1 - t2;
//    SocP += asoc[i] = t1;
//    SovP += asov[i] = t2 + t3;
//
//    if ( !blvmen )
//    {
//       SocP += asoc[i] = t1;
//       SovP += asov[i] = t3;
//    }
//    else
//    {
//       SocP += asoc[i] = t1 - t2;
//       SovP += asov[i] = t2+t3;
//    }
//  }

//  KorrMesPeriod(Soc2, Soc1, Soc0, 
//                Sov2, Sov1, Sov0, 
//                asoc, asov, 
//                m0, m1, m2, 
//                endotek, dper);


    // расшифровка выплат на цели соцстраха
    for ( int i = idxDEC9; i < idxDEC9 + cPay; i++ )
    {
      var lst = CreateObject("ParamFuncRW");
      lst.IInitial1(static_cast_to_string(Tabl.Text(fld[i],zap)),",",18);

      Cnt[i-idxDEC9] += atoi(lst.Get(0)); // невмененка
      Dni[i-idxDEC9] += atoi(lst.Get(1));
      Sum[i-idxDEC9] += atof(lst.Get(2));

      Cnv[i-idxDEC9] += atof(lst.Get(3)); // вмененка
      Dnv[i-idxDEC9] += atof(lst.Get(4));
      Suv[i-idxDEC9] += atof(lst.Get(5));

      if ( i == idxDEC2 ) // по беременности и родам (совместительство)
      {
        Cnts += atoi(lst.Get(6)); // невмененка
        Dnis += atoi(lst.Get(7));
        Sums += atof(lst.Get(8));

        Cnvs += atof(lst.Get(9)); // вмененка
        Dnvs += atof(lst.Get(10));
        Suvs += atof(lst.Get(11));
      }

      if ( i == idxDEC9 ) // по болезни
      {
        Cnt9 += atoi(lst.Get(6)); // невмененка
        Dni9 += atoi(lst.Get(7));
        Sum9 += atof(lst.Get(8));

        Cnv9 += atof(lst.Get(9)); // вмененка
        Dnv9 += atof(lst.Get(10));
        Suv9 += atof(lst.Get(11));
      }

      if ( i == idxDEC3 ) // до 1.5 лет
      {
        // Замечание!!!
        // Массив cntLS0 и переменная cnvLS0, заведены для подсчета
        // кол-ва получающих оплату работников, которые печатаются
        // в строках 6 и 9 таблицы 3 и строке 5 таблицы 6.
        // Дело в том, что работник может одновременно получить
        // и пособие на первого ребенка и пособие на второго ребенка,
        // в этом случае он учтется как 1 получающий и в строке
        // 7(10) и в строке 8 (11) таблицы 3, в строке 6 и 7 таблицы 6.
        // Но, ВЕРОЯТНО (но это надо уточнять в ФСС) в отношении получателей
        // строка 6 не является суммой строк 7 и 8 и т.д.
        int idxar = 0;
        if ( fld[idxStudent]>-1 && atoi(Tabl.Text( fld[idxStudent], zap)))
           idxar=1;
        // невмененка (первый ребенок) 
        int cnt=atoi(lst.Get(6));; 
        bool bChecked = false; // признак того, что ЛС учтен для таблицы 3 
        bool bCheckedV = false; // признак того, что ЛС учтен для таблицы 6
        if ( cnt )
        {
           Cnt1[idxar] += cnt;
           Dni1[idxar] += atoi(lst.Get(7));
           Sum1[idxar] += atof(lst.Get(8));
           if ( !bChecked )
           {
              cntLS0[idxar]++;
              bChecked=true;
           }
           cntLS1[idxar]++;
        }

        // вмененка (первый ребенок) 
        cnt = atoi(lst.Get(9));
        if ( cnt )
        {
           Cnv1 += cnt; 
           Dnv1 += atof(lst.Get(10));
           Suv1 += atof(lst.Get(11));
           cnvLS1++;
           if ( !bCheckedV )
           {
              cnvLS0++;
              bCheckedV=true;
           }
        }

        // невмененка (второй и более ребенок) 
        cnt = atoi(lst.Get(12));
        if ( cnt )
        {
           Cnt2[idxar] += cnt;
           Dni2[idxar] += atoi(lst.Get(13));
           Sum2[idxar] += atof(lst.Get(14));
           cntLS2[idxar]++;
           if ( !bChecked )
           {
              cntLS0[idxar]++;
              bChecked=true;
           }
        }

        // вмененка (второй и более ребенок) 
        cnt = atoi(lst.Get(15));
        if ( cnt )
        {
           Cnv2 += cnt;
           Dnv2 += atof(lst.Get(16));
           Suv2 += atof(lst.Get(17));
           cnvLS2++;
           if ( !bCheckedV )
           {
              cnvLS0++;
              bCheckedV=true;
           }
        }
      }
    }

    // травматизм
    tmp = atof( Tabl.Text( fld[idxTRAP], zap)); if ( nabs(tmp) > eps ) { TroP += tmp; ChpT++; }
    Tro2 += atof( Tabl.Text( fld[idxTRA2], zap));
    Tro1 += atof( Tabl.Text( fld[idxTRA1], zap));
    Tro0 += atof( Tabl.Text( fld[idxTRA0], zap));

    TrdP += atof( Tabl.Text( fld[idxDNIP], zap));
    Trd2 += atof( Tabl.Text( fld[idxDNI2], zap));
    Trd1 += atof( Tabl.Text( fld[idxDNI1], zap));
    Trd0 += atof( Tabl.Text( fld[idxDNI0], zap));

    tmp = atof( Tabl.Text( fld[idxPRSP], zap)); if ( nabs(tmp) > eps ) { PrsP += tmp; ChpP++; }
    Prs2 += atof( Tabl.Text( fld[idxPRS2], zap));
    Prs1 += atof( Tabl.Text( fld[idxPRS1], zap));
    Prs0 += atof( Tabl.Text( fld[idxPRS0], zap));

    PrdP += atof( Tabl.Text( fld[idxPRDP], zap));

    OtsP += atof( Tabl.Text( fld[idxOTSP], zap));
    Ots2 += atof( Tabl.Text( fld[idxOTS2], zap));
    Ots1 += atof( Tabl.Text( fld[idxOTS1], zap));
    Ots0 += atof( Tabl.Text( fld[idxOTS0], zap));

    OtdP += atof( Tabl.Text( fld[idxOTDP], zap));

    MtrP += atof( Tabl.Text( fld[idxMTRP], zap));
    Mtr2 += atof( Tabl.Text( fld[idxMTR2], zap));
    Mtr1 += atof( Tabl.Text( fld[idxMTR1], zap));
    Mtr0 += atof( Tabl.Text( fld[idxMTR0], zap));

    UtrP += atof( Tabl.Text( fld[idxUTRP], zap));
    Utr2 += atof( Tabl.Text( fld[idxUTR2], zap));
    Utr1 += atof( Tabl.Text( fld[idxUTR1], zap));
    Utr0 += atof( Tabl.Text( fld[idxUTR0], zap));

////////////////////////////////////////////////////////////////////////////////

    var lst = CreateObject("ParamFuncRW");
    lst.IInitial1(static_cast_to_string(Tabl.Text(fld[idxTRAPS],zap)),",",18);
    
    // совместительство
    TrdS += atoi(lst.Get(7)); // дни  
    TroS += atof(lst.Get(8)); // сумма
    
    lst.IInitial1(static_cast_to_string(Tabl.Text(fld[idxPRSPS],zap)),",",18);
    
    // совместительство
    PrdS += atoi(lst.Get(7)); // дни  
    PrsS += atof(lst.Get(8)); // сумма
    
    lst.IInitial1(static_cast_to_string(Tabl.Text(fld[idxOTSPS],zap)),",",18);
    
    // совместительство
    OtdS += atoi(lst.Get(7)); // дни  
    OtsS += atof(lst.Get(8)); // сумма

////////////////////////////////////////////////////////////////////////////////

    // расчет ФСС

    double TEMP3 = atof(Tabl.Text(fld[idxINCP],zap)), // облагаемый доход
  
           rt70 = atof(Tabl.Text(fld[idxTAX70],zap)), // доход аттестованных военных
           rt73 = atof(Tabl.Text(fld[idxTAX73],zap)), // суммы налоговых льгот
  
           d503 = atof(Tabl.Text(fld[idxD503],zap)), // вычет по мат.помощи
           d504 = atof(Tabl.Text(fld[idxD504],zap)), // вычет по медикаментам
           d507 = atof(Tabl.Text(fld[idxD507],zap)), // вычет по натуроплате
           d508 = atof(Tabl.Text(fld[idxD508],zap)); // вычет из профсоюза

    double d902=0.; 
    char s112[len]; 
    sprintf(s112,"%s", Tabl.Text(fld[idxTAX112],zap)); 
    RealDed(s112, d902, 902);
  
    double d901 = rt73 - d503 - d504 - d507 - d508 - d902;

    double tnb = TEMP3 + d901;
  
    NalBase += tnb;
    NalLgot += d901;

    // численность
    if ( dper <= 12 ) 
    {
      for ( int i = 0; i < dper; i++ ) 
      {
        tmp = atof(Tabl.Text(fld[idxSCH1+i],zap));

//      sscc += tmp;
//      if ( pol ) sswc += tmp;
//      if ( ainv[i] ) ssic += tmp;
//      if ( aout[i] ) ssbf += tmp;

//      if ( nabs(tnb) > eps )
        {
          ssc += tmp;
          if ( pol ) ssw += tmp;
          if ( ainv[i] ) ssi += tmp;
        }

        if ( flVme || vme )
        {
          sscv += tmp;
          if ( pol ) sswv += tmp;
        }
      }
    }

    if ( INV )
    {
      CI++;
    }

    // Соц.выплаты по невмененке из 2-го ст.ТВХ для сводов
    for ( int i = 0; i < 12; i++ )
    {
      FssPays[i] += atof(Tabl.Text(fld[idxFSSPAY01+i],zap));
    }

  } // конец цикла по записям таблицы

  double RI4 = R14 + R34 + R44 + R64 + R74 + R84;
  int   SI14 = S14 + S24 + S54 + S84;
  int   WI14 = w14 + w24 + w54 + w84;

  // данные из справки о предприятии

  char Org[len]; RefEnt("ИМЯП"    ,Org,W); // наименование предприятия
  char Adr[len]; RefEnt("АДРП"    ,Adr,W); // адрес предприятия
  char Inn[len]; RefEnt("ИНН"     ,Inn,W); // ИНН
  char Kpp[len]; RefEnt("КОДПОСУЧ",Kpp,W); // КПП
  char Cni[len]; RefEnt("КОДНИ"   ,Cni,W); // код налоговой инспекции
  char Ssn[len]; RefEnt("ФССНОМ"  ,Ssn,W); // регистрационный номер в ФСС
  char Ruk[len]; RefEnt("РУКП"    ,Ruk,W); // ФИО руководителя
  char Glb[len]; RefEnt("ГЛБУХ"   ,Glb,W); // ФИО гл.бухгалтера

  char Okp[len]; RefEnt("ОКПО"    ,Okp,W); // код общероссийского классификатора прелприятий и организаций
  char Okv[len]; RefEnt("ОКВЭД"   ,Okv,W); // код общероссийского классификатора видов эконом. деятельности
  char Oko[len]; RefEnt("ОКОПФ"   ,Oko,W); // код общероссийского классификатора организационно-правовых форм
  char Okf[len]; RefEnt("ОКФС"    ,Okf,W); // код общероссийского классификатора форм собственности
  char Okn[len]; RefEnt("ОКОНХ"   ,Okn,W); // код общероссийского классификатора отраслей народного хозяйства
  char Grn[len]; RefEnt("ОГРН"    ,Grn,W); // Основной государственный регистрационный номер
  char Okd[len]; RefEnt("ОКДП"    ,Okd,W); // Общероссийский классификатор видов деятельности, продукции и услуг

  char Adr1[len]; Adr1[0] = 0;
  char Adr2[len]; Adr2[0] = 0;

  KorrAdr(Adr,Adr1,Adr2,W);

  char Nko[len]; GetValueClassif("T_GUIDE\\okopf.tab",Oko,Nko,60,"Value","Kod"); FreeSpaceString(Nko,3,"");
  
  try
  { 
  char Dir[len];
  GetCurrentDirectory(W,Dir);
  string nm = "TABLESN\\fss4_06.xlt";
  var WorkDir = Dir + "\\";
  var fullFileName = WorkDir+nm;

  tPrepereOfficeForWork(); // определяем работать на Excel или на Calc (определяем какой из офисов (MS Office или OpenOffice) установлен и какой предпочтительнее)
  tCreateXlsObjects(fullFileName,"Расчетная ведомость"); // создание основных объектов

///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 1

  tGetWshByIndex(1); // получаем ссылку на лист (worksheet)

  tWriteStringToCell("AJ20",period);
  tWriteStringToCell("BS20",year);
  tWriteStringToCell("A22",Org);
  tWriteStringToCell("H37",Adr1);
  tWriteStringToCell("A38",Adr2);

  tWriteStringToCell("CB29",Okp);
  tWriteStringToCell("CB30",Inn); 
  tWriteStringToCell("CQ30",Kpp);
  tWriteStringToCell("CB31",Grn);
  tWriteStringToCell("CB32",Okv);
  tWriteStringToCell("CQ32",Okn);
  tWriteStringToCell("CB33",Okd);
  tWriteStringToCell("CB34",Oko);
  tWriteStringToCell("CQ34",Okf);

  tWriteStringToCell("P35",OemToAnsi(Nko));


  tWriteStringToCell("AQ46",Ssn);
  tWriteStringToCell("U49",datatek);

///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 2
  tGetWshByIndex(2); // получаем ссылку на лист (worksheet)

  // табл.1  Для страхователей-налогоплательщиков уплачивающих ЕСН

  // налоговая база
  if ( nabs(NalBase) > eps ) tWriteNumToCell("CJ11", NalBase);
  if ( nabs(NalLgot) > eps ) tWriteNumToCell("CJ12", NalLgot);

  // считаем среднесписочную численность за период
  if ( dper ) 
  {
    sscc /= dper; round(sscc);    
    sswc /= dper; round(sswc); 
    ssic /= dper; round(ssic);
    ssbf /= dper; round(ssbf);

    ssc /= dper; round(ssc);    
    ssw /= dper; round(ssw); 
    ssi /= dper; round(ssi);

    sscv /= dper; round(sscv);    
    sswv /= dper; round(sswv); 
  }

  // итоги по численности
  if ( ssc > 0.00001 ) tWriteNumToCell("CJ9",  ssc);
  if ( ssw > 0.00001 ) tWriteNumToCell("CJ10", ssw);

// --------------------------------------------------------------------------------------------------------

  // табл.2  Расчеты по ЕСН

  tWriteStringToCell("B27", mn2);
  tWriteStringToCell("B28", mn1);
  tWriteStringToCell("B29", mn0);

  double tper = TaxP - ( Tax2 + Tax1 + Tax0 ),
         tkva = Tax2 + Tax1 + Tax0;

  // налог
  if ( nabs(tper) > eps ) tWriteNumToCell("AH25", tper); // на начало периода
  if ( nabs(Tax2) > eps ) tWriteNumToCell("AH27", Tax2); // за 1-й мксяц квартала
  if ( nabs(Tax1) > eps ) tWriteNumToCell("AH28", Tax1); // за 2-й мксяц квартала 
  if ( nabs(Tax0) > eps ) tWriteNumToCell("AH29", Tax0); // за 3-й мксяц квартала 

  tWriteStringToCell("BH27", mn2); // печатаем названия месяцев
  tWriteStringToCell("BH28", mn1);
  tWriteStringToCell("BH29", mn0);

  SocP = 0.0;
  Soc2 = 0.0;
  Soc1 = 0.0;
  Soc0 = 0.0;

  for ( int i = 0; i < dper; i++ ) SocP += FssPays[i];

  if ( mkv1 ) Soc2 = FssPays[mkv1-1];
  if ( mkv2 ) Soc1 = FssPays[mkv2-1];
  if ( mkv3 ) Soc0 = FssPays[mkv3-1];

  double sper = SocP - ( Soc2 + Soc1 + Soc0 ),
         skva = Soc2 + Soc1 + Soc0;

  // выплаты из средств соцстраха
  if ( nabs(sper) > eps ) tWriteNumToCell("CK25", sper); // на начало периода    
  if ( nabs(Soc2) > eps ) tWriteNumToCell("CK27", Soc2); // за 1-й мксяц квартала
  if ( nabs(Soc1) > eps ) tWriteNumToCell("CK28", Soc1); // за 2-й мксяц квартала
  if ( nabs(Soc0) > eps ) tWriteNumToCell("CK29", Soc0); // за 3-й мксяц квартала


  tWriteStringToCell("B34", mn2); // печатаем названия месяцев
  tWriteStringToCell("B35", mn1);
  tWriteStringToCell("B36", mn0);

  tWriteStringToCell("B42", mn2); // печатаем названия месяцев
  tWriteStringToCell("B43", mn1);
  tWriteStringToCell("B44", mn0);

  tWriteStringToCell("B50", mn2); // печатаем названия месяцев
  tWriteStringToCell("B51", mn1);
  tWriteStringToCell("B52", mn0);

  tWriteStringToCell("B56", mn2); // печатаем названия месяцев
  tWriteStringToCell("B57", mn1);
  tWriteStringToCell("B58", mn0);

///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 3
  tGetWshByIndex(3); // получаем ссылку на лист (worksheet)

  // табл.3  Зачтено расходов на цели гос.соц.страхования с начала года
  RasSocVyp1(Dni, Cnt, Sum, 
             Dnis, Cnts, Sums, 
             Dni9, Cnt9, Sum9, 
             Dni1, Cnt1, Sum1,cntLS1,
             Dni2, Cnt2, Sum2,cntLS2);

  if ( SrzCount1_5 )
  {
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE01N])); if ( tmi ) tWriteNumToCell("BK62", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE02N])); if ( tmi ) tWriteNumToCell("BK63", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE03N])); if ( tmi ) tWriteNumToCell("BK64", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE04N])); if ( tmi ) tWriteNumToCell("BK65", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE05N])); if ( tmi ) tWriteNumToCell("BK66", tmi);
  }
  else
  {
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE11N])); if ( tmi ) tWriteNumToCell("BK62", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE12N])); if ( tmi ) tWriteNumToCell("BK63", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE13N])); if ( tmi ) tWriteNumToCell("BK64", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE14N])); if ( tmi ) tWriteNumToCell("BK65", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE15N])); if ( tmi ) tWriteNumToCell("BK66", tmi);
  }

///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 5
  tGetWshByIndex(5); // получаем ссылку на лист (worksheet)

  // табл.6  Расходы на цели гос.соц.страхования с начала года
  RasSocVyp2(Dnv, Cnv, Suv, 
             Dnvs, Cnvs, Suvs, 
             Dnv9, Cnv9, Suv9, 
             Dnv1, Cnv1, Suv1,cntLS1, 
             Dnv2, Cnv2, Suv2,cntLS2);

  if ( SrzCount1_5 )
  {
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE01V])); if ( tmi ) tWriteNumToCell("BK45", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE02V])); if ( tmi ) tWriteNumToCell("BK46", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE03V])); if ( tmi ) tWriteNumToCell("BK47", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE04V])); if ( tmi ) tWriteNumToCell("BK48", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE05V])); if ( tmi ) tWriteNumToCell("BK49", tmi);
  }                                                                                          
  else                                                                                       
  {                                                                                          
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE11V])); if ( tmi ) tWriteNumToCell("BK45", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE12V])); if ( tmi ) tWriteNumToCell("BK46", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE13V])); if ( tmi ) tWriteNumToCell("BK47", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE14V])); if ( tmi ) tWriteNumToCell("BK48", tmi);
    tmi = atoi(Tabl.Get_Bottom_Text(fld[idxRANGE15V])); if ( tmi ) tWriteNumToCell("BK49", tmi);
  }


///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 4
  tGetWshByIndex(4); // получаем ссылку на лист (worksheet)

//double vper = SovP - ( Sov2 + Sov1 + Sov0 ),
//       vkva = Sov2 + Sov1 + Sov0;

  // расходы на цели ФСС

  if ( nabs(SumVme) > eps ) tWriteNumToCell("BK14", SumVme); // сумма вмененного дохода

  if ( nabs(SovP) > eps ) tWriteNumToCell("CU28", SovP); // за период

  {
    if ( sscv > eps ) tWriteNumToCell("BK12", sscv); // всего 
    if ( sswv > eps ) tWriteNumToCell("BK13", sswv); // в том числе женщин
  }


///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 7
  // Раздел III
  // Для страхователей, уплачивающих страховые взносы на обязательное социальное страхование от несчастных
  // случаев на производстве и профессиональных заболеваний

  tGetWshByIndex(7); // получаем ссылку на лист (worksheet)

  // табл.9
  // среднесписочная численность
  if ( sscc > eps ) tWriteNumToCell("A17", sscc); // всего 
  if ( ssic > eps ) tWriteNumToCell("H17", ssic); // в том числе инвалидов
  if ( ssbf > eps ) tWriteNumToCell("O17", ssbf); // в том числе инвалидов

  tWriteStringToCell("Y15", mn2); // печатаем названия месяцев
  tWriteStringToCell("Y16", mn1);
  tWriteStringToCell("Y17", mn0);

  tper = TraP,
  tkva = Tra2 + Tra1 + Tra0;

  double tpei = TriP,
         tkvi = Tri2 + Tri1 + Tri0;

  double tpen = TrnP,
         tkvn = Trn2 + Trn1 + Trn0;

  double tpeb = TrbP,
         tkvb = Trb2 + Trb1 + Trb0;


  if ( strInv )
  {
    tpeb += tpen;
    tkvb += tkvn;
    Trb2 += Trn2;
    Trb1 += Trn1;
    Trb0 += Trn0;
  }

  if ( nabs(tper) > eps ) tWriteNumToCell("Y13", tper);  // за период
  if ( nabs(Tra2) > eps ) tWriteNumToCell("Y15", Tra2);  // за 1-й мксяц квартала
  if ( nabs(Tra1) > eps ) tWriteNumToCell("Y16", Tra1);  // за 2-й мксяц квартала
  if ( nabs(Tra0) > eps ) tWriteNumToCell("Y17", Tra0);  // за 3-й мксяц квартала

  if ( nabs(tpei) > eps ) tWriteNumToCell("AO13", tpei); // за период
  if ( nabs(Tri2) > eps ) tWriteNumToCell("AO15", Tri2); // за 1-й мксяц квартала
  if ( nabs(Tri1) > eps ) tWriteNumToCell("AO16", Tri1); // за 2-й мксяц квартала
  if ( nabs(Tri0) > eps ) tWriteNumToCell("AO17", Tri0); // за 3-й мксяц квартала

  if ( nabs(tpeb) > eps ) tWriteNumToCell("AX13", tpeb); // за период
  if ( nabs(Trb2) > eps ) tWriteNumToCell("AX15", Trb2); // за 1-й мксяц квартала
  if ( nabs(Trb1) > eps ) tWriteNumToCell("AX16", Trb1); // за 2-й мксяц квартала
  if ( nabs(Trb0) > eps ) tWriteNumToCell("AX17", Trb0); // за 3-й мксяц квартала

  if ( nabs(st6) > eps ) tWriteNumToCell("BF17", st6); // размер страхового тарифа в соответствии с классом профессионального риска %
  if ( nabs(st7) > eps ) tWriteNumToCell("BR17", st7); // скидка к страховому тарифу %
  if ( nabs(st9) > eps ) tWriteNumToCell("CK17", st9); // надбавка к страховому тарифу %
  if ( strlen(dst) )     tWriteStringToCell("CA17", dst);  // дата установления надбавки
  if ( nabs(sttar[dper-1]) > eps ) 
                         tWriteNumToCell("CQ17", sttar[dper-1]); // размер страхового тарифа с учетом скидки (надбавки) %

//---------------------------------------------------------------------------------------------------------

  // табл.10
  // Расчеты по средствам обязательного социального страхования от несчастных случаев на производстве
  // и профессиональных заболеваний

    for ( int i = 0; i < dper; i++ )
    {
      if ( TM ) taxtr[i] = inctr[i] * sttar[i] / 100.0; // процент берется от общей суммы за месяц
      else      taxtr[i] = tmtra[i];                    // процент берется от суммы по ЛС

      round(taxtr[i]);
      TtrP += taxtr[i];
    }

  if ( endotek == m0 ) { Ttr2 = taxtr[dper-3];                     
                         Ttr1 = taxtr[dper-2];
                         Ttr0 = taxtr[dper-1]; }
                         
  if ( endotek == m1 ) { Ttr2 = taxtr[dper-2];                     
                         Ttr1 = taxtr[dper-1]; }
  
  if ( endotek == m2 ) { Ttr2 = taxtr[dper-1]; }

  // отчисления по травматизму

  tWriteStringToCell("B33", mn2); // печатаем названия месяцев
  tWriteStringToCell("B34", mn1);
  tWriteStringToCell("B35", mn0);

  tper = TtrP - ( Ttr2 + Ttr1 + Ttr0 ),
  tkva = Ttr2 + Ttr1 + Ttr0;

  if ( nabs(tper) > eps ) tWriteNumToCell("AB31", tper); // на начало периода
  if ( nabs(Ttr2) > eps ) tWriteNumToCell("AB33", Ttr2); // за 1-й месяц квартала
  if ( nabs(Ttr1) > eps ) tWriteNumToCell("AB34", Ttr1); // за 2-й месяц квартала 
  if ( nabs(Ttr0) > eps ) tWriteNumToCell("AB35", Ttr0); // за 3-й месяц квартала 

  // расходы по травматизму

  tWriteStringToCell("BE33", mn2); // печатаем названия месяцев
  tWriteStringToCell("BE34", mn1);
  tWriteStringToCell("BE35", mn0);

  tper = TroP - ( Tro2 + Tro1 + Tro0 ) +
         PrsP - ( Prs2 + Prs1 + Prs0 ) +
         MtrP - ( Mtr2 + Mtr1 + Mtr0 ) +
         UtrP - ( Utr2 + Utr1 + Utr0 ) +
         OtsP - ( Ots2 + Ots1 + Ots0 );

  tkva = Tro2 + Tro1 + Tro0 +
         Prs2 + Prs1 + Prs0 +
         Mtr2 + Mtr1 + Mtr0 +
         Ots2 + Ots1 + Ots0;

  Tro2 += (Prs2 + Ots2 + Mtr2 + Utr2);
  Tro1 += (Prs1 + Ots1 + Mtr1 + Utr1);
  Tro0 += (Prs0 + Ots0 + Mtr0 + Utr0);

  if ( nabs(tper) > eps ) tWriteNumToCell("CE31", tper); // на начало периода
  if ( nabs(Tro2) > eps ) tWriteNumToCell("CE33", Tro2); // за 1-й месяц квартала
  if ( nabs(Tro1) > eps ) tWriteNumToCell("CE34", Tro1); // за 2-й месяц квартала 
  if ( nabs(Tro0) > eps ) tWriteNumToCell("CE35", Tro0); // за 3-й месяц квартала 

///////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 8
  tGetWshByIndex(8); // получаем ссылку на лист (worksheet)

  // табл.11

  // Зачтено расходов по обязательному социальному страхованию от несчастных случаев на производстве
  // и профессиональных заболеваний с начала года

  if ( nabs(TrdP) > eps ) tWriteNumToCell("BM8", TrdP); // дней по травме
  if ( nabs(TroP) > eps ) tWriteNumToCell("CE8", TroP); // сумма БЛ по травме
                                                    
  // совместительство                               
  if ( nabs(TrdS) > eps ) tWriteNumToCell("BM9", TrdS); // дней по травме
  if ( nabs(TroS) > eps ) tWriteNumToCell("CE9", TroS); // сумма БЛ по травме

  if ( nabs(PrdP) > eps ) tWriteNumToCell("BM11", PrdP); // дней по профзаболеваниям
  if ( nabs(PrsP) > eps ) tWriteNumToCell("CE11", PrsP); // сумма БЛ по профзаболеваниям
                                                     
  // совместительство                                
  if ( nabs(PrdS) > eps ) tWriteNumToCell("BM12", PrdS); // дней по профзаболеваниям
  if ( nabs(PrsS) > eps ) tWriteNumToCell("CE12", PrsS); // сумма БЛ по профзаболеваниям
                                                     
  if ( nabs(OtdP) > eps ) tWriteNumToCell("BM14", OtdP); // дней по леч.отпускам
  if ( nabs(OtsP) > eps ) tWriteNumToCell("CE14", OtsP); // сумма БЛ по леч.отпускам
                                                     
  if ( nabs(MtrP) > eps ) tWriteNumToCell("CE16", MtrP); // предупредительные меры
  if ( nabs(UtrP) > eps ) tWriteNumToCell("CE17", UtrP); // углубленные осмотры
                                                     
  // таблица 12                                      
  if ( nabs(ChpT) > eps ) tWriteNumToCell("BT29", ChpT); // численность пострадавших по травме
  if ( nabs(ChpP) > eps ) tWriteNumToCell("BT31", ChpP); // численность пострадавших по профзаболеваниям

  tWriteStringToCell("AX40", Ruk);
  tWriteStringToCell("AX44", Glb);

  var mt = CreateObject("KMonth");

  for ( int i = 0, j = 3; j < 10; i++,j++ )
  {
    str[i] = datatek[j];
  }

  str[7] = 0;

  mt.SetDate(static_cast_to_string(str));
  sprintf(arg,"11,%d",mt.GetRel());
  R_DATA_EX(arg,str,W,A);
  FreeSpaceString(str,3,"");
  string smes = OemToAnsi(str);
  tWriteStringToCell("T37",smes);

  sprintf(str,"%c%c",datatek[0],datatek[1]);
  string sday = static_cast_to_string(str);
  tWriteStringToCell("N37",sday);

  sprintf(str,"%c",datatek[9]);
  string syear = static_cast_to_string(str);

  tWriteStringToCell("AM37",syear);

//////////////////////////////////////////////////////////////////////////////////////////////////////////

  // лист 10
  tGetWshByIndex(10); // получаем ссылку на лист (worksheet)

  tWriteStringToCell("BW10",period);
  tWriteStringToCell("CL10",year);

  string sorg = Org + ", " + Adr1 + Adr2 + ", " + Ssn + ", " + Okv;
  tWriteStringToCell("AN11",sorg);

  tWriteStringToCell("A19",sscc);
  tWriteStringToCell("DX22",Ruk);
  tWriteStringToCell("AQ22",Glb);
  tWriteStringToCell("Z25",smes);
  tWriteStringToCell("U25",sday);
  tWriteStringToCell("AP25",syear);



//////////////////////////////////////////////////////////////////////////////////////////////////////////


  tGetWshByIndex(9); // получаем ссылку на лист (worksheet)

  if ( CI )
  {
    tWshSelect();

    int n = 5;
    char cel[len];

    double itg_vse = 0.0,
           itg_kva = 0.0,
           itg_1me = 0.0,
           itg_2me = 0.0,
           itg_3me = 0.0;

    for ( int i = 0; i < CI; i++ )
    {
      tInsertRows(n,1); // вставка одной строки
      tCopyRow(n); // копирование строки n-1 в строку n

      sprintf(cel,"A%d",n-1);
      tWriteNumToCell(cel,i+1);

      sprintf(cel,"B%d",n-1);
      tWriteStringToCell(cel,INV_FIO[i]);

      sprintf(cel,"C%d",n-1);
      tWriteNumToCell(cel,INV_VSE[i]);

      sprintf(cel,"D%d",n-1);
      tmp = INV_1ME[i] + INV_2ME[i] + INV_3ME[i];
      tWriteNumToCell(cel,tmp);

      sprintf(cel,"E%d",n-1);
      tWriteNumToCell(cel,INV_1ME[i]);

      sprintf(cel,"F%d",n-1);
      tWriteNumToCell(cel,INV_2ME[i]);

      sprintf(cel,"G%d",n-1);
      tWriteNumToCell(cel,INV_3ME[i]);

      itg_vse += INV_VSE[i];
      itg_kva += tmp;
      itg_1me += INV_1ME[i];
      itg_2me += INV_2ME[i];
      itg_3me += INV_3ME[i];

      sprintf(cel,"H%d",n-1);
      tWriteNumToCell(cel,INV_GRU[i]);

      sprintf(cel,"I%d",n-1);
      tWriteStringToCell(cel,INV_DAT[i]);

      sprintf(cel,"J%d",n-1);
      tWriteStringToCell(cel,INV_KON[i]);

      sprintf(cel,"K%d",n-1);
      tWriteStringToCell(cel,INV_SER[i]);

      sprintf(cel,"L%d",n-1);
      tWriteStringToCell(cel,INV_NOM[i]);

      sprintf(cel,"M%d",n-1);
      tWriteStringToCell(cel,INV_NAC[i]);

      n++;
    }

    tDeleteRows(n-1,1); // удаление одной строки

    sprintf(cel,"C%d",n-1); tWriteNumToCell(cel,itg_vse);
    sprintf(cel,"D%d",n-1); tWriteNumToCell(cel,itg_kva);
    sprintf(cel,"E%d",n-1); tWriteNumToCell(cel,itg_1me);
    sprintf(cel,"F%d",n-1); tWriteNumToCell(cel,itg_2me);
    sprintf(cel,"G%d",n-1); tWriteNumToCell(cel,itg_3me);
    

    tWshCellSelect(1,1);
    tGetWshByIndex(1);
    tWshSelect();
  }
  else
  {
    tWshHide(); // делаем лист невидимым
  }

///////////////////////////////////////////////////////////////////////////////////////////////////////////
  }
  catch(object err)
  {
    SayError(err);
  }
  catch(...)
  {
    ;
  }

  tMakeXlsVisible(); // делаем форму видимой

  return 0;
}

//=====================================================================================================================

KorrAdr(&str,&str1,&str2,n)
{
  var List = CreateObject("ParamFuncRW");
  List.IInitial(static_cast_to_string(str),",",100);

  int clm = List.Count();
  int flg = 0;

  for ( int i = 0; i < clm; i++ )
  {
    string s = List.Get(i);

    if ( strlen(str1) + strlen(s) > 37 ) flg = 1;

    if ( !flg )
    {
      str1 += s;
      if ( i < clm-1 ) str1 += ",";
    }
    else
    {
      str2 += s;
      if ( i < clm-1 ) str2 += ",";
    }
  }
}

//=====================================================================================================================

RefEnt(name,&str,n)
{
  GetEnterpriseVar(name,str,n);
  FreeSpaceString(str,3,"");
  UpperString(str);
  OemToChar(str,str);
}

//=====================================================================================================================

MonthName(&name,month)
{
  sprintf(arg,"1,%d",month);
  sprintf(ts,"%-*.*s",W,A,R_DATA_EX(arg,str,W,A));
  FreeSpaceString(ts,3,"");
  OemToChar(ts,ts);
  name=ts;
}

//=====================================================================================================================

RealDed( str, &sum, n)
{
  FreeSpaceString(str,3,"");
  int celem=count_elem(str,';');
  for (int i=1; i<=celem; i++)
  {
    char buf1[len];
    char buf2[len];
    char buf3[len];

    for ( int j = 0; j < len; j++ ) buf1[j] = buf2[j] = buf3[j] = 0;

    elem_of_array(str,i,';',buf1,99);
    elem_of_array(buf1,1,',',buf2,99);
    int ded=atoi(buf2);
    if (ded==n)
    {
      elem_of_array(buf1,2,',',buf3,99);
      sum = atof(buf3);
    }
  }
}

//=====================================================================================================================

RasSocVyp1(&Dni, &Cnt, &Sum, 
           &Dnis, &Cnts, &Sums, 
           &Dni9, &Cnt9, &Sum9, 
           &Dni1, &Cnt1, &Sum1,&cntLS1,
           &Dni2, &Cnt2, &Sum2,&cntLS2)
{
  // (стр.1) по временной нетрудоспособности 
  if ( nabs(Cnt[0]) > eps ) tWriteNumToCell("Q9",  Cnt[0]); // случаев 
  if ( nabs(Dni[0]) > eps ) tWriteNumToCell("BK7", Dni[0]); // дней    
  if ( nabs(Sum[0]) > eps ) tWriteNumToCell("BW7", Sum[0]); // сумма

  // (стр.2) вр.нетрудоспособность (совместительство)
  if ( nabs(Cnt9) > eps ) tWriteNumToCell("V12",  Cnt9); // случаев 
  if ( nabs(Dni9) > eps ) tWriteNumToCell("BK11", Dni9); // дней    
  if ( nabs(Sum9) > eps ) tWriteNumToCell("BW11", Sum9); // сумма

  // (стр.3) по беременности и родам 
  if ( nabs(Dni[1]) > eps ) tWriteNumToCell("BK14", Dni[1]); // дней    
  if ( nabs(Sum[1]) > eps ) tWriteNumToCell("BW14", Sum[1]); // сумма 

  // (стр.4) по беременности и родам (совместительство) 
  if ( nabs(Dnis) > eps ) tWriteNumToCell("BK15", Dnis); // дней    
  if ( nabs(Sums) > eps ) tWriteNumToCell("BW15", Sums); // сумма 

  // (стр.5) до 1.5 лет всего
  int rab1_5 = cntLS1[0]+cntLS2[0];
  int stud1_5 = cntLS1[1]+cntLS2[1];
  int all1_5 = rab1_5+stud1_5;
  if ( !rab1_5 )
  {
    tWriteStringToCell("AB21", "");
    tWriteStringToCell("BK19", "");
    tWriteStringToCell("BW19", "");
  }
  if ( !stud1_5 )
  { 
    tWriteStringToCell("AB30", "");
    tWriteStringToCell("BK29", "");
    tWriteStringToCell("BW29", "");
  }
  if ( !all1_5 )
  {
    tWriteStringToCell("X17",  "");
    tWriteStringToCell("BK16", "");
    tWriteStringToCell("BW16", "");
  }
  else
  {
     // {{"BK23","BW23","AG24","BK26","BW26","AG27"},     
     //  {"BK32","BW32","AG33","BK35","BW35","AG36"}};
     string Range[2][7];
     Range[0][0]="BK23",Range[0][1]="BW23",Range[0][2]="AG24",
     Range[0][3]="BK26",Range[0][4]="BW26",Range[0][5]="AG27",Range[0][6]="AB21",
     Range[1][0]="BK32",Range[1][1]="BW32",Range[1][2]="AG33",
     Range[1][3]="BK35",Range[1][4]="BW35",Range[1][5]="AG36",Range[1][6]="AB30";
     for ( int idx=0; idx<2; ++idx )
     {
        if ( cntLS0[idx] )
        { 
           // Если подсчитываем "физ.лица" то перезатираем формулу "суммирования"
           // в шаблоне посчитанным кол-вом получателей
           if ( !TypeCalcCount1_5 )
              tWriteNumToCell(Range[idx][6], cntLS0[idx]); // получателей        
           // (стр.7,10) до 1.5 лет - 1-й ребенок
           if ( nabs(Cnt1[idx]) > eps )
           {
              tWriteNumToCell(Range[idx][0], Cnt1[idx]); // случаев    
              if ( nabs(Sum1[idx]) > eps ) tWriteNumToCell(Range[idx][1], Sum1[idx]); // сумма    
              if ( cntLS1[idx] ) tWriteNumToCell(Range[idx][2], cntLS1[idx]); // получателей    
           }
           // (стр.8,11) до 1.5 лет - 2-й ребенок
           if ( nabs(Cnt2[idx]) > eps )
           { 
              tWriteNumToCell(Range[idx][3], Cnt2[idx]); // случаев    
              if ( nabs(Sum2[idx]) > eps ) tWriteNumToCell(Range[idx][4], Sum2[idx]); // сумма    
              if ( cntLS2[idx] ) tWriteNumToCell(Range[idx][5], cntLS2[idx]); // получателей    
           }
         }
     }
  }
  // (стр.12) при рождении 
  if ( nabs(Cnt[3]) > eps ) tWriteNumToCell("BK38", Cnt[3]); // случаев    
  if ( nabs(Sum[3]) > eps ) tWriteNumToCell("BW38", Sum[3]); // сумма      

  // (стр.13) на погребение 
  if ( nabs(Cnt[4]) > eps ) tWriteNumToCell("BK39", Cnt[4]); // случаев    
  if ( nabs(Sum[4]) > eps ) tWriteNumToCell("BW39", Sum[4]); // сумма      

  // (стр.14) по уходу за детьми-инвалидами 
  if ( nabs(Dni[5]) > eps ) tWriteNumToCell("BK40", Dni[5]); // дней
  if ( nabs(Sum[5]) > eps ) tWriteNumToCell("BW40", Sum[5]); // сумма    

  // (стр.15) ранние сроки беременности 
  if ( nabs(Cnt[6]) > eps ) tWriteNumToCell("BK41", Cnt[6]); // случаев
  if ( nabs(Sum[6]) > eps ) tWriteNumToCell("BW41", Sum[6]); // сумма      

  // (стр.16) при усыновлении 
//if ( nabs(Cnt[7]) > eps ) tWriteNumToCell("BK42", Cnt[7]); // случаев
//if ( nabs(Sum[7]) > eps ) tWriteNumToCell("BW42", Sum[7]); // сумма      

  // (стр.18) детские лагеря 
  if ( nabs(Cnt[8]) > eps ) tWriteNumToCell("BK44", Cnt[8]); // случаев
  if ( nabs(Sum[8]) > eps ) tWriteNumToCell("BW44", Sum[8]); // сумма

  // (стр.19) санаторные лагеря 
  if ( nabs(Cnt[9]) > eps ) tWriteNumToCell("BK48", Cnt[9]); // случаев
  if ( nabs(Sum[9]) > eps ) tWriteNumToCell("BW48", Sum[9]); // сумма

  // (стр.20) детские санатории 
  if ( nabs(Cnt[10]) > eps ) tWriteNumToCell("BK49", Cnt[10]); // случаев
  if ( nabs(Sum[10]) > eps ) tWriteNumToCell("BW49", Sum[10]); // сумма

  // (стр.21) возмещение комендировочных расходов за сопровождение детей в лагеря 
  if ( nabs(Cnt[11]) > eps ) tWriteNumToCell("BK50", Cnt[11]); // случаев
  if ( nabs(Sum[11]) > eps ) tWriteNumToCell("BW50", Sum[11]); // сумма

  // (стр.22) санаторно-курортное лечение 
  if ( nabs(Cnt[12]) > eps )
  {
    tWriteStringToCell("B51","╧юыэр  (ўрёЄшўэр ) юяырЄр яєЄхтюъ эр ёрэрЄюЁэю-ъєЁюЁЄэюх ыхўхэшх ЁрсюЄэшъют"); //WriteToCell("B51","╧юыэр  (ўрёЄшўэр ) юяырЄр яєЄхтюъ эр ёрэрЄюЁэю-ъєЁюЁЄэюх ыхўхэшх ЁрсюЄэшъют");
    tWriteStringToCell("BW51"," ");
    tHorizontalAlignmentCell("BW51",1);
    tFontSizeCell("BW51",8);
    tWriteNumToCell("BK51", Cnt[12]); // случаев
  }
  if ( nabs(Sum[12]) > eps ) tWriteNumToCell("BW51", Sum[12]); // сумма
}

//=====================================================================================================================

RasSocVyp2(&Dni, &Cnt, &Sum, 
           &Dnvs, &Cnvs, &Suvs, 
           &Dnv9, &Cnv9, &Suv9, 
           &Dnv1, &Cnv1, &Suv1,&cntLS1, 
           &Dnv2, &Cnv2, &Suv2,&cntLS2)
{
  // по временной нетрудоспособности (стр.1)
  if ( nabs(Cnt[0]) > eps ) tWriteNumToCell("Q9",  Cnt[0]); // случаев 
  if ( nabs(Dni[0]) > eps ) tWriteNumToCell("BK7", Dni[0]); // дней    
  if ( nabs(Sum[0]) > eps ){tWriteNumToCell("BW7", Sum[0]); SovP += Sum[0];}// сумма

  if ( nabs(Cnv9) > eps ) tWriteNumToCell("V12",  Cnv9); // случаев 
  if ( nabs(Dnv9) > eps ) tWriteNumToCell("BK11", Dnv9); // дней    
  if ( nabs(Suv9) > eps ) tWriteNumToCell("BW11", Suv9); // сумма

  // по беременности и родам (стр.3)
  if ( nabs(Dni[1]) > eps ) tWriteNumToCell("BK14", Dni[1]); // дней    
  if ( nabs(Sum[1]) > eps ){tWriteNumToCell("BW14", Sum[1]); SovP += Sum[1];}// сумма 

  // по беременности и родам (совместительство) (стр.4)
  if ( nabs(Dnvs) > eps ) tWriteNumToCell("BK15", Dnvs); // дней    
  if ( nabs(Suvs) > eps ) tWriteNumToCell("BW15", Suvs); // сумма 

  // до 1.5 лет (стр.5)
  int all1_5 = cnvLS1+cnvLS2;
  if ( !all1_5 )
  {
     tWriteStringToCell("AB17", "");
     tWriteStringToCell("BK16", "");
     tWriteStringToCell("BW16", "");
  }
  else
  {
     if ( cnvLS0 )
     {
        // Если подсчитываем "физ.лица" то перезатираем формулу "суммирования"
        // в шаблоне посчитанным кол-вом получателей
        if ( !TypeCalcCount1_5 )
           tWriteNumToCell("AB17", cnvLS0); // получателей    
        if ( nabs(Cnv1) > eps )
        {
           tWriteNumToCell("BK19", Cnv1); // случаев    
           if ( nabs(Suv1) > eps ){tWriteNumToCell("BW19", Suv1); SovP += Suv1;}// сумма    
           if ( cnvLS1 ) tWriteNumToCell("AG20", cnvLS1); // получателей    
        }
        if ( nabs(Cnv2) > eps )
        {
           tWriteNumToCell("BK22", Cnv2); // случаев    
           if ( nabs(Suv2) > eps ){tWriteNumToCell("BW22", Suv2); SovP += Suv2;}// сумма    
           if ( cnvLS2 ) tWriteNumToCell("AG23", cnvLS2); // получателей    
        }
     }
  }

  // при рождении (стр.8)
  if ( nabs(Cnt[3]) > eps ) tWriteNumToCell("BK25", Cnt[3]); // случаев    
  if ( nabs(Sum[3]) > eps ){tWriteNumToCell("BW25", Sum[3]); SovP += Sum[3];}// сумма      

  // на погребение (стр.9)
  if ( nabs(Cnt[4]) > eps ) tWriteNumToCell("BK26", Cnt[4]); // случаев    
  if ( nabs(Sum[4]) > eps ){tWriteNumToCell("BW26", Sum[4]); SovP += Sum[4];}// сумма      

  // по уходу за детьми-инвалидами (стр.10)
  if ( nabs(Dni[5]) > eps ) tWriteNumToCell("BK27", Dni[5]); // дней
  if ( nabs(Sum[5]) > eps ){tWriteNumToCell("BW27", Sum[5]); SovP += Sum[5];}// сумма    

  // ранние сроки беременности (стр.11)
  if ( nabs(Cnt[6]) > eps ) tWriteNumToCell("BK28", Cnt[6]); // случаев
  if ( nabs(Sum[6]) > eps ){tWriteNumToCell("BW28", Sum[6]); SovP += Sum[6];}// сумма      

  // при усыновлении (стр.12)
//if ( nabs(Cnt[7]) > eps ) tWriteNumToCell("BK29", Cnt[7]); // случаев
//if ( nabs(Sum[7]) > eps ){tWriteNumToCell("BW29", Sum[7]); SovP += Sum[7];}// сумма      

  // детские лагеря (стр.14)
  if ( nabs(Cnt[8]) > eps ) tWriteNumToCell("BK31", Cnt[8]); // случаев
  if ( nabs(Sum[8]) > eps ){tWriteNumToCell("BW31", Sum[8]); SovP += Sum[8];}// сумма

  // санаторные лагеря (стр.15)
  if ( nabs(Cnt[9]) > eps ) tWriteNumToCell("BK35", Cnt[9]); // случаев
  if ( nabs(Sum[9]) > eps ){tWriteNumToCell("BW35", Sum[9]); SovP += Sum[9];}// сумма

  // детские санатории (стр.16)
  if ( nabs(Cnt[10]) > eps ) tWriteNumToCell("BK36", Cnt[10]); // случаев
  if ( nabs(Sum[10]) > eps ){tWriteNumToCell("BW36", Sum[10]); SovP += Sum[10];}// сумма

  // возмещение комендировочных расходов за сопровождение детей в лагеря (стр.17)
  if ( nabs(Cnt[11]) > eps ) tWriteNumToCell("BK37", Cnt[11]); // случаев
  if ( nabs(Sum[11]) > eps ){tWriteNumToCell("BW37", Sum[11]); SovP += Sum[11];}// сумма

  // Санаторно-курортное лечение (строка 18)
  if ( nabs(Cnt[12]) > eps )
  {
     tWriteStringToCell("B38","╧юыэр  (ўрёЄшўэр ) юяырЄр яєЄхтюъ эр ёрэрЄюЁэю-ъєЁюЁЄэюх ыхўхэшх ЁрсюЄэшъют"); //WriteToCell("B38","╧юыэр  (ўрёЄшўэр ) юяырЄр яєЄхтюъ эр ёрэрЄюЁэю-ъєЁюЁЄэюх ыхўхэшх ЁрсюЄэшъют");
     tWriteStringToCell("BW38"," ");
     tHorizontalAlignmentCell("BW38",1);
     tFontSizeCell("BW38",8);
     tWriteNumToCell("BK38", Cnt[12]); // случаев
  }
  if ( nabs(Sum[12]) > eps ){tWriteNumToCell("BW38", Sum[12]); SovP += Sum[12];} // сумма
}

//=====================================================================================================================

KorrMesPeriod(&v2, &v1, &v0, &p2, &p1, &p0, &av, &ap, m0, m1, m2, endotek, dper)
{
  if ( endotek == m0 )
  {
    v2 += av[dper-3]; p2 += ap[dper-3];
    v1 += av[dper-2]; p1 += ap[dper-2];
    v0 += av[dper-1]; p0 += ap[dper-1];
  }
  
  if ( endotek == m1 )
  {
    v2 += av[dper-2]; p2 += ap[dper-2];
    v1 += av[dper-1]; p1 += ap[dper-1];
  }
  
  if ( endotek == m2 )
  {
    v2 += av[dper-1]; p2 += ap[dper-1];
  }

  return 0;
}

//=====================================================================================================================

clear( &str )
{
  for ( int i = strlen(str) - 1; i >= 0 ; i-- ) 
  {
    str[i] = 0;
  }

  return 0;
}

//=====================================================================================================================

FillFld()
//=============================================================================
// Находим поля в таблице
//=============================================================================
{
  fld[idxBDAT]      = Tabl.Find_Name_Fld("BDAT");
  fld[idxEDAT]      = Tabl.Find_Name_Fld("EDAT");
  fld[idxABDAT]     = Tabl.Find_Name_Fld("ABDAT");
  fld[idxAEDAT]     = Tabl.Find_Name_Fld("AEDAT");
  fld[idxENDOTNTEK] = Tabl.Find_Name_Fld("ENDOTNTEK");
  fld[idxENDKVL]    = Tabl.Find_Name_Fld("ENDKVL");
  fld[idxENDINKV]   = Tabl.Find_Name_Fld("ENDINKV");
  fld[idxM2]        = Tabl.Find_Name_Fld("M2");
  fld[idxM1]        = Tabl.Find_Name_Fld("M1");
  fld[idxM0]        = Tabl.Find_Name_Fld("M0");
  fld[idxINCP]      = Tabl.Find_Name_Fld("INCP");
  fld[idxINC2]      = Tabl.Find_Name_Fld("INC2");
  fld[idxINC1]      = Tabl.Find_Name_Fld("INC1");
  fld[idxINC0]      = Tabl.Find_Name_Fld("INC0");
  fld[idxTAXP]      = Tabl.Find_Name_Fld("TAXP");
  fld[idxTAX2]      = Tabl.Find_Name_Fld("TAX2");
  fld[idxTAX1]      = Tabl.Find_Name_Fld("TAX1");
  fld[idxTAX0]      = Tabl.Find_Name_Fld("TAX0");
  fld[idxSOCP]      = Tabl.Find_Name_Fld("SOCP");
  fld[idxSOC2]      = Tabl.Find_Name_Fld("SOC2");
  fld[idxSOC1]      = Tabl.Find_Name_Fld("SOC1");
  fld[idxSOC0]      = Tabl.Find_Name_Fld("SOC0");
  fld[idxDEC9]      = Tabl.Find_Name_Fld("DEC9");
  fld[idxDEC2]      = Tabl.Find_Name_Fld("DEC2");
  fld[idxDEC3]      = Tabl.Find_Name_Fld("DEC3");
  fld[idxDEC4]      = Tabl.Find_Name_Fld("DEC4");
  fld[idxDEC5]      = Tabl.Find_Name_Fld("DEC5");
  fld[idxDEC6]      = Tabl.Find_Name_Fld("DEC6");
  fld[idxDEC7]      = Tabl.Find_Name_Fld("DEC7");
  fld[idxDEC8]      = Tabl.Find_Name_Fld("DEC8");
  fld[idxDECA]      = Tabl.Find_Name_Fld("DECA");
  fld[idxDECB]      = Tabl.Find_Name_Fld("DECB");
  fld[idxDECG]      = Tabl.Find_Name_Fld("DECG");
  fld[idxDECC]      = Tabl.Find_Name_Fld("DECC");
  fld[idxDECD]      = Tabl.Find_Name_Fld("DECD");
  fld[idxSCH1]      = Tabl.Find_Name_Fld("SCH1");
  fld[idxSCH2]      = Tabl.Find_Name_Fld("SCH2");
  fld[idxSCH3]      = Tabl.Find_Name_Fld("SCH3");
  fld[idxSCH4]      = Tabl.Find_Name_Fld("SCH4");
  fld[idxSCH5]      = Tabl.Find_Name_Fld("SCH5");
  fld[idxSCH6]      = Tabl.Find_Name_Fld("SCH6");
  fld[idxSCH7]      = Tabl.Find_Name_Fld("SCH7");
  fld[idxSCH8]      = Tabl.Find_Name_Fld("SCH8");
  fld[idxSCH9]      = Tabl.Find_Name_Fld("SCH9");
  fld[idxSCH10]     = Tabl.Find_Name_Fld("SCH10");
  fld[idxSCH11]     = Tabl.Find_Name_Fld("SCH11");
  fld[idxSCH12]     = Tabl.Find_Name_Fld("SCH12");
  fld[idxINCTYPE]   = Tabl.Find_Name_Fld("INCTYPE");
  fld[idxINC_DR]    = Tabl.Find_Name_Fld("INC_DR");
  fld[idxDED_DR]    = Tabl.Find_Name_Fld("DED_DR");
  fld[idxPROP]      = Tabl.Find_Name_Fld("PROP");
  fld[idxD17]       = Tabl.Find_Name_Fld("D17");
  fld[idxTAX70]     = Tabl.Find_Name_Fld("TAX70");
  fld[idxTAX73]     = Tabl.Find_Name_Fld("TAX73");
  fld[idxTAX112]    = Tabl.Find_Name_Fld("TAX112");
  fld[idxD503]      = Tabl.Find_Name_Fld("D503");
  fld[idxD504]      = Tabl.Find_Name_Fld("D504");
  fld[idxD507]      = Tabl.Find_Name_Fld("D507");
  fld[idxD508]      = Tabl.Find_Name_Fld("D508");
  fld[idxPOL]       = Tabl.Find_Name_Fld("POL");
  fld[idxVMENP]     = Tabl.Find_Name_Fld("VMENP");
  fld[idxFV]        = Tabl.Find_Name_Fld("FV");
  fld[idxTRAVMA]    = Tabl.Find_Name_Fld("TRAVMA");
  fld[idxSVLIST]    = Tabl.Find_Name_Fld("SVLIST");
  fld[idxTRAP]      = Tabl.Find_Name_Fld("TRAP");
  fld[idxTRA2]      = Tabl.Find_Name_Fld("TRA2");
  fld[idxTRA1]      = Tabl.Find_Name_Fld("TRA1");
  fld[idxTRA0]      = Tabl.Find_Name_Fld("TRA0");
  fld[idxDNIP]      = Tabl.Find_Name_Fld("DNIP");
  fld[idxDNI2]      = Tabl.Find_Name_Fld("DNI2");
  fld[idxDNI1]      = Tabl.Find_Name_Fld("DNI1");
  fld[idxDNI0]      = Tabl.Find_Name_Fld("DNI0");
  fld[idxFLGINVP]   = Tabl.Find_Name_Fld("FLGINVP");
  fld[idxPRSP]      = Tabl.Find_Name_Fld("PRSP");
  fld[idxPRDP]      = Tabl.Find_Name_Fld("PRDP");
  fld[idxPRS2]      = Tabl.Find_Name_Fld("PRS2");
  fld[idxPRS1]      = Tabl.Find_Name_Fld("PRS1");
  fld[idxPRS0]      = Tabl.Find_Name_Fld("PRS0");
  fld[idxOTSP]      = Tabl.Find_Name_Fld("OTSP");
  fld[idxOTDP]      = Tabl.Find_Name_Fld("OTDP");
  fld[idxOTS2]      = Tabl.Find_Name_Fld("OTS2");
  fld[idxOTS1]      = Tabl.Find_Name_Fld("OTS1");
  fld[idxOTS0]      = Tabl.Find_Name_Fld("OTS0");

  fld[idxKR01]      = Tabl.Find_Name_Fld("KR01");
  fld[idxKR02]      = Tabl.Find_Name_Fld("KR02");
  fld[idxKR03]      = Tabl.Find_Name_Fld("KR03");
  fld[idxKR04]      = Tabl.Find_Name_Fld("KR04");
  fld[idxKR05]      = Tabl.Find_Name_Fld("KR05");
  fld[idxKR06]      = Tabl.Find_Name_Fld("KR06");
  fld[idxKR07]      = Tabl.Find_Name_Fld("KR07");
  fld[idxKR08]      = Tabl.Find_Name_Fld("KR08");
  fld[idxKR09]      = Tabl.Find_Name_Fld("KR09");
  fld[idxKR10]      = Tabl.Find_Name_Fld("KR10");
  fld[idxKR11]      = Tabl.Find_Name_Fld("KR11");
  fld[idxKR12]      = Tabl.Find_Name_Fld("KR12");

  fld[idxTRAPS]     = Tabl.Find_Name_Fld("TRAPS");
  fld[idxOTSPS]     = Tabl.Find_Name_Fld("OTSPS");
  fld[idxPRSPS]     = Tabl.Find_Name_Fld("PRSPS");

  fld[idxRANGE01N]  = Tabl.Find_Name_Fld("RANGE01N");
  fld[idxRANGE02N]  = Tabl.Find_Name_Fld("RANGE02N");
  fld[idxRANGE03N]  = Tabl.Find_Name_Fld("RANGE03N");
  fld[idxRANGE04N]  = Tabl.Find_Name_Fld("RANGE04N");
  fld[idxRANGE05N]  = Tabl.Find_Name_Fld("RANGE05N");

  fld[idxRANGE01V]  = Tabl.Find_Name_Fld("RANGE01V");
  fld[idxRANGE02V]  = Tabl.Find_Name_Fld("RANGE02V");
  fld[idxRANGE03V]  = Tabl.Find_Name_Fld("RANGE03V");
  fld[idxRANGE04V]  = Tabl.Find_Name_Fld("RANGE04V");
  fld[idxRANGE05V]  = Tabl.Find_Name_Fld("RANGE05V");

  fld[idxMTRP]      = Tabl.Find_Name_Fld("MTRP");
  fld[idxMTR2]      = Tabl.Find_Name_Fld("MTR2");
  fld[idxMTR1]      = Tabl.Find_Name_Fld("MTR1");
  fld[idxMTR0]      = Tabl.Find_Name_Fld("MTR0");
                                          
  fld[idxUTRP]      = Tabl.Find_Name_Fld("UTRP");
  fld[idxUTR2]      = Tabl.Find_Name_Fld("UTR2");
  fld[idxUTR1]      = Tabl.Find_Name_Fld("UTR1");
  fld[idxUTR0]      = Tabl.Find_Name_Fld("UTR0");

  fld[idxFIO]       = Tabl.Find_Name_Fld("FIO");
  fld[idxINV]       = Tabl.Find_Name_Fld("INV");
  fld[idxStudent]   = Tabl.Find_Name_Fld("Student");

  fld[idxRANGE11N]  = Tabl.Find_Name_Fld("RANGE11N");
  fld[idxRANGE12N]  = Tabl.Find_Name_Fld("RANGE12N");
  fld[idxRANGE13N]  = Tabl.Find_Name_Fld("RANGE13N");
  fld[idxRANGE14N]  = Tabl.Find_Name_Fld("RANGE14N");
  fld[idxRANGE15N]  = Tabl.Find_Name_Fld("RANGE15N");

  fld[idxRANGE11V]  = Tabl.Find_Name_Fld("RANGE11V");
  fld[idxRANGE12V]  = Tabl.Find_Name_Fld("RANGE12V");
  fld[idxRANGE13V]  = Tabl.Find_Name_Fld("RANGE13V");
  fld[idxRANGE14V]  = Tabl.Find_Name_Fld("RANGE14V");
  fld[idxRANGE15V]  = Tabl.Find_Name_Fld("RANGE15V");

  fld[idxDATA_ATT]  = Tabl.Find_Name_Fld("dat_att");

  fld[idxFSSPAY01]  = Tabl.Find_Name_Fld("FSSPAY01");
  fld[idxFSSPAY02]  = Tabl.Find_Name_Fld("FSSPAY02");
  fld[idxFSSPAY03]  = Tabl.Find_Name_Fld("FSSPAY03");
  fld[idxFSSPAY04]  = Tabl.Find_Name_Fld("FSSPAY04");
  fld[idxFSSPAY05]  = Tabl.Find_Name_Fld("FSSPAY05");
  fld[idxFSSPAY06]  = Tabl.Find_Name_Fld("FSSPAY06");
  fld[idxFSSPAY07]  = Tabl.Find_Name_Fld("FSSPAY07");
  fld[idxFSSPAY08]  = Tabl.Find_Name_Fld("FSSPAY08");
  fld[idxFSSPAY09]  = Tabl.Find_Name_Fld("FSSPAY09");
  fld[idxFSSPAY10]  = Tabl.Find_Name_Fld("FSSPAY10");
  fld[idxFSSPAY11]  = Tabl.Find_Name_Fld("FSSPAY11");
  fld[idxFSSPAY12]  = Tabl.Find_Name_Fld("FSSPAY12");

  fld[idxTRASUM01]  = Tabl.Find_Name_Fld("TRASUM01");
  fld[idxTRASUM02]  = Tabl.Find_Name_Fld("TRASUM02");
  fld[idxTRASUM03]  = Tabl.Find_Name_Fld("TRASUM03");
  fld[idxTRASUM04]  = Tabl.Find_Name_Fld("TRASUM04");
  fld[idxTRASUM05]  = Tabl.Find_Name_Fld("TRASUM05");
  fld[idxTRASUM06]  = Tabl.Find_Name_Fld("TRASUM06");
  fld[idxTRASUM07]  = Tabl.Find_Name_Fld("TRASUM07");
  fld[idxTRASUM08]  = Tabl.Find_Name_Fld("TRASUM08");
  fld[idxTRASUM09]  = Tabl.Find_Name_Fld("TRASUM09");
  fld[idxTRASUM10]  = Tabl.Find_Name_Fld("TRASUM10");
  fld[idxTRASUM11]  = Tabl.Find_Name_Fld("TRASUM11");
  fld[idxTRASUM12]  = Tabl.Find_Name_Fld("TRASUM12");

  fld[idxTRABL01]   = Tabl.Find_Name_Fld("TRABL01");
  fld[idxTRABL02]   = Tabl.Find_Name_Fld("TRABL02");
  fld[idxTRABL03]   = Tabl.Find_Name_Fld("TRABL03");
  fld[idxTRABL04]   = Tabl.Find_Name_Fld("TRABL04");
  fld[idxTRABL05]   = Tabl.Find_Name_Fld("TRABL05");
  fld[idxTRABL06]   = Tabl.Find_Name_Fld("TRABL06");
  fld[idxTRABL07]   = Tabl.Find_Name_Fld("TRABL07");
  fld[idxTRABL08]   = Tabl.Find_Name_Fld("TRABL08");
  fld[idxTRABL09]   = Tabl.Find_Name_Fld("TRABL09");
  fld[idxTRABL10]   = Tabl.Find_Name_Fld("TRABL10");
  fld[idxTRABL11]   = Tabl.Find_Name_Fld("TRABL11");
  fld[idxTRABL12]   = Tabl.Find_Name_Fld("TRABL12");

  fld[idxTRAINV01]  = Tabl.Find_Name_Fld("TRAINV01");
  fld[idxTRAINV02]  = Tabl.Find_Name_Fld("TRAINV02");
  fld[idxTRAINV03]  = Tabl.Find_Name_Fld("TRAINV03");
  fld[idxTRAINV04]  = Tabl.Find_Name_Fld("TRAINV04");
  fld[idxTRAINV05]  = Tabl.Find_Name_Fld("TRAINV05");
  fld[idxTRAINV06]  = Tabl.Find_Name_Fld("TRAINV06");
  fld[idxTRAINV07]  = Tabl.Find_Name_Fld("TRAINV07");
  fld[idxTRAINV08]  = Tabl.Find_Name_Fld("TRAINV08");
  fld[idxTRAINV09]  = Tabl.Find_Name_Fld("TRAINV09");
  fld[idxTRAINV10]  = Tabl.Find_Name_Fld("TRAINV10");
  fld[idxTRAINV11]  = Tabl.Find_Name_Fld("TRAINV11");
  fld[idxTRAINV12]  = Tabl.Find_Name_Fld("TRAINV12");

  fld[idxTRAUSL01]  = Tabl.Find_Name_Fld("TRAUSL01");
  fld[idxTRAUSL02]  = Tabl.Find_Name_Fld("TRAUSL02");
  fld[idxTRAUSL03]  = Tabl.Find_Name_Fld("TRAUSL03");
  fld[idxTRAUSL04]  = Tabl.Find_Name_Fld("TRAUSL04");
  fld[idxTRAUSL05]  = Tabl.Find_Name_Fld("TRAUSL05");
  fld[idxTRAUSL06]  = Tabl.Find_Name_Fld("TRAUSL06");
  fld[idxTRAUSL07]  = Tabl.Find_Name_Fld("TRAUSL07");
  fld[idxTRAUSL08]  = Tabl.Find_Name_Fld("TRAUSL08");
  fld[idxTRAUSL09]  = Tabl.Find_Name_Fld("TRAUSL09");
  fld[idxTRAUSL10]  = Tabl.Find_Name_Fld("TRAUSL10");
  fld[idxTRAUSL11]  = Tabl.Find_Name_Fld("TRAUSL11");
  fld[idxTRAUSL12]  = Tabl.Find_Name_Fld("TRAUSL12");

  return 0;
}


int idxBDAT      =  0, // месяц начала периода (относительный)
    idxEDAT      =  1, // месяц конца периода (ММ.ГГГГ)
    idxABDAT     =  2, // месяц начала периода (абсолютный)
    idxAEDAT     =  3, // месяц конца периода (абсолютный)
    idxENDOTNTEK =  4, // месяц конца периода (относительный)
    idxENDKVL    =  5, // квартал месяца конца периода (1,2,3 или 4)
    idxENDINKV   =  6, // номер месяца конца периода в квартале (1,2 или 3)
    idxM2        =  7, // первый месяц квартала (относительный)
    idxM1        =  8, // второй месяц квартала (относительный)
    idxM0        =  9, // третий месяц квартала (относительный)
    idxINCP      = 10, // доход за период
    idxINC2      = 11, // доход за первый месяц квартала
    idxINC1      = 12, // доход за второй месяц квартала
    idxINC0      = 13, // доход за третий месяц квартала
    idxTAXP      = 14, // налог за период
    idxTAX2      = 15, // налог за первый месяц квартала
    idxTAX1      = 16, // налог за второй месяц квартала
    idxTAX0      = 17, // налог за третий месяц квартала
    idxSOCP      = 18, // выплаты за счет соцстраха за период
    idxSOC2      = 19, // выплаты за счет соцстраха за первый месяц квартала
    idxSOC1      = 20, // выплаты за счет соцстраха за второй месяц квартала
    idxSOC0      = 21, // выплаты за счет соцстраха за третий месяц квартала

    idxDEC9      = 22, // пособия по временной нетрудоспособности
    idxDEC2      = 23, // по беременности и родам
    idxDEC3      = 24, // по уходу за ребенком до 1.5 лет
    idxDEC4      = 25, // при рождении ребенка
    idxDEC5      = 26, // пособие на погребение
    idxDEC6      = 27, // по уходу за детьми-инвалидами
    idxDEC7      = 28, // пособие женщинам, вставшим на учет в ранние сроки беременности
    idxDEC8      = 29, // при усыновлении ребенка
    idxDECA      = 30, // детские лагеря
    idxDECB      = 31, // санаторные лагеря
    idxDECC      = 32, // детские санатории
    idxDECD      = 33, // возмещение командировочных расходов
    idxDECG      = 34, // возмещение командировочных расходов
    
    idxSCH1      = 35, // среднесписочная численность с 1 по 12 месяц от начала периода
    idxSCH2      = 36,
    idxSCH3      = 37,
    idxSCH4      = 38,
    idxSCH5      = 39,
    idxSCH6      = 40,
    idxSCH7      = 41,
    idxSCH8      = 42,
    idxSCH9      = 43,
    idxSCH10     = 44,
    idxSCH11     = 45,
    idxSCH12     = 46,

    idxINCTYPE   = 47, // код работы для налога
    idxINC_DR    = 48, // доход с другого места
    idxDED_DR    = 49, // вычет с другого места
    idxPROP      = 50, // настройка PROPORCIA (вычисление налога по пропорции к вычетам)
    idxD17       = 51, // общая сумма вычетов
    idxTAX70     = 52, // доход аттестованных военных
    idxTAX73     = 53, // суммы налоговых льгот
    idxTAX112    = 54, // список вида: код вычета - сумма вычета
    idxD503      = 55, // вычет по мат.помощи
    idxD504      = 56, // вычет по медикаментам
    idxD507      = 57, // вычет по натуроплате
    idxD508      = 58, // вычет из профсоюза
    idxPOL       = 59, // пол
    idxVMENP     = 60, // вмененный доход за период
    idxFV        = 61, // флаг присутствия процента вмененного дохода в КЧ в расчетном периоде
    idxTRAVMA    = 62, // список: сумма,%страх.тарифа,флаг инвалидности; для каждого месяца
    idxSVLIST    = 63, // список вида: сумма,% вмен.дох;сумма,% вмен.дох; ... для каждого месяца периода
                       // работает, если FV не ноль
    idxTRAP      = 64, // суммы выплат пособий по травме за период
    idxTRA2      = 65, // и по месяцам квартала
    idxTRA1      = 66, //
    idxTRA0      = 67, //
    idxDNIP      = 68, // дни, приходящиеся на пособия по травме за период
    idxDNI2      = 69, // и по месяцам квартала
    idxDNI1      = 70, //
    idxDNI0      = 71, //
    idxFLGINVP   = 72, // флаг наличия инвалидов в периоде

    idxPRSP      = 73, // профзаболевание, сумма
    idxPRDP      = 74, // профзаболевание, дни
    idxPRS2      = 75, // профзаболевание, 3 месяц
    idxPRS1      = 76, // профзаболевание, 2 месяц
    idxPRS0      = 77, // профзаболевание, 1 месяц

    idxOTSP      = 78, // леч.отпуска, сумма
    idxOTDP      = 79, // леч.отпуска, дни
    idxOTS2      = 80, // леч.отпуска, 3 месяц
    idxOTS1      = 81, // леч.отпуска, 2 месяц
    idxOTS0      = 82, // леч.отпуска, 1 месяц

    idxKR01      = 83, // Код работы для подоходного налога
    idxKR02      = 84, // 0 - основное место
    idxKR03      = 85, // 1 - совместительство
    idxKR04      = 86, // 2 - договор
    idxKR05      = 87, //
    idxKR06      = 88, //
    idxKR07      = 89, //
    idxKR08      = 90, //
    idxKR09      = 91, //
    idxKR10      = 92, //
    idxKR11      = 93, //
    idxKR12      = 94, //

    idxTRAPS     = 95, //
    idxOTSPS     = 96, //
    idxPRSPS     = 97, //

    idxRANGE01N  = 98,
    idxRANGE02N  = 99,
    idxRANGE03N  = 100,
    idxRANGE04N  = 101,
    idxRANGE05N  = 102,
                      
    idxRANGE01V  = 103,
    idxRANGE02V  = 104,
    idxRANGE03V  = 105,
    idxRANGE04V  = 106,
    idxRANGE05V  = 107,

    idxMTRP      = 108,
    idxMTR2      = 109,
    idxMTR1      = 110,
    idxMTR0      = 111,

    idxUTRP      = 112,
    idxUTR2      = 113,
    idxUTR1      = 114,
    idxUTR0      = 115,

    idxFIO       = 116,
    idxINV       = 117,
    idxStudent   = 118,

    idxRANGE11N  = 119,
    idxRANGE12N  = 120,
    idxRANGE13N  = 121,
    idxRANGE14N  = 122,
    idxRANGE15N  = 123,
                   
    idxRANGE11V  = 124,
    idxRANGE12V  = 125,
    idxRANGE13V  = 126,
    idxRANGE14V  = 127,
    idxRANGE15V  = 128,

    idxDATA_ATT  = 129,

    idxFSSPAY01  = 130,
    idxFSSPAY02  = 131,
    idxFSSPAY03  = 132,
    idxFSSPAY04  = 133,
    idxFSSPAY05  = 134,
    idxFSSPAY06  = 135,
    idxFSSPAY07  = 136,
    idxFSSPAY08  = 137,
    idxFSSPAY09  = 138,
    idxFSSPAY10  = 139,
    idxFSSPAY11  = 140,
    idxFSSPAY12  = 141,

    idxTRASUM01  = 142,
    idxTRASUM02  = 143,
    idxTRASUM03  = 144,
    idxTRASUM04  = 145,
    idxTRASUM05  = 146,
    idxTRASUM06  = 147,
    idxTRASUM07  = 148,
    idxTRASUM08  = 149,
    idxTRASUM09  = 150,
    idxTRASUM10  = 151,
    idxTRASUM11  = 152,
    idxTRASUM12  = 153,

    idxTRABL01   = 154,
    idxTRABL02   = 155,
    idxTRABL03   = 156,
    idxTRABL04   = 157,
    idxTRABL05   = 158,
    idxTRABL06   = 159,
    idxTRABL07   = 160,
    idxTRABL08   = 161,
    idxTRABL09   = 162,
    idxTRABL10   = 163,
    idxTRABL11   = 164,
    idxTRABL12   = 165,

    idxTRAINV01  = 166,
    idxTRAINV02  = 167,
    idxTRAINV03  = 168,
    idxTRAINV04  = 169,
    idxTRAINV05  = 170,
    idxTRAINV06  = 171,
    idxTRAINV07  = 172,
    idxTRAINV08  = 173,
    idxTRAINV09  = 174,
    idxTRAINV10  = 175,
    idxTRAINV11  = 176,
    idxTRAINV12  = 177,

    idxTRAUSL01  = 178,
    idxTRAUSL02  = 179,
    idxTRAUSL03  = 180,
    idxTRAUSL04  = 181,
    idxTRAUSL05  = 182,
    idxTRAUSL06  = 183,
    idxTRAUSL07  = 184,
    idxTRAUSL08  = 185,
    idxTRAUSL09  = 186,
    idxTRAUSL10  = 187,
    idxTRAUSL11  = 188,
    idxTRAUSL12  = 189,

    CountIdx     = 190;

int fld[CountIdx]; // массив номеров полей таблицы


