////////////////////////////////////////////////////////////////////////////
// Модуль для вспомогательных функций (в основном для таблиц и форм печати)
// (следующий такой модуль - funcrw1.s)
////////////////////////////////////////////////////////////////////////////


RW_IF(&Arg,  &pcT, W, A) // печатная функция "IF" для условного выполнения функций 
{         // условие отделяется от функции знаком @    (вложенные IF не работают!)
          // IF(выражение @ функция @ иначе_функция )

   var Param = CreateObject("ParamFuncRW");
   Param.IInitial(static_cast_to_string(Arg),"@",3);
   if (Param.Count()<2) return pcT;
   char Buf[21];
   Calc_Expr(Param.Get(0),Buf,20,20,0);
   int uslov = atoi(Buf);
   if (uslov)
   {
      CallFuncReceive(Param.Get(1),pcT,W,A);
   }
   else if (Param.Count()==3)
   {
      CallFuncReceive(Param.Get(2),pcT,W,A);
   }      
 
   return pcT;
}

R_STAG2 ( &Arg,  &pcT, W, A)
//////////////////////////////////////////////////////////////////
// СТАЖ2(парам1,парам2, парам3, парам4 )
// парам1 - псевдоним поля КЧ, где находится дата начала стажа,
//          или просто дата в формате известном системе
// парам2 - то же что и парам1, только для даты конца
//   (при отсутствии этого параметра берется первое число
//    текущего месяца)
// парам3 - формат, в котором хотим получить стаж
//    0 (или отсутствие 3-го параметра) - выдает в формате ??л??м??д.
//    1 - выдает в формате ??л??м (количество полных лет и месяцев)
//    2 - выдает в формате ??л (количество полных лет)
//    Причем буковка 'л' в нужных ситуациях меняется на 'г'.
//    Например:  33г и 35л
// парам4 - способ расчета:
//    0 (или отсутствует) - сравнение с реальным количеством дней
//                          в месяце
//    1 - сравнение с числом 30 (и вообще расчет по алгоритму при-
//      веденному в инструкции ПФ (правила проверки)
//        Условные обозначения:
//        Гн Мн Дн - дата начала периода 
//        Гк Мк Дк - дата конца периода
//        Г М Д     - календарно отработанное время
//            Гк Мк Дк - Гн Мн Дн =  Г  М  Д
//        1.  Д=Дк-Дн  , если Д<0, то Д=Д+30, Мк=Мк-1
//        2. М= Мк-Мн  , если М<0, то М=М+12, Гк=Гк-1
//        3. Г=Гк-Гн
//        4. Д=Д+1
//        если Д>=30, то Д=0, М=М+1
//        если М=12, то М=0, Г=Г+1
////////////////////////////////////////////////////////////////////
{
   var FuncParam =  CreateObject("ParamFuncRW");
   FuncParam.IInitial(static_cast_to_string(Arg),",",10);
   int CountParam=FuncParam.Count();

   if ( CountParam )
   {
      var DateBeg = CreateObject("KDate");
      var DateEnd = CreateObject("KDate");
      DateEnd.SetDateII(1,mrasch); 
      DateBeg.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(0)));

      if ( CountParam>1 )
      {
         DateEnd.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(1)));
      }

      int TypeForm = 0;
      if ( CountParam>2 ) TypeForm = atoi(static_cast_to_string(FuncParam.Get(2)));

      int TypeCalc = 0;
      if ( CountParam>3 ) TypeCalc = atoi(static_cast_to_string(FuncParam.Get(3)));

      int year=0, month=0, day=0;
      // CalculateStag(DateBeg,DateEnd, year, month, day, TypeCalc,"");
      if ( !DateBeg.IsEqI(INVALID_DATE_VALUE) && !DateEnd.IsEqI(INVALID_DATE_VALUE) )
      {
         if ( DateBeg.GT(DateEnd) )
         {
             int d=DateBeg.GetDay(), 
                 m=DateBeg.GetAbs();
             DateBeg.SetDateII(DateEnd.GetDay(),DateEnd.GetAbs());
             DateEnd.SetDateII(d,m);
         }

         if ( TypeCalc ) // расчет с учетом того, что в месяце 30 дней
         {
               //        1.  Д=Дк-Дн  , если Д<0, то Д=Д+30, Мк=Мк-1
               //        2. М= Мк-Мн  , если М<0, то М=М+12, Гк=Гк-1
               //        3. Г=Гк-Гн
               //        4. Д=Д+1
               //        если Д>=30, то Д=0, М=М+1
               //        если М=12, то М=0, Г=Г+1
               day = DateEnd.GetDay() - DateBeg.GetDay();
               int dop=0;
               if ( day<0 ) day+=30, dop=1;

               month = DateEnd.GetMonth()-dop-DateBeg.GetMonth();
               if ( month<0 ) month+=12, dop=1;
               else                      dop=0;

               year = DateEnd.GetYear()-dop-DateBeg.GetYear();

               day++; // Т.е. в стаже учитываем как дату начала, так и дату конца
               if ( day>=30   ) day=0,month++;
               if ( month>=12 ) month=0,year++;
         }
         else // расчет с учетом реального количества дней в месяцах
         {
         int CountM = DateEnd.GetAbs() - DateBeg.GetAbs();

         if ( CountM>=0 )
         {
            if ( CountM==0 )
            {
               day = DateEnd.Diff(DateBeg);
               // защита от дурака - если даты задали не в том порядке
               if ( day<0 ) day = -day;
            }
            else
            {
               var DatePred = CreateObject("KDate");
               DatePred.SetDateII(DateBeg.GetDay(),DateEnd.GetAbs()-1);
               day = DateEnd.Diff(DatePred);
               if ( day>=DatePred.CountDay() ) day -= DatePred.CountDay();
               else
               {  // в этом случае нет одного полного месяца, поэтому
                  // уменьшаем кол-во месяцев на 1
                  CountM--;
               }
            }
            year = CountM/12;
            month = CountM%12;
         }
      }
      }
      // о-го-го! Столько не живут :), а тем более не работают :))
      // if ( year>99 ) year=month=day=0;

      int Ost = year%10;
      char SimvY = (Ost>0 && Ost<5) ? 'г' : 'л';

      char Str[81];
      Str[0]=0;
      switch ( TypeForm )
      {
         case 1:   // л.м.
            sprintf(Str,"%2d%c%2dм",year,SimvY,month);
            break;

         case 2:   // л.
            sprintf(Str,"%2d%c",year,SimvY);
            break;

         default:  // л.м.д.
            sprintf(Str,"%2d%c%2dм%2dд",year,SimvY,month,day);
            break;
      }
      Text_Text(pcT,Str,W);
   }
   return pcT;
}

GetVvedPeriod(SRC)
{
   double d1 = GetDateFromFuncRWScript(Str_Date_0);   
   double d2 = GetDateFromFuncRWScript(Str_Date_1);   

   var DateBeg=CreateObject("KDate");  // дата начала действия строки
   var DateEnd=CreateObject("KDate");
   DateBeg.SetDateD(d1);   
   DateEnd.SetDateD(d2);   

   char buf[256];
   char func[256];
   double ItogSum=0.;

   for ( int i=DateBeg.GetAbs();i<=DateEnd.GetAbs();i++ )
   {
      sprintf(func,"GetVved(%d,%s)",i,static_cast_to_string(SRC));
      CallFuncReceive(func,buf,250,2);
      ItogSum += atof(buf);

   }
   return ItogSum;
}

GetVvedPeriod2(m1,m2,SRC)
{
   char buf[256];
   char func[256];
   double ItogSum=0.;

   for ( int i=m1;i<=m2;i++ )
   {
      sprintf(func,"GetVved(%d,%s)",i,static_cast_to_string(SRC));
      CallFuncReceive(func,buf,250,2);
      ItogSum += atof(buf);

   }
   return ItogSum;
}

/*
SostavPeriod2(tip,m1,m2)
{
   char buf[256];
   char func[256];
   double ItogSum=0.;

   for ( int i=m1;i<=m2;i++ )
   {
      sprintf(func,"СОСТАВ(%d,%d)",atoi(tip),i);
      CallFuncReceive(func,buf,250,0);
      ItogSum += atof(buf);

   }
   return static_cast_to_string(ItogSum);
}
*/

GetDolg ( &Arg,  &pcT, W, A)
//////////////////////////////////////////////////////////////////
// НЕПОГАШ_ДОЛГ(месяц,месяц начала, месяц конца)
// месяц - месяц на который надо сосчитать непогашенный долг
// месяц начала - месяц конца - период за который учитываем долг
// Если дата начала и дата конца не указываются - берем из 
// панели
//////////////////////////////////////////////////////////////////
{
   var FuncParam =  CreateObject("ParamFuncRW");
   FuncParam.IInitial(static_cast_to_string(Arg),",",3);
   int CountParam=FuncParam.Count();

   if ( !CountParam ) return pcT;
   var Month  = CreateObject("KMonth"),
       MonthB = CreateObject("KMonth"),
       MonthE = CreateObject("KMonth");

   Month.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(0)));
   MonthB.SetDate(static_cast_to_string(Str_Date_0));
   MonthE.SetDate(static_cast_to_string(Str_Date_1));
   if ( CountParam>2 )
   {
      MonthB.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(1)));
      MonthE.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(2)));
   }

   double OstDolg=0;
   for (int m = MonthB.GetAbs(); m<=MonthE.GetAbs(); m++ )
   {
      for ( int mv = m; mv<Month.GetAbs(); mv++ )
         OstDolg += CashSumm(0,998,m,mv,32,CL_M | CL_MV,0);
   }
   Double_Text(pcT,OstDolg,A,W);
   return pcT;
}

NameColTbl ( n )
/////////////////////////////////////////////////////////// 
// Функция возвращает название столбца таблицы 
// n - номер столбца
/////////////////////////////////////////////////////////// 
{
   int k=static_cast_to_int(n);
   var a=CreateObject("CurPrnTbl");
   return a.Name(k);
}

R_WorkType ( &Arg,  &pcT, W, A)
/////////////////////////////////////////////////////////// 
// Функция определяет тип работы для ЛС (оклад/тариф) и,
// если в 1 ст.спец.ТВХ среди видов действующих в ЛС
// встречается 1 или 9 - возвращает 1 (оклад),
// если встречается 2  - возвращает 2 (тариф в рублях),
// если встречается 3  - возвращает 3 (тариф в копейках)
/////////////////////////////////////////////////////////// 
{
  int rez=0;
  int mStr=0;
  double cod;
  double dEnd;
  char sim;
  var Month=CreateObject("KDate");

  for(int i=0; i<countkod; i++)
  {
    cod=GetCode(i);
    if (IsCodeNach(cod))
    {
      dEnd=GetEndDate(i);
      Month.SetDateD(dEnd);
      mStr=Month.GetAbs();
      if (mtek<=mStr)
      {
        sim=Sim_For_Intern_Cod(cod,1000);
        switch (sim)
        {
          case 49: case 57: rez=1; break;
          case 50: rez=2; break;
          case 51: rez=3; break;
        }
        if (rez>0) break;
      }
    }
  }

  Long_Text(pcT,rez,W);
  return pcT;
}


R_FrvType ( &Arg,  &pcT, W, A)
/////////////////////////////////////////////////////////// 
// Функция определяет тип ФРВ для ЛС (по дням/по часам) и,
// если во 2 ст.спец.ТВХ среди видов, действующих в ЛС 
// встречается 1 - возвращает 1 (по дням),
// если встречается 2 - возвращает 2 (по часам)
/////////////////////////////////////////////////////////// 
{
  int rez=0;
  int mStr=0;
  double cod;
  double dEnd;
  char sim;
  var Month=CreateObject("KDate");

  for(int i=0; i<countkod; i++)
  {
    cod=GetCode(i);
    if (IsCodeNach(cod))
    {
      dEnd=GetEndDate(i);
      Month.SetDateD(dEnd);
      mStr=Month.GetAbs();
      if (mtek<=mStr)
      {
        sim=Sim_For_Intern_Cod(cod,1001);
        switch (sim)
        {
          case 49: rez=1; break;
          case 50: rez=2; break;
        }
        if (rez>0) break;
      }
    }
  }

  Long_Text(pcT,rez,W);
  return pcT;
}

R_TaxSc(Code,W,A)
//////////////////////////////////////////////////////////////////
// Вызов функции R_Tax(Code). 
// Используется в качестве функции приема в таблицах.
//////////////////////////////////////////////////////////////////
{
    char Arg[256],Str[256];
    sprintf(Arg,"%d",Code);
    return static_cast_to_string(R_Tax(Arg,Str,W,A));
}

R_TaxSc1(Code,m1,m2,Type,W,A) 
//////////////////////////////////////////////////////////////////
// Вызов функции R_Tax(Code,1,m1,m2,Источник выплаты,*,Type) 
// Используется в качестве функции приема в таблицах.
//////////////////////////////////////////////////////////////////
{
    char Arg[256],Str[256];
    sprintf(Arg,"%d,1,%s,%s,Источник выплаты,*,%c",Code,m1,m2,Type);
    return static_cast_to_string(R_Tax(Arg,Str,W,A));
}

R_TaxSc2(Code,m1,m2,Type,W,A)
//////////////////////////////////////////////////////////////////
// Вызов функции R_Tax(Code,1,m1,m2,*,*,Type) 
// Используется в качестве функции приема в таблицах.
//////////////////////////////////////////////////////////////////
{
    char Arg[256],Str[256];
    var dat = CreateObject("KDate");
    dat.SetMonth(m2+mtek); 
    sprintf(Arg,"%d,1,%s,%s,*,*,%c,DateTaxCnf=%s",Code,static_cast_to_string(m1),static_cast_to_string(m2),Type,dat.GetStr());
    return static_cast_to_string(R_Tax(Arg,Str,W,A));
}
R_TaxSc2Ex(Code,m1,m2,Type,W,A)
//////////////////////////////////////////////////////////////////
// Вызов функции R_Tax(Code,1,m1,m2,*,*,Type) 
// Используется в качестве функции приема в таблицах.
// Отличается от R_TaxSc2 тем что Type- строка + конвертируется MakeCodAlgForTax(Key)
//////////////////////////////////////////////////////////////////
{
    char Arg[256],Str[256];
    var dat = CreateObject("KDate");
    dat.SetMonth(m2+mtek); 
    sprintf(Arg,"%d,1,%s,%s,*,*,%s,DateTaxCnf=%s",Code,static_cast_to_string(m1),static_cast_to_string(m2),MakeCodAlgForTax(Type),dat.GetStr());
    return static_cast_to_string(R_Tax(Arg,Str,W,A));
}

GetFirstProcentTax()
{
   double Proc=0.;
   try
   {
      var Map=CreateObject("MapString");
      Proc=ProcentTax(1,Map);
   }
   catch(...)
   {
      char Str[256];
      R_Tax("2100",Str,255,0);
      var Par = CreateObject("ParamFuncRW");
      Par.IInitial1(static_cast_to_string(Str),";",12);
      Proc = atof(Par.Get(2));
      if ( Str_Cmp(Str," "," ;,0") && Proc<0.00001 )
      {
         double Base = atof(R_Tax("4",Str,14,2));
         if ( Base>0.00001 )
         {
            double Tax = atof(R_Tax("7",Str,14,8));
            Proc = Tax/Base;
         }
      }
   }
   return Proc;
}

kch_inv()
{
  char Str[256];
  char Arg[256];
  char Rez[256];
  string RESULT="";

  sprintf(Arg,"d_inv,0,СКОЛЬКО");
  int Count=atoi(R_KCH_PERIOD(Arg,Rez,25,0));

  for (int i=0; i<Count; i++)
  {
    sprintf(Arg,"d_inv,%2d",i+1);
    string Elem=RTrim(R_KCH_PERIOD(Arg,Rez,250,0));
    RESULT=(i==0)?Elem:RESULT+";"+Elem;
  }


  return RESULT;
}

/*
CalcKategESN_PF()
//////////////////////////////////////////////////////////////////
// 3 типа плательщиков для ЕСН ПФ:
// 1-ый: мужчины 1952 г.р. и старше, женщины 1956 г.р. и старше
// 2-ой: мужчины 1953-1966 г.р. и женщины 1957-1966 г.р.
// 3-ий: все остальные (т.е. мужчины и женщины 1967 г.р. и моложе)
//////////////////////////////////////////////////////////////////
{
   int KategPayESN_PF=3;
   char Str[11];

   var DateEnd = CreateObject("KDate");
   DateEnd.SetDateII(countday,mrasch);

   GetKchValue("data_r",Str,10,DateEnd);

   var DatR=CreateObject("KDate");
   DatR.SetDate(static_cast_to_string(Str)); 

   long Year = DatR.GetYear();
   if ( Year<1 )
   {
      KategPayESN_PF=1; // если не заполнено поле "дата рождения" относим к 1-ой категории
      return KategPayESN_PF;
   }

   GetKchValue("pol",Str,1,DateEnd);
   char Pol = Str[0];
   Pol=To_Rus(Pol); Pol=To_Upper(Pol);
   int FlagW = (Pol=='Ж') ? 1 : 0;

   if ( Year<=1952  || (FlagW && Year<=1956) ) KategPayESN_PF=1;
   else if ( Year<=1966 )                      KategPayESN_PF=2;
   else                                        KategPayESN_PF=3;
   return static_cast_to_string(KategPayESN_PF);
}
*/

R_TaxSc3( Kod, Inv, W, A)
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
{
  char Arg[256];
  char Rez[256];
  char Str[256];
  string RESULT="";
  int n=0;
  double eps=.001;

  if ( Kod=="INV" )    n=0;

  if ( Kod=="0100_3" ) n=1003;  if ( Kod=="0100_5" ) n=1005;  if ( Kod=="0100_7" ) n=1007;  if ( Kod=="0100_9" ) n=1009;
  if ( Kod=="0200_3" ) n=2003;  if ( Kod=="0200_5" ) n=2005;  if ( Kod=="0200_7" ) n=2007;  if ( Kod=="0200_9" ) n=2009;
  if ( Kod=="0300_3" ) n=3003;  if ( Kod=="0300_5" ) n=3005;  if ( Kod=="0300_7" ) n=3007;  if ( Kod=="0300_9" ) n=3009;
  if ( Kod=="0400_3" ) n=4003;  if ( Kod=="0400_5" ) n=4005;  if ( Kod=="0400_7" ) n=4007;  if ( Kod=="0400_9" ) n=4009;
  if ( Kod=="0500_3" ) n=5003;
  if ( Kod=="0600_3" ) n=6003;
  if ( Kod=="1000_3" ) n=10003; if ( Kod=="1000_5" ) n=10005; if ( Kod=="1000_7" ) n=10007; if ( Kod=="1000_9" ) n=10009;
  if ( Kod=="1100_3" ) n=11003; if ( Kod=="1100_5" ) n=11005; if ( Kod=="1100_7" ) n=11007; if ( Kod=="1100_9" ) n=11009;
  if ( Kod=="79_3" )   n=793;   if ( Kod=="79_5" )   n=795;   if ( Kod=="79_7" )   n=797;   if ( Kod=="79_9" )   n=799;
  if ( Kod=="503_3" )  n=5033;  if ( Kod=="503_5" )  n=5035;  if ( Kod=="503_7" )  n=5037;  if ( Kod=="503_9" )  n=5039;
  if ( Kod=="13_3" )   n=133;   if ( Kod=="13_5" )   n=135;   if ( Kod=="13_7" )   n=137;   if ( Kod=="13_9" )   n=139;
  if ( Kod=="12_3" )   n=123;   if ( Kod=="12_5" )   n=125;   if ( Kod=="12_7" )   n=127;   if ( Kod=="12_9" )   n=129;
  if ( Kod=="6_13_3" ) n=6133;
  if ( Kod=="6_12_3" ) n=6123;
  if ( Kod=="5_13_3" ) n=5133;
  if ( Kod=="5_12_3" ) n=5123;

  if ( Kod=="STRAH" ) n=7000;
  if ( Kod=="NAKOP" ) n=7001;


  switch (n)
  {

    case 0:
    {
      char D_End[10]; 
      sprintf(D_End,"%-7.7s",RTrim(R_Date("10",Rez,10,0)));
      sprintf(Arg,"d_inv,%s",D_End);
      R_Face(Arg,Rez,100,0);
      int Group=GetGroupInv(Rez);
      RESULT=Group;

    }
    break;

    case 1003: case 1005: case 1007: case 1009:
    {
      double sum1=.0;
      double sum2=.0;
      double sum3=.0;
      double sum4=.0;
      double sum5=.0;
      double sum6=.0;
      double sum7=.0;
      double sum=.0;

      if (n==1003) sum1=atof(R_Tax("73",Rez,25,2)); // Суммы налоговых льгот
      if (n==1005) sum1=atof(R_Tax("73,1,*,*,*,*,Ц",Rez,25,2)); // Суммы налоговых льгот
      if (n==1007) sum1=atof(R_Tax("73,1,*,*,*,*,М",Rez,25,2)); // Суммы налоговых льгот
      if (n==1009) sum1=atof(R_Tax("73,1,*,*,*,*,Т",Rez,25,2)); // Суммы налоговых льгот

      sum2=atof(R_Tax( "4",Rez,25,2)); // Полная сумма для обложения с копейками
      sum3=atof(R_Tax("70",Rez,25,2)); // Доход аттестованых военных
      sprintf(Arg,"%s,%s,2530,0,507,1,%s","list","RealDiscount"," ");
      sum4=atof(R_Tax( Arg,Rez,25,2)); // Натур.оплата
      sprintf(Arg,"%s,%s,2760,0,503,1,%s","list","RealDiscount"," ");
      sum5=atof(R_Tax( Arg,Rez,25,2)); // Мат.помощь
      sprintf(Arg,"%s,%s,2770,0,504,1,%s","list","RealDiscount"," ");
      sum6=atof(R_Tax( Arg,Rez,25,2)); // Медикаменты
      sprintf(Arg,"%s,%s,4901,0,508,1,%s","list","RealDiscount"," ");
      sum7=atof(R_Tax( Arg,Rez,25,2)); // Выплаты из средств профсоюза

      sum=sum1+sum2+sum3-sum4-sum5-sum6-sum7;

      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;

    case 2003: case 2005: case 2007: case 2009:
    {
      double sum1=atof(R_Tax("73",Rez,25,2)); // Суммы налоговых льгот
      double sum2=atof(R_Tax("70",Rez,25,2)); // Доход аттестованых военных
      sprintf(Arg,"%s,%s,2760,0,503,1,%s","list","RealDiscount"," ");
      double sum3=atof(R_Tax( Arg,Rez,25,2)); // Мат.помощь
      sprintf(Arg,"%s,%s,2530,0,507,1,%s","list","RealDiscount"," ");
      double sum4=atof(R_Tax( Arg,Rez,25,2)); // Натур.оплата
      sprintf(Arg,"%s,%s,2770,0,504,1,%s","list","RealDiscount"," ");
      double sum5=atof(R_Tax( Arg,Rez,25,2)); // Медикаменты
      sprintf(Arg,"%s,%s,4901,0,508,1,%s","list","RealDiscount"," ");
      double sum6=atof(R_Tax( Arg,Rez,25,2)); // Выплаты из средств профсоюза
      double sum=sum1-sum3-sum4-sum5-sum6+sum2;
      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;

    case 3003: case 3005: case 3007: case 3009:
    {
      double sum=atof(R_Tax( "4",Rez,25,2)); // Полная сумма для обложения с копейками
      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;

    case 4003: case 4005: case 4007: case 4009: case 6003: case 5003:
    case 123:  case 125:  case 127:  case 129:  case 6123: case 5123:
    case 133:  case 135:  case 137:  case 139:  case 6133: case 5133:
    {
      double sum1=.0;
      double sum2=.0;
      double sum3=.0;
      double sum =.0;
      char vn[10];

      switch (n)
      {
        case 4003: case 4005: case 4007: case 4009: case 6003: case 5003:
        { sprintf(vn,"7"); } break; // Налог с полной суммы
        case 123:  case 125:  case 127:  case 129:  case 6123: case 5123:
        { sprintf(vn,"12");} break; // Налог, удержанный в отчетном периоде
        case 133:  case 135:  case 137:  case 139:  case 6133: case 5133:
        { sprintf(vn,"13");} break; // Налог, удержанный в счет отчетного периода
      }

      if (n==4003 || n==123 || n==133 || n==6003 || n==5003 || n==6133 || n==6123 || n==5133 || n==5123)
        sprintf(Arg,"%s,1,*,*,*,*,П",vn);
      else
        sprintf(Arg,"%s",vn);

      sum1=atof(R_Tax(Arg,Rez,25,2)); 

      if (n==4003 || n==123 || n==133 || n==6003 || n==6123 || n==6133 || n==5003 || n==5123 || n==5133)
      {
        if (Inv==1 || n==6003 || n==6123 || n==6133 || n==5003 || n==5123 || n==5133)
        {
          sprintf(Arg,"%s,1,*,*,*,*,А",vn); sum2=atof(R_Tax(Arg,Rez,25,2)); 
          sprintf(Arg,"%s,1,*,*,*,*,Л",vn); sum3=atof(R_Tax(Arg,Rez,25,2)); 
        }
      }

                             sum=sum1+sum2+sum3;
      if (n==6003 && Inv==0) sum=sum1;
      if (n==6133 && Inv==0) sum=sum1;
      if (n==6123 && Inv==0) sum=sum1;
      if (n==6003)           sum=sum-(sum2+sum3);
      if (n==6133)           sum=sum-(sum2+sum3);
      if (n==6123)           sum=sum-(sum2+sum3);
      if (n==5003)           sum=sum2+sum3;
      if (n==5133)           sum=sum2+sum3;
      if (n==5123)           sum=sum2+sum3;

      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;

    case 10003: case 10005: case 10007: case 10009:
    case 11003: case 11005: case 11007: case 11009:
    {
      double sum1=.0; double sum2=.0; double sum3=.0; 
      double sum4=.0; double sum5=.0; double sum6=.0; 
      double sum=.0;

      if (n==11003 || n==11005 || n==11007 || n==11009)
      {
        sum1=atof(R_Tax("81",Rez,25,2)); // Объект налогообложения без учета отрицательных сумм дохода
        sum1=sum1-atof(R_Tax("124",Rez,25,2)); // Сумма вмененного дохода
        sum2=atof(R_Tax("73",Rez,25,2)); // Суммы налоговых льгот

        sprintf(Arg,"%s,%s,2760,0,503,1,%s","list","RealDiscount"," ");
        sum2=sum2-atof(R_Tax( Arg,Rez,25,2)); // Мат.помощь
        sprintf(Arg,"%s,%s,2530,0,507,1,%s","list","RealDiscount"," ");
        sum2=sum2-atof(R_Tax( Arg,Rez,25,2)); // Натур.оплата
        sprintf(Arg,"%s,%s,2770,0,504,1,%s","list","RealDiscount"," ");
        sum2=sum2-atof(R_Tax( Arg,Rez,25,2)); // Медикаменты
        sprintf(Arg,"%s,%s,4901,0,508,1,%s","list","RealDiscount"," ");
        sum2=sum2-atof(R_Tax( Arg,Rez,25,2)); // Выплаты из средств профсоюза

        sum3=atof(R_Tax( "4",Rez,25,2)); // Полная сумма для обложения с копейками
        sum4=atof(R_Tax("70",Rez,25,2)); // Доход аттестованных военных
        sum5=atof(R_Tax("78",Rez,25,2)); // Выплаты из средств, оставшихся в распоряжении организации (обозначен символом 'Я' в столбце "Доп")
        if (n==11005) sum6=atof(R_Tax("77",Rez,25,2)); // Доход по договорам подряда (обозначен символом 'Р' в столбце "Доп")
        sum=sum1-(sum2+sum3)-sum4-(sum5+sum6);
      }
      else
      {
        if (n==10003)
          sum=atof(R_Tax("78,1,*,*,*,*,П",Rez,25,2)); // Выплаты из средств оставшихся в распоряжении предприятия (виды отмеченные *Я в столбце Доп)
        else
          sum=atof(R_Tax("78",Rez,25,2)); // Выплаты из средств, оставшихся в распоряжении организации (обозначен символом 'Я' в столбце "Доп")
      }

      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;

    case 793: case 795: case 797: case 799:
    {
      double sum=atof(R_Tax("79",Rez,25,2)); // Расходы произведенные на цели гоударственного социального страхования (больничные, пособия до 1.5 лет) (виды помеченные "*Б" и "*Х")
      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;

    case 5033: case 5035: case 5037: case 5039:
    {
      sprintf(Arg,"%s,%s,2760,0,503,1,%s","list","RealDiscount"," ");
      double sum=atof(R_Tax(Arg,Rez,25,2)); // Мат.помощь
      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;

    case 7000: case 7001:
    {
      double sum=0.;
      if (n==7000)
        sum=atof(R_Tax("4,1,*,*,*,*,А",Rez,25,2));  
      else
        sum=atof(R_Tax("4,1,*,*,*,*,Л",Rez,25,2));  
      sprintf(Str,"%*.*f", W, A, sum);
      RESULT=Str;
    }
    break;


    default:
      RESULT="";
  }

  return RESULT;
}


/*
ParseInv( &s, what)
//  what = 0 - дата начала
//         1 - дата конца
//         2 - группа
//         3 - серия
//         4 - номер
//         5 - кем 
{
   int Gr=0;
   string NumSprav=" ",SerSprav=" ",Kem=" ";
   var DateBeg = CreateObject("KDate"),
       DateEnd = CreateObject("KDate");
   DateBeg.SetDateD(0);
   DateEnd.SetDateD(0);

   string p=s;
   // FreeSpaceString(p,2,"");

   var FuncParam =  CreateObject("ParamFuncRW");
   FuncParam.IInitial(p,",",6);
   int CountParam=FuncParam.Count();
   if ( CountParam<=2 ) // самый старый формат, хранится только группа инвалидности
   {
         int FlagBegData=0;
         if ( CountParam>1 )
         {
            DateBeg.SetDate(FuncParam.Get(0));
            if ( !DateBeg.IsEqI(INVALID_DATE_VALUE) ||
                 !Str_Cmp(FuncParam.Get(0),".."," ") 
               )
            {
               FlagBegData=1;
            }
         }
         Gr=atoi(FuncParam.Get(FlagBegData));
   }
   else
   {
         // Возможно два варианта строки:
         // Дата конца, группа, серия, номер, кем выдана
         // Дата начала, Дата конца, группа, серия, номер, кем выдана
         int FlagBegData=0;
         // if ( CountParam>3 )
         {
            var DateB = CreateObject("KDate"),
                DateE = CreateObject("KDate");
                DateB.SetDate(FuncParam.Get(0));
                DateE.SetDate(FuncParam.Get(1));
            if ( (!Str_Cmp(FuncParam.Get(0),".."," ") || !DateB.IsEqI(INVALID_DATE_VALUE) )
                 &&
                 (!Str_Cmp(FuncParam.Get(1),".."," ") || !DateE.IsEqI(INVALID_DATE_VALUE) )
               )
            {
               FlagBegData=1;
               DateBeg.SetDate(FuncParam.Get(0));
            }
         }
         int idxDE = FlagBegData;
         DateEnd.SetDate(FuncParam.Get(idxDE));
         Gr=atoi(FuncParam.Get(idxDE+1));
         SerSprav=FuncParam.Get(idxDE+2);
         NumSprav=FuncParam.Get(idxDE+3);
         Kem=FuncParam.Get(idxDE+4);
   }

   char Str[81];

   switch (what)
   {
       case 0:
          Double_Text(Str,DateBeg.GetDouble(),2,12);
          break; 

       case 1:
          Double_Text(Str,DateEnd.GetDouble(),2,12);
          break; 

       case 3:
          Text_Text(Str,SerSprav,80);
          break; 

       case 4:
          Text_Text(Str,NumSprav,80);
          break;

       case 5:
          Text_Text(Str,Kem,80);
          break;

       case 2:
       default:
          Long_Text(Str,Gr,80);
          break;
   }

   return Str;
}

GetNumSpravInv( &Spr, &Part, nMax)
{
   return static_cast_to_string(Text_Text(Part,ParseInv(Spr,4),nMax));
}

GetSerSpravInv( &Spr, &Part, nMax)
{
   return static_cast_to_string(Text_Text(Part,ParseInv(Spr,3),nMax));
}

GetKemSpravInv( &Spr, &Part, nMax)
{
   return static_cast_to_string(Text_Text(Part,ParseInv(Spr,5),nMax));
}

GetGroupInv(&Spr)
{
   return atoi(ParseInv(Spr,2));
}

GetDateEndInv(&Spr)
{
   return atof(ParseInv(Spr,1));
}


GetDateBegInv(&Spr)
{
   return atof(ParseInv(Spr,0));
}
*/
APropBEString(ExtSrc,ExtSubject,Podr,ExtCombine)
{
   var Src=CreateObject("APropBE");
   char str[256];
   str = TrimN(ExtSrc);
   Src.SetSrc(ExtSrcToInt(str[0]));
   Src.SetSubject(ExtSubjectToInt(ExtSubject));
   Src.SetPodr(atoi(to_string(Podr)));
   Src.SetCombine(ExtCombineToInt(ExtCombine));
   return Src.MakeStr();
}

PutSummTime ( &Arg,  &pcT, W, A) // функция разноски "PutST"
//////////////////////////////////////////////////////////////////
// Разноска суммы и РВ в строку.
// код, мп, мн, флаг (см.BE_?????), рв, ист., сумма, дата
//////////////////////////////////////////////////////////////////
{
   var FuncParam =  CreateObject("ParamFuncRW");
   FuncParam.IInitial(static_cast_to_string(Arg),",",8);
   int CountParam=FuncParam.Count();
   bool bMergeSumm = false;
   bool bMergeRv = false;
   int rowkod[ROWMAX];
   double OldSum[ROWMAX];
   double OldRv[ROWMAX];
   int cntrow=0;
   
   // Как минимум должны задать код вида, месяц принадлежности и месяц начисления.
   if ( CountParam>2 )
   {
      toMatrLS();
      // внутренний код вида
      double Cod = Extern_To_InternE(atof(GetVarValue(FuncParam.Get(0))));

      // месяцы принадлежности и начисления
      var MP = CreateObject("KDate");
      var MV = CreateObject("KDate");
      MP.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(1)));
      MV.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(2)));
      int m = mrasch, mv = mrasch;
      if ( !MP.IsEqI(INVALID_DATE_VALUE) ) m  = MP.GetAbs();
      if ( !MV.IsEqI(INVALID_DATE_VALUE) ) mv = MV.GetAbs();

      long Flag = BE_CODE;
      if ( CountParam>3 ) // задан флаг разноски
      {
        string s=FuncParam.Get(3);
        Flag=0;
           // отбор по ключу строки                               
        if ( reinterpret_cast_to_long(strstr(s,"BE_KEY")) )
          Flag |= BE_KEY;

           // отбор по коду вида
        if ( reinterpret_cast_to_long(strstr(s,"BE_CODE")) )
          Flag |= BE_CODE;

           // отбор по точному коду
        if ( reinterpret_cast_to_long(strstr(s,"BE_EXACT")) )
          Flag |= BE_EXACT;

           // не добавлять новую строку при                       
           // отсутствии в ЛС нужной строки                       
        if ( reinterpret_cast_to_long(strstr(s,"BE_REPLACE")) )
          Flag |= BE_REPLACE;

           // не заменять сумму, если она уже есть в ЛС
        if ( reinterpret_cast_to_long(strstr(s,"BE_FREESUM")) )
          Flag |= BE_FREESUM;

           // отбор по собственному истфину строки
        if ( reinterpret_cast_to_long(strstr(s,"BE_SRC_L")) )
          Flag |= BE_SRC_L;

           // отбор по истфину
        if ( reinterpret_cast_to_long(strstr(s,"BE_SRC")) )
          Flag |= BE_SRC;
           
           // отбор действующих строк
        if ( reinterpret_cast_to_long(strstr(s,"BE_ACTIVE")) )
          Flag |= BE_ACTIVE;

           // отбор строк по столбцу табл.вх.(номер столбца - в параметре IntCode)
        if ( reinterpret_cast_to_long(strstr(s,"BE_COL")) )
          Flag |= BE_COL;

           // признак выбора "скрытых" видов
        if ( reinterpret_cast_to_long(strstr(s,"BE_HIDDEN")) )
          Flag |= BE_HIDDEN;

           // отбор действующих строк (в месяце принадлежности m)
        if ( reinterpret_cast_to_long(strstr(s,"BE_IGNORE_MACTIVE")) )
          Flag |= BE_IGNORE_MACTIVE;

           // добавление суммы к существующей
        if ( !(Flag & BE_FREESUM) && reinterpret_cast_to_long(strstr(s,"BE_MERGE_SUM")) )
            bMergeSumm=true;
        if ( !(Flag & BE_FREESUM) && reinterpret_cast_to_long(strstr(s,"BE_MERGE_RV")) )
            bMergeRv=true;
      }

      double Rv=0.;
      if ( CountParam>4 ) // задано РВ
        Rv=atof(GetVarValue(FuncParam.Get(4)));


      var Src=CreateObject("APropBE");
      if ( CountParam>5 ) // задан источник
      {
        char s[256];
        s = GetVarValue(FuncParam.Get(5));
        if (s[0]=='*' && s[1]=='*') Src.Initial(GetCommonProp(CMN_SRC_REFS2));
        else if ( IsSubStrPresent(s,"~") ) Src.LoadFromStr(to_string(s));
        else Src.InitSrc(ExtSrcToInt(s[0]));
      }

      double Summa=atof(pcT);
      if ( CountParam>6 ) // задана сумма
        Summa=atof(GetVarValue(FuncParam.Get(6)));

      struct SumElemS E;
      E.summa=Summa;
      E.rv=Rv;
      E.m=m;
      E.mv=mv;
      E.mp=INVALID_MONTH_VALUE;
      E.dayp=INVALID_DAY_VALUE;
      if ( CountParam>7 ) // задана дата
      {
         var Dat = CreateObject("KDate");
         Dat.SetDateD(GetDateFromFuncRWScript(FuncParam.Get(7)));
         if ( !Dat.IsEqI(INVALID_DATE_VALUE) )
         {
            E.mp=Dat.GetAbs();
            E.dayp=Dat.GetDay();
         }   
      }

      if ( bMergeSumm || bMergeRv )
      {
         cntrow=poiskosnkod(Cod,rowkod,0,CLL_TOTAL_SRC);
         for ( int row=0; row<cntrow; ++row )
         {
            if ( bMergeSumm )
               OldSum[row]=CollectSumm(GetCode(rowkod[row]),E.m,E.mv,CL_M|CL_MV|CL_EXACT);
            if ( bMergeRv )
            {
               var LS = CreateObject("LS");
               LS.GetGlobalLS();
               var MatrLS = LS.MatrLS();
               var Prop = CreateObject("APropBE");
               var SumElem = MatrLS.CollectSumm(GetCode(rowkod[row]),E.m,E.mv,CL_M|CL_MV|CL_EXACT,Prop);
               OldRv[row]=SumElem.RV;
            }
         }
      }
      double NewCode = PutSummProp(Cod,E,Src,Flag);
      if ( bMergeSumm || bMergeRv )
      {
         for ( int row=0; row<cntrow; ++row )
         {  
            if ( nabs(GetCode(rowkod[row])-NewCode)<0.0000001 )
            {
               if ( bMergeSumm ) E.summa+=OldSum[row];
               if ( bMergeRv   ) E.rv += OldRv[row];
               Flag |= BE_REPLACE;
               Flag &= ~BE_FREESUM;
               PutSummProp(Cod,E,Src,Flag);
               break;
            }
         }
      }
      toUseal(1);
   }
   return pcT;
}

R_SHORT_FIO( &Arg, &pcT, W, A)
//////////////////////////////////////////////////////////////////
// читает фамилию имя отчество из справки о предприятии по псевдониму поля
// и возвращает фамилию и инициалы
// ---------------------------------------------------------------
// СФИО(парам1, парам2)
// парам1 - имя поля из справки о предприятии (РУКП, ГЛБУХ, ОТВНАЛ и т.п.)   
// парам2 - 0, или параметр опущен - фамилия и инициалы
//          1 - как есть
//////////////////////////////////////////////////////////////////
{
  var FuncParam =  CreateObject("ParamFuncRW");
  FuncParam.IInitial(static_cast_to_string(Arg),",",10);
  int CountParam=FuncParam.Count();
  char Str[200];

  if (CountParam)
  {
    string Field=static_cast_to_string(FuncParam.Get(0));
    char Name[128];
    GetEnterpriseVar(Field,Name,127); 

    if (CountParam==2)
    {
      int n=atoi(static_cast_to_string(FuncParam.Get(1)));
      if (n)
      {
        sprintf(Str,"%s",Name);
        Text_Text(pcT,Str,W);
        return pcT;
      }
    }

    int count = count_elem(Name,' ');
    for (int i=1; i<=count; i++)
    {
      char Buf[100];
      elem_of_array(Name,i,' ',Buf, 99);
      FreeSpaceString(Buf,3,"");
      if (i==1) sprintf(Str,"%s",Buf);
      else
      {
        if ( (Buf[1]=='.') && (i==2) ) sprintf(Str,"%s %s",Str,Buf);
        else 
        {
          if (i==2)
            sprintf(Str,"%s %c.",Str,Buf[0]);
          else
            sprintf(Str,"%s%c.",Str,Buf[0]);
        }
      }
    }
    Text_Text(pcT,Str,W);
  }

  return pcT;
}

R_Padeg( &Arg, &pcT, W, A)
//////////////////////////////////////////////////////////////////////////////////
// Склонение ФИО по падежам
// Параметры: 
// 1 - ФИО (Фамилия Имя Отчество)
// 2 - падеж (1-именительный,2-родительный,3-дательный,...,6-предложный
// 3 - пол ( 0 - ж, !=0 - м, или символами М, м, Ж, ж)
//////////////////////////////////////////////////////////////////////////////////
{
   char Result[W+1];
   Text_Text(Result,pcT,W);
   var Param = CreateObject("ParamFuncRW");
   Param.IInitial(static_cast_to_string(Arg),", ",3);
   if (Param.Count()<2) return pcT;
   string pFIO = GetVarValue(Param.Get(0));

   char Buf[21];
   Calc_Expr(Param.Get(1),Buf,20,20,0);
   int TmpP = atoi(Buf);
   long Padeg = ( TmpP>=IMENIT_PADEG && TmpP<=PREDL_PADEG ) ? TmpP : IMENIT_PADEG;

/*
   int Len=strlen(pFIO);
   string FIO[3];
   char FBuf[Len+1];
   var F_I_O = CreateObject("ParamFuncRW");
   F_I_O.IInitial(pFIO," ",3);
   for (int i=0; i<3; i++)
   {
       if (i<F_I_O.Count()) Text_Text(FBuf,F_I_O.Get(i),Len);
       else                 Text_Text(FBuf," ",Len);
       FIO[i]=FBuf;
   }
*/
   
   if (Param.Count()<3)
        GetFIOPadegFSAS(pFIO,Padeg,Result,W);
        // GetFIOPadegAS(FIO[0],FIO[1],FIO[2],Padeg,Result,W);
   else
   {
      bool bSex=true;
      char Work[513];
      Text_Text(Work,GetVarValue(Param.Get(2)),512);
      FreeSpaceString(Work,2,"");
      bool bMan   = Work[0]=='m' || Work[0]=='M' || Work[0]=='м' || Work[0]=='М';
      bool bWoman = Work[0]=='ж' || Work[0]=='Ж';
      if ( bMan || bWoman ) bSex = bMan;
      else
      {
         Calc_Expr(Work,Buf,20,20,0);
         if ( atoi(Buf) ) bSex=true;
         else             bSex=false;
      }
      GetFIOPadegFS(pFIO,bSex,Padeg,Result,W);
      // GetFIOPadeg(FIO[0],FIO[1],FIO[2],bSex,Padeg,Result,W);
   }
   Text_Text(pcT,Result,W);
   return pcT;
}

IsVidPeriod(iCod)
// функция проверяет есть ли вид в ЛС и действует ли он в заданном
// в панели запроса периоде, период определяется по месяцам
// если да возвращает 1; если нет 0; если вида нет -1
{
  string Rez="";

  char TmpStr[20];

  sprintf(TmpStr,"%c%c%c%c%c%c",Str_Date_0[3],Str_Date_0[4],Str_Date_0[5],
                                Str_Date_0[6],Str_Date_0[0],Str_Date_0[1]);
  int BPer=atoi(TmpStr);

  sprintf(TmpStr,"%c%c%c%c%c%c",Str_Date_1[3],Str_Date_1[4],Str_Date_1[5],
                                Str_Date_1[6],Str_Date_1[0],Str_Date_1[1]);
  int EPer=atoi(TmpStr);

  int n=-1;
  //  n=poisk(iCod);
  for (int crow=0; crow<countkod; crow++)
  {
    int kod=GetCode(crow);
    if (kod==iCod)
    {
      n=crow;
      int BegDate=GetBegDate(crow);
      int EndDate=GetEndDate(crow);

      if (BegDate<=BPer && EndDate>=EPer) return 1; else Rez="0";
    }
  }

  if (n==-1) return -1;
  return Rez;
}

FlagKchInvPeriod(str)
{
  int n=0;
  int group=0;
  char buf[101];

  int celem=count_elem(str,';');
  if (celem>0)
  {
    for (int i=1; i<=celem; i++)
    {
      elem_of_array(str,i,';',buf,100);
      int group=GetGroupInv(buf);
      if (group>0) 
      {
        n=1; break;
      }
    }
  }
  return n;
}

FlagKchVmenenPeriod()
{
  char arg[256];
  char rez[256];
  char buf[101];
  int n=0;

  sprintf(arg,"d_vmenen,0,СКОЛЬКО");
  int count=atoi(R_KCH_PERIOD(arg,rez,25,0));

  for (int i=0; i<count; i++)
  {
    sprintf(arg,"d_vmenen,%2d",i+1);
    R_KCH_PERIOD(arg,rez,250,0);
    elem_of_array(rez,2,',',buf,100);
    int proc=atoi(buf);

    if (proc>0)
    {
      n=1; break;
    }
  }
  return n;
}

FlagStdDedPeriod()
{
  char arg[256];
  char rez[256];
  char buf[101];
  int n=2;

  string sv[3];
  sv[0]="kmin";
  sv[1]="kmin_i";
  sv[2]="mul_ded";

  for (int k=0; k<3; k++)
  {
    sprintf(arg,"%s,0,СКОЛЬКО", sv[k]);
    int count=atoi(R_KCH_PERIOD(arg,rez,25,0));

    for (int i=0; i<count; i++)
    {
      sprintf(arg,"%s,%2d",sv[k],i+1);
      R_KCH_PERIOD(arg,rez,250,0);
      elem_of_array(rez,2,',',buf,100);
      int cod=atoi(buf);

      if (cod>0)
      {
        n=1; break;
      }
    }
    if (n==1) break;
  }

  return n;
}


MainSrcLs()
//=======================================================================================
// Возвращает код главного источника финансирования ЛС.
// Главным считается источник в котором находится вид результирующего подоходного налога,
// внутренний код - 205
//=======================================================================================
{
  int MainSrc=0; // главный истчник

  for (int row=0; row<countkod; row++) // цикл по строкам ЛС   
  {   
    double iKod=GetCode(row); // внутренний код строки (точный)   
    int    Src =IntSrcToExt(GetSrcOfCod(iKod)); // интегральный источник строки
    // определяем главный источник в ЛС
    if (static_cast_to_int(iKod)==205) 
    {
      MainSrc=Src; 
      break;
    }
  }

  char rez[5]; 
  sprintf(rez,"%c",MainSrc);
  return static_cast_to_string(rez);
}


PaySocStr(Pay,Src,Typ,Ver)
//=============================================================================================
// Выплаты на цели обязательного социального страхования
// Используется в таблицах справок по ФСС 
// Pay: вид выплаты
//   9 - по временной нетрудоспособности     
//   2 - по беременности и родам
//   3 - по уходу за ребенком до 1.5 лет
//   4 - при рождении ребенка
//   5 - пособие на погребение
//   6 - по уходу за детьми-инвалидами
//   7 - пособие женщинам, вставшим на учет в ранние сроки беременности
//   8 - пособие при усыновлении ребенка
//   А - детские оздоровительные лагеря
//   Б - санаторные оздоровительные лагеря
//   В - возмещещение командировочных расходов лицам, сопровождающим детей в детские санаторные
//       оздоровительные лагеря
//   Г - выплата денежной компенсации в случае невозможности предоставления путевки
// Src: главный источник финансирования ЛС
// Typ: тип выборки данных 0 - по месяцу принадлежности; 1 - по месяцу начисления  
// Ver: 1 - версия АМБы с функцией IsVidVmenen(); 0 - версия без данной функции
// Возвращает значение в виде списка: число случаев, дней, сумма, - для невмененного дохода
//                                    число случаев, дней, сумма  - для вмененного дохода
//                                    число случаев, дней, сумма, - для невмененного дохода (совместительство)
//                                    число случаев, дней, сумма  - для вмененного дохода   (совместительство)
//=============================================================================================
{
  char arg[256];
  char str[256];
  char ts[256];

  var m1 = CreateObject("KMonth");
  var m2 = CreateObject("KMonth");

  m1.SetDate(static_cast_to_string(Str_Date_0));
  m2.SetDate(static_cast_to_string(Str_Date_1));

  int mbeg = m1.GetAbs(),
      mend = m2.GetAbs();

  int cnt = 0, 
      dni = 0,
      cnv = 0,
      dnv = 0;

  double eps = 0.001,
         sum = 0.0,
         svm = 0.0;

  int cnts = 0, 
      dnis = 0,
      cnvs = 0,
      dnvs = 0;

  double sums = 0.0,
         svms = 0.0;

  int cnt2 = 0, 
      dni2 = 0,
      cnv2 = 0,
      dnv2 = 0;

  double sum2 = 0.0,
         svm2 = 0.0;

  char src[50]; sprintf(src,"%s", static_cast_to_string(Src)); FreeSpaceString(src,3,""); //  unsigned char src = ts[0];

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

  double code, proc, sm;

  int rv = 0;
  int vm = 0;

  int cntvid = 0; // реальное число строк пособий до 1.5 лет
  int cntmax = 100;

  double code3[cntmax],
         dbeg3[cntmax];

  int flag3[cntmax];

  int flag = 0;

  kch_from("det",str);
  int cntdet = atoi(str);

////////////////////////////////////////////////////////////////
  if ( '3' == Pay )
  {
    for ( int row = 0; row < countkod; row++ )
    { // цикл по строкам ЛС
      code = GetCode(row);
    
      var de = CreateObject("KDate");
      de.SetDateD(GetEndDate(row));
      if ( de.IsEqI(INVALID_DATE_VALUE) ) continue;
      if ( Pay != Sim_For_Intern_Cod(code,1101) ) continue;
      if ( cntmax <= cntvid ) continue;

      code3[cntvid] = code;
      dbeg3[cntvid] = GetBegDate(row);
      flag3[cntvid] = 1;
  
      cntvid++;
    }
  
    // теперь посмотрим что мы насобирали и расставим флажки
    if ( cntdet > 1 )
    {
      if ( cntdet > cntvid ) for ( int i = 0; i < cntvid; i++ ) flag3[i] = 2; // в случае если детей больше чем строк считаем что те что в строках младшие
      else
      {
        // сначала раздадим всем вторые флажки
        for ( int i = 0; i < cntvid; i++ ) flag3[i] = 2;
    
        // теперь найдем запись достойную первого флажка
        if ( cntvid )
        {
          // найдем запись с минимальной датой начала
          double dmin = dbeg3[0];
          int zmin = 0;
    
          for ( int i = 0; i < cntvid; i++ )
          {
            if ( dbeg3[i] - dmin < eps )
            {
              dmin = dbeg3[i]; // минимальная дата начала
              zmin = i;        // номер записи с минимальной датой начала
            }
          }
    
          // среди записей с минимальной датой найдем запись с минимальным расширением
          int ikod = code3[zmin];
          sprintf(str,"%5.0f",(code3[zmin]-ikod*1.0)*100.0);
          int extmin = atoi(str);
    
          for ( int i = 0; i < cntvid; i++ )
          {
            if ( nabs(dbeg3[i] - dmin) > eps ) continue;
    
            ikod = code3[i];
            sprintf(str,"%5.0f",(code3[i]-ikod*1.0)*100.0);
            int te = atoi(str);
    
            if ( te < extmin ) 
            {
              extmin = te;
              zmin = i;
            }
          }
    
          // найденной записи отдадим первый флажок
          flag3[zmin] = 1;
        }
      }
    }
  }
////////////////////////////////////////////////////////////////////////

  for ( int mes = mbeg; mes <= mend; mes++ )
  { // цикл по месяцам

    sprintf(arg,"5,%d", mes); // находим первый день месяца
    sprintf(ts,"01.%s", R_DATA_EX(arg,str,7,4));  
    sprintf(arg,"d_vmenen,%s", ts);
    proc = atof(R_Face(arg,str,14,2));

    sprintf(arg,"inc_type,%s", ts);
    int sovm1 = atoi(R_Face(arg,str,14,0)); // 1 - совместительство

    sprintf(arg,"kod_rab,%s", ts);
    int sovm2 = atoi(R_Face(arg,str,14,0)); // 4 - совместительство

    int sovm = 0;

    if ( 1 == sovm1 || 4 == sovm2 || 9 == sovm2 ) sovm = 1;

    if ( !atoi(Ver) )
    {
      sprintf(arg,"8,%d", mes);
      int meso = atoi(R_DATA_EX(arg,str,7,0)); // преобразовыли месяц из абсолютного в относительный

      sprintf(arg,"\"%c\",\"н\",1102,%d,%d",Pay,meso,meso);
      sm = ( Typ ) ? atof(R_Col_S_MV(arg,str,25,2)) : atof(R_Col_S(arg,str,25,2));
    
      sprintf(arg,"\"%c\",\"н\",1102,%d,%d,%-1.1s",Pay,meso,meso,src);
      rv = ( Typ ) ? atoi(R_Col_T_MV(arg,str,25,2)) : atoi(R_Col_T(arg,str,25,2));

//      PaySocCount(cnt,dni,sum,cnv,dnv,svm,sm,rv,vm,proc);
    }
    else
    {
      int ckod = countkod + 1;
      int ck = 0; // ральное количество строк

      double COD[ckod];
      double SUM[ckod];
      double  RV[ckod];                                              
      char   SRC[ckod];
      int     VM[ckod];

      for ( int i = 0; i < ckod; i++ )
      {
        COD[i] = 0.0;
        SUM[i] = 0.0;
         RV[i] = 0.0;
        SRC[i] = 0;  
         VM[i] = 0;
      }

      for ( int row = 0; row < countkod; row++ )
      { // цикл по строкам ЛС
        code = GetCode(row);

        var de = CreateObject("KDate");
        de.SetDateD(GetEndDate(row));
        if ( de.IsEqI(INVALID_DATE_VALUE) ) continue;

        if ( Pay != Sim_For_Intern_Cod(code,1101) ) continue;
        vm = IsVidVmenen(code); // 1 - вмененка; 0 - невмененка

        if ( !atoi(Typ) ) sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_M,0);
        else              sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_MV,0);
      
        if ( !atoi(Typ) ) rv = CashSumm(0,code,mes,mes,42,CL_EXACT|CL_M,0);
        else              rv = CashSumm(0,code,mes,mes,42,CL_EXACT|CL_MV,0);

        // "удержания" с выплат по уходу за детьми-инвалидами не собираем
        if ( '6' == Pay  && !IsCodeNach(code) )
           sm=rv=0.;
        

        int fmsrc = 0;
        sprintf(ts,"%c",IntSrcToExt(GetSrcOfCod(code)));
        if ( ts == src ) fmsrc = 1;

        if ( '3' == Pay )
        {
          for ( int i = 0; i < cntvid; i++ )
          {
            if ( nabs(code-code3[i]) < eps ) flag = flag3[i];
          }
        }

        if ( 'Т' == Pay || 'П' == Pay || 'О' == Pay )
        {
          vm = 0;
          proc = 0.0;
        }

        if ( '9' != Pay  && '2' != Pay  && '6' != Pay )
        {
          if ( nabs(sm) > eps )
          {
            PaySocCount(cnt, // число случаев для невмененки                                                        
                        dni, // число дней для невмененки                                                           
                        sum, // сумма для невмененки                                                                
                        cnv, // число случаев для вмененки                                                          
                        dnv, // число дней для вмененки                                                             
                        svm, // сумма для вмененки                                                                  
                       cnts, // число случаев для невмененки (совместительство) (до 1.5 лет 1-й ребенок)
                       dnis, // число дней для невмененки    (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       sums, // сумма для невмененки         (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       cnvs, // число случаев для вмененки   (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       dnvs, // число дней для вмененки      (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       svms, // сумма для вмененки           (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       cnt2, // число случаев для невмененки (до 1.5 лет 2-й ребенок)
                       dni2, // число дней для невмененки    (до 1.5 лет 2-й ребенок)                                    
                       sum2, // сумма для невмененки         (до 1.5 лет 2-й ребенок)                                    
                       cnv2, // число случаев для вмененки   (до 1.5 лет 2-й ребенок)                                    
                       dnv2, // число дней для вмененки      (до 1.5 лет 2-й ребенок)                                    
                       svm2, // сумма для вмененки           (до 1.5 лет 2-й ребенок)                                    
                         sm, // сумма                                                                               
                         rv, // РВ                                                                                  
                         vm, // флаг принадлежности суммы к источнику или совместительству отмеченным как "вмененка"
                       proc, // % вмененного дохода из КЧ                                                           
                       sovm, // 1 - совместительство
                        Pay,
                       flag);// флаг количества детей                                                                
                      
          }
        }
        else
        {
          if ( nabs(sm) > eps )
          {
            COD[ck] = code;
            SUM[ck] = sm;
             RV[ck] = rv;
            SRC[ck] = ts[0]; 
             VM[ck] = vm;
                ck++;
          }
        }
      } // конец цикла по строкам ЛС

      if ( '9' == Pay  || '2' == Pay || '6' == Pay )
      {

        for ( int i = 0; i < ck-1; i++ )
        {
          for ( int j = i+1; j < ck; j++ )
          {
            if ( nabs(RV[i] - RV[j]) < eps && VM[i] == VM[j] ) 
            {
              SUM[i] += SUM[j];
              SUM[j] = 0.0;
            }
          }
        }

        for ( int i = 0; i < ck; i++ )
        {
          if ( nabs(SUM[i]) > eps )
          {
            sm = SUM[i];
            rv = RV[i];
            vm = VM[i];

            PaySocCount(cnt, // число случаев для невмененки                                                        
                        dni, // число дней для невмененки                                                           
                        sum, // сумма для невмененки                                                                
                        cnv, // число случаев для вмененки                                                          
                        dnv, // число дней для вмененки                                                             
                        svm, // сумма для вмененки                                                                  
                       cnts, // число случаев для невмененки (совместительство) (до 1.5 лет 1-й ребенок)
                       dnis, // число дней для невмененки    (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       sums, // сумма для невмененки         (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       cnvs, // число случаев для вмененки   (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       dnvs, // число дней для вмененки      (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       svms, // сумма для вмененки           (совместительство) (до 1.5 лет 1-й ребенок)                                    
                       cnt2, // число случаев для невмененки (до 1.5 лет 2-й ребенок)
                       dni2, // число дней для невмененки    (до 1.5 лет 2-й ребенок)                                    
                       sum2, // сумма для невмененки         (до 1.5 лет 2-й ребенок)                                    
                       cnv2, // число случаев для вмененки   (до 1.5 лет 2-й ребенок)                                    
                       dnv2, // число дней для вмененки      (до 1.5 лет 2-й ребенок)                                    
                       svm2, // сумма для вмененки           (до 1.5 лет 2-й ребенок)                                    
                         sm, // сумма                                                                               
                         rv, // РВ                                                                                  
                         vm, // флаг принадлежности суммы к источнику или совместительству отмеченным как "вмененка"
                       proc, // % вмененного дохода из КЧ                                                           
                       sovm, // 1 - совместительство
                        Pay,
                       flag);// флаг количества детей                                                                
                      
          }
        }
      }
    }
  } // конец цикла по месяцам

  string rez = "";

  sprintf(ts,"%d",    cnt); FreeSpaceString(ts,3,""); rez =             ts; // невмененка
  sprintf(ts,"%d",    dni); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
  sprintf(ts,"%14.2f",sum); FreeSpaceString(ts,3,""); rez = rez + "," + ts;

  sprintf(ts,"%d",    cnv); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // вмененка
  sprintf(ts,"%d",    dnv); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
  sprintf(ts,"%14.2f",svm); FreeSpaceString(ts,3,""); rez = rez + "," + ts;

  sprintf(ts,"%d",    cnts); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // невмененка (совместительство) (до 1.5 лет 1-й ребенок)
  sprintf(ts,"%d",    dnis); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
  sprintf(ts,"%14.2f",sums); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
  
  sprintf(ts,"%d",    cnvs); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // вмененка   (совместительство) (до 1.5 лет 1-й ребенок)
  sprintf(ts,"%d",    dnvs); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
  sprintf(ts,"%14.2f",svms); FreeSpaceString(ts,3,""); rez = rez + "," + ts;

  if ( '3' == Pay )
  {
    sprintf(ts,"%d",    cnt2); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // невмененка (до 1.5 лет 2-й ребенок)
    sprintf(ts,"%d",    dni2); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",sum2); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    
    sprintf(ts,"%d",    cnv2); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // вмененка   (до 1.5 лет 2-й ребенок)
    sprintf(ts,"%d",    dnv2); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",svm2); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
  }

  return rez;
}


PaySocCount(&cnt, // число случаев для невмененки
            &dni, // число дней для невмененки
            &sum, // сумма для невмененки
            &cnv, // число случаев для вмененки
            &dnv, // число дней для вмененки   
            &svm, // сумма для вмененки        
           &cnts, // число случаев для невмененки (совместительство)
           &dnis, // число дней для невмененки    (совместительство)
           &sums, // сумма для невмененки         (совместительство)
           &cnvs, // число случаев для вмененки   (совместительство)
           &dnvs, // число дней для вмененки      (совместительство)
           &svms, // сумма для вмененки           (совместительство)
           &cnt2, // число случаев для невмененки 
           &dni2, // число дней для невмененки    
           &sum2, // сумма для невмененки         
           &cnv2, // число случаев для вмененки   
           &dnv2, // число дней для вмененки      
           &svm2, // сумма для вмененки           
              sm, // сумма
              rv, // РВ
              vm, // флаг принадлежности суммы к источнику или совместительству отмеченным как "вмененка"
            proc, // % вмененного дохода из КЧ
            sovm, // 1 - совместительство
             Pay,
            flag  // флаг количества детей
)
{
  double tmp, eps = 0.001;

  if ( nabs(sm) > eps )
  {
    if ( !vm ) 
    { // невмененка
      if ( proc < eps )
      { // % вмененного дохода в КЧ нулевой
        cnt++;
        dni += rv;
        sum += sm;

        if ( '9' == Pay ) // по временной нетрудоспособности
        {
          if ( 1 == sovm )
          {
            cnts++;
            dnis += rv;
            sums += sm;
          }
        }

        if ( '3' == Pay ) // до 1.5 лет
        {
          if ( 1 == flag ) // 1-й ребенок
          {
            cnts++;
            dnis += rv;
            sums += sm;
          }

          if ( 2 == flag ) // 2-й ребенок
          {
            cnt2++;
            dni2 += rv;
            sum2 += sm;
          }
        }
      }
  
      if ( proc > eps && proc < 99.999 )
      { // % вмененки в КЧ больше нуля и меньше 100
        tmp = sm * proc / 100.0; round( tmp ); 
        svm += tmp;
        sum += ( sm - tmp );
  
        cnt++;
        dni += rv;
        cnv++;
        dnv += rv;

        if ( 1 == sovm && '3' != Pay )
        {
          tmp = sm * proc / 100.0; round( tmp ); 
          svms += tmp;
          sums += ( sm - tmp );
  
          cnts++;
          dnis += rv;
          cnvs++;
          dnvs += rv;
        }

        if ( 1 == flag  && '3' == Pay )
        {
          tmp = sm * proc / 100.0; round( tmp ); 
          svms += tmp;
          sums += ( sm - tmp );
  
          cnts++;
          dnis += rv;
          cnvs++;
          dnvs += rv;
        }

        if ( 2 == flag )
        {
          tmp = sm * proc / 100.0; round( tmp ); 
          svm2 += tmp;
          sum2 += ( sm - tmp );
  
          cnt2++;
          dni2 += rv;
          cnv2++;
          dnv2 += rv;
        }
      }
  
      if ( proc > 99.999 )
      { // 100% вмененки в КЧ
        cnv++;
        dnv += rv;
        svm += sm;

        if ( 1 == sovm && '3' != Pay )
        {
          cnvs++;
          dnvs += rv;
          svms += sm;
        }

        if ( 1 == flag && '3' == Pay )
        {
          cnvs++;
          dnvs += rv;
          svms += sm;
        }

        if ( 2 == flag )
        {
          cnv2++;
          dnv2 += rv;
          svm2 += sm;
        }
      }
    }
    else 
    { // вмененка
      cnv++;
      dnv += rv;
      svm += sm;

      if ( 1 == sovm && '3' != Pay )
      {
        cnvs++;
        dnvs += rv;
        svms += sm;
      }

      if ( 1 == flag && '3' == Pay )
      {
        cnvs++;
        dnvs += rv;
        svms += sm;
      }

      if ( 2 == flag )
      {
        cnv2++;
        dnv2 += rv;
        svm2 += sm;
      }
    }
  }
  
  return 0;
}

count_elem(Str, ch)
// функция считает число элементов в строке Str,
// разделенных символом ch;
// возвращает - если символ ch не найден - 0,
// иначе - число найденных символов ch + 1;
// работает в паре с функцией elem_of_array()
{
  int cnt=0, k=0;
  int length=strlen(Str);
  for (int i=0; i<length; ++i)
  {
    if (Str[i]=='\0') break;
    if (Str[i]!=' ') k=1;
    if (Str[i]==ch) 
    {
      cnt++;    
    }
  }
  if (cnt>0)
    cnt++;
  if (cnt==0 && k==1)
    cnt++;

  return cnt;  
}

PartOfSeparatedString(Str,Razd,idx)
{
   if ( idx<0 ) return "";
   var Razb = CreateObject("ParamFuncRW");
   Razb.IInitial1(to_string(Str),to_string(Razd),idx+1);
   return Razb.Get(idx);
}

elem_of_array(Str, Num, ch, &Buf, W)
// функция возвращает элемент Num массива Str, элементы которого
// разделены символом ch; нумерация с 1;
// W - размер Buf, Buf - результат;
{
  char Str1[256], Str2[256];
  int length = strlen(Str);
  if ( length > 256 ) return (0);
  sprintf(Str1,"%-*.*s",length,length,Str);
  sprintf(Str2,"%-s",RTrim(Str1));
  length = strlen(Str2);
  int i, count, n;
  for ( i=0, count=0, n=0; ((i<length) && (n<W)); ++i)
  {
    if ( Str2[i] == '\0' ) 
    {
      Buf[n] = 0;
      break;
    }
    if ( count == (Num-1) )
    {
      if (Str2[i]==ch)
      {
        Buf[n] = 0;
//        break;
      }
      else
      {
        Buf[n] = Str2[i];
        n++;
      }
    }
    if (Str2[i]==ch) count++;
  }

  if ( n > 0 ) Buf[n] = 0;

  return (0);
}

PaySocVm(Sim,Str,Typ,Ver)
// Функция для вычисления доли соц.выплат приходящейся на вмененный доход
// Используется в таблицах справок по ФСС 
// Sim : буква, по которой считается налог
// Typ : тип выборки данных 0 - по месяцу принадлежности; 1 - по месяцу начисления  
// Ver : 1 - версия АМБы с функцией IsVidVmenen(); 0 - версия без данной функции
// Возвращает список вида: сумма невмененки, сумма вмененки с процента, сумма вмененки с вида; 
//                         и т.д для каждого месяца периода
{
  char arg[256],
       str[256],
       ts[256];

  var m1 = CreateObject("KMonth");
  var m2 = CreateObject("KMonth");

  m1.SetDate(static_cast_to_string(Str_Date_0));
  m2.SetDate(static_cast_to_string(Str_Date_1));

  int mbeg = m1.GetAbs(),
      mend = m2.GetAbs();

  string rez = "";

  // цикл по месяцам
  for ( int mes = mbeg; mes <= mend; mes++ )
  {
    // % вмененного дохода
    sprintf(arg,"5,%d", mes);
    sprintf(ts,"01.%s", R_DATA_EX(arg,str,7,4));  
    sprintf(arg,"d_vmenen,%s", ts);
    double proc = atof(R_Face(arg,str,14,2));
    if ( proc < 100 ) proc = 0;

    sprintf(arg,"8,%d", mes); 
    int meso = atoi(R_DATA_EX(arg,str,7,0)); // преобразовыли месяц из абсолютного в относительный
    
    // сумма выплат из соцстраха
    sprintf(arg,"79,1,%d,%d,*,*,%s", meso, meso, Sim);
    double Sum = atof(R_Tax(arg,str,25,2));

    double tvp = 0.0,
           tvv = 0.0;

    if ( !atoi(Ver) )
    {
      tvp = ( proc > 0.001 ) ? Sum * proc / 100.0 : 0.0; 
    }
    else
    {
      double sm,tv,code;
      double svm = 0.0;

      for ( int row = 0; row < countkod; row++ )
      { // цикл по строкам ЛС
        code = GetCode(row);

        if ( !reinterpret_cast_to_long(strrchr(Str,Sim_For_Intern_Cod(code,1101))) ) continue;

        int vm = IsVidVmenen(code); // 1 - вмененка; 0 - невмененка
    
        if ( !atoi(Typ) ) sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_M,0);
        else              sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_MV,0);

        if ( !vm ) tvp += ( proc > 0.001 ) ? sm * proc / 100.0 : 0.0; 
        else       tvv += sm;
      } // конец цикла по строкам ЛС
    }

    round(tvp);

    sprintf(ts,"%14.2f",Sum); FreeSpaceString(ts,3,""); rez = rez + ts + ",";
    sprintf(ts,"%14.2f",tvp); FreeSpaceString(ts,3,""); rez = rez + ts + ",";
    
    sprintf(ts,"%14.2f",tvv); FreeSpaceString(ts,3,"");
    
    if ( mes != mend ) rez = rez + ts + ";";
    else               rez = rez + ts; 
  } // конец цикла по месяцам

  return rez;

}


string TravmaString = "";

PayTravma()
// Функция для расчета отчислений на травматизм
// Используется в таблицах справок по ФСС 
// Возвращает список вида: 
//   сумма,
//   выплаты на которые не начисляются страховые взносы,
//   признак инвалидности;
//   признак особых условий труда
//   ... и т.д. для каждого месяца
{
  TravmaString = "";

  char Arg[256],
       Str[256],
       ts[256];

  var m1 = CreateObject("KMonth");
  var m2 = CreateObject("KMonth");

  m1.SetDate(static_cast_to_string(Str_Date_0));
  m2.SetDate(static_cast_to_string(Str_Date_1));

  int ames = m1.GetAbs(),
      kmes = m1.GetMonth(),
      mbeg = m1.GetRel(),
      mend = m2.GetRel();

  int year = m1.GetYear();

  double sim = 0.0;

  string rez = "";

  char t1[256]; t1 = Str_Date_0;
  char t2[256]; t2 = Str_Date_1;

  // цикл по месяцам
  for ( int mes = mbeg; mes <= mend; mes++, ames++, kmes++ )
  {
    var Mes = CreateObject("KMonth");
    Mes.SetMonth(ames);

    // сумма
    sprintf(Arg,"\"%s\",\"н\",1107,%d,%d","12Н",mes,mes);
    double sum = atof(R_Col_S_MV(Arg,Str,25,2)); sim = sum;
    sprintf(ts,"%15.2f", sum); FreeSpaceString(ts,3,"");
    rez = rez + ts + ",";

    // выплаты на которые не начисляются страховые взносы
    sprintf(Arg,"\"%s\",\"н\",1107,%d,%d","Б",mes,mes);
    sum = atof(R_Col_S_MV(Arg,Str,25,2));
    sprintf(ts,"%15.2f", sum); FreeSpaceString(ts,3,"");
    rez = rez + ts + ",";

    // дата увольнения
    sprintf(Arg,"data_uv,%02d.%02d.%4d", Mes.CountDay(), Mes.GetMonth(), Mes.GetYear());
    R_Face(Arg,Str,50,0);
    var Duv = CreateObject("KDate");
    Duv.SetDate(static_cast_to_string(Str));

    // признак инвалидности
    int inv = 0;
    sprintf(Arg,"d_inv,%02d.%02d.%4d", Mes.CountDay(), Mes.GetMonth(), Mes.GetYear());
    R_Face(Arg,Str,50,0);
    var SprInv = CreateObject("ParamFuncRW");
    SprInv.IInitial(static_cast_to_string(Str),",",3);

    if ( SprInv.Count()<=1 ) inv = atoi(Str);
    else                     
    {
      var Dat = CreateObject("KDate");
      Dat.SetDateD(GetDateEndInv(Str));

      int aMesEnd = Dat.GetAbs();
      if ( Dat.GetDay() < Dat.CountDay() ) aMesEnd--;

      inv = (GetGroupInv(Str)!=0 && 
             (Dat.IsEqI(INVALID_DATE_VALUE) || aMesEnd >= ames))?1:0;

//    inv = (GetGroupInv(Str)!=0 && 
//           (Dat.IsEqI(INVALID_DATE_VALUE) || Dat.GetAbs()>=ames))?1:0;

      if ( !Duv.IsEqI(INVALID_DATE_VALUE) && Duv.GetAbs() < ames ) 
      {
        if ( nabs(sim) < 0.001 ) inv = 0;
      }
    }

    if ( inv ) inv = 1;
    sprintf(ts,"%d", inv); FreeSpaceString(ts,3,"");
    rez = rez + ts + ",";

    // признак особых условий труда
    int out = 0;
    // Сначала посмотрим на поле со спец.оценкой
    GlobalInfoAboutStatus3 = GetNothing();
    FillInfoAboutStatus3(KDateFromInt_WithDay(1,ames),KDateFromInt_LastDay(ames));
    for ( GlobalInfoAboutStatus3.SetBegin(); !out && !GlobalInfoAboutStatus3.End(); GlobalInfoAboutStatus3.Next() )
       if ( atoi(GlobalInfoAboutStatus3.GetCurCod()) ) out=1;
    GlobalInfoAboutStatus3 = GetNothing();

    // Особые условия могут быть еще в трудовом стаже
    if ( !out )
    {
       char ts1[256]; sprintf(ts1,"%02d.%04d",kmes,year);
       Str_Date_0 = ts1;
       Str_Date_1 = ts1;
       sprintf(Arg,"ПРОВЕРКА_СТАЖА(1,ОСОБУСЛ)");
       CallFuncReceive(Arg,Str,20,0); FreeSpaceString(Str,3,"");
       if ( strlen(Str) ) out = 1;
    }
    sprintf(ts,"%d", out); FreeSpaceString(ts,3,"");
    if ( mes != mend ) rez = rez + ts + ";";
    else               rez = rez + ts; 

  } // конец цикла по месяцам

  Str_Date_0 = t1;
  Str_Date_1 = t2;

  TravmaString = rez;

  return rez;

}

IncSelProperty(str)
{
  var fp1 = CreateObject("ParamFuncRW");
  fp1.IInitial( static_cast_to_string(str), ";", 100);

  double sum = 0.0;

  for ( int i = fp1.Count(); i >= 0; i-- )
  {
    string ts = fp1.Get(i);

    var fp2 = CreateObject("ParamFuncRW");
    fp2.IInitial( ts, ",", 100);

    int ic = atoi(fp2.Get(0));

    if ( ic==4600 || ic==3010 || ic==2800 || ic==1530 || ic==1520 || ic==1510 || ic==4000 )
    {
      sum += atof(fp2.Get(1));
    }
  }

  return sum;
}


NumsDogsPodr()
// возвращает список номеров договоров подряда действовавших
// в заданном периоде
{
  string spisok = "";

  var mkBeg = CreateObject("KMonth"),
      mkEnd = CreateObject("KMonth");

  mkBeg.SetDate(static_cast_to_string(Str_Date_0));
  mkEnd.SetDate(static_cast_to_string(Str_Date_1));

  var dkBeg = CreateObject("KDate"),
      dkEnd = CreateObject("KDate");

  dkBeg.SetDateIM(1, mkBeg);


  dkEnd.SetDateIM(mkEnd.CountDay(), mkEnd);

  double cod,
         dBeg,
         dEnd;

  char sim;

  char str[256];
  char str1[256];

  // перебираем строки ЛС
  for(int i=0; i<countkod; i++)
  {
    cod = GetCode(i);
    sim = Sim_For_Intern_Cod(cod, 19);

    if ( sim == 'Р' )
    {
      dBeg = GetBegDate(i);
      dEnd = GetEndDate(i);

      if ( dBeg <= dkEnd.GetDouble() && dEnd >= dkBeg.GetDouble() )
      {
        Rkv_from(cod,"ндоговор",str1,str);
        FreeSpaceString(str,3,"");
        if ( strlen(spisok) ) spisok = spisok + "," + str;
        else                  spisok = str;
      }
    }
  }

  return spisok;
}


zamena_oboz (oboz, &str1)
//---------------------------------------------
// Замена обозначений в oboz с записью
// расшифровки в str1.
// str должна быть достаточна для расшифровки !
// Заменяются:  r - на rsimv,
//              n - на simv_nr,
//              s - на simv_otpsub,
//              w - на simv_vyhodn.
//---------------------------------------------
{
   char str_s_oboz[256], str[512];
   stccpy(str_s_oboz,oboz,256);
   int len;
   str[0]=0;
   for(int i=0; str_s_oboz[i]!='\0';i++)
   {
      switch(str_s_oboz[i])
      {
         case 'r':
            str += rsimv;
         break;

         case 'n':
            str += simv_nr;
         break;

         case 's':
            str += simv_otpsub;
         break;

         case 'w':
            str += simv_vyhodn;
         break;

         default:
            len = strlen(str);
            str[len]=str_s_oboz[i];
            str[len+1]=0;
         break;
      }
   }
   strcpy(str1,str);
   return 1;
}


CountTabelNormCalendDay(absm, _SimvTabel, _SimvNorm, bHoliday, &Hours )
//*********************************************************
//** Определяет количество отработанных дней в месяце absm
//** SimvTabel - какие символы в табеле учитываем
//** SimvNorm  - какие символы в нормативном календаре 
//**             учитываем
//** bHoliday - учитывать (1) только праздничные дни 
//              или их не учитывать (0)
//*********************************************************
{
   int TmpMrasch = mrasch;
   if ( absm!=mrasch )
      s50(absm);
   
   int CountDay = 0;
   double CountHours = 0.;

   char SimvTabel[512], SimvNorm[512];
   zamena_oboz(_SimvTabel,SimvTabel);
   zamena_oboz(_SimvNorm, SimvNorm);
   string Holidays = ListHolidays(absm);
   var razb = CreateObject("ParamFuncRW");
   razb.IInitial(Holidays,",",32);
   short HolidayDay[32];
   for ( int i=0; i<razb.Count(); ++i )
   {
      HolidayDay[i]=atoi(razb.Get(i));
   }
   
   for ( int day=1; day<=countday; day++ )
   {
      int pos = poisk1(day,HolidayDay,razb.Count(),0);
      if ( (bHoliday && pos!=EOF || !bHoliday && pos==EOF) &&
           CountChar(SimvTabel,calm[day-1]) && CountChar(SimvNorm,calmras[day-1])
         )
      {
         CountDay++;
         double rv;
         skoljko(rv,data,day,day,SimvTabel,calm,cht);
         CountHours += rv;
      }
   }
   Hours = CountHours;
   if ( TmpMrasch!=mrasch ) 
      s50(TmpMrasch);
   return CountDay;
}


CountWorkWorkDays(absm, &Hours)
{
   return CountTabelNormCalendDay(absm,"rn","n",0,Hours);
}

CountWorkSundays(absm, &Hours)
{
   return CountTabelNormCalendDay(absm,"rn","sw",0,Hours);
}

CountWorkHolidays(absm, &Hours)
{
   return CountTabelNormCalendDay(absm,"rn","nsw",1,Hours);
}

CWSH(absm,typ_rv,typ_days,w,a)
{
  int Days = 0;
  double Hours = 0.0;

  if ( typ_days == 1 ) Days = CountTabelNormCalendDay(absm,"r","n",0,Hours);
  if ( typ_days == 2 ) Days = CountTabelNormCalendDay(absm,"rn","sw",0,Hours);
  if ( typ_days == 3 ) Days = CountTabelNormCalendDay(absm,"rn","nsw",1,Hours);

  double rezult = 0.0;

  if ( typ_rv == 1 ) rezult = Days;
  else               rezult = Hours;

  char str[256];
  sprintf(str,"%*.*f",w,a,rezult);

  return static_cast_to_string(str);
}


FlagIncomPeriod(c)
{
  int fip = 0;

  char arg[256], str[256];

  var mBeg = CreateObject("KMonth"),
      mEnd = CreateObject("KMonth");

  mBeg.SetDate(static_cast_to_string(Str_Date_0));
  mEnd.SetDate(static_cast_to_string(Str_Date_1));

  int m1 = mBeg.GetMonth(),
      m2 = mEnd.GetMonth();

  for ( int mes = m1; mes <= m2; mes++ )
  {
    sprintf(arg,"1,1,_Beg(%d),_End(%d),*,*,%c",mes,mes,c);
    R_Tax(arg,str,25,2);

    if ( nabs(atof(str)) > 0.001 )
    {
      fip = 1;
      break;
    }
  }

  return fip;
}

// Обертки для системных OemToChar компенсирующие особенность работы с переменной
// типа string переданной как источник и как принимающий буфер
OemToChar(In,&Out)
{
   OemToCharA(In,Out);
}
CharToOem(In,&Out)
{
   CharToOemA(In,Out);
}

OemToAnsi( Str )
//=============================================================================
// Перевод в Windows-кодировку
//=============================================================================
{
   string Ans=Str;
   OemToChar(Str,Ans);
   return Ans;
}

AnsiToOem( Str )
//=============================================================================
// Перевод в Dos-кодировку
//=============================================================================
{
   string Oem=Str;
   CharToOem(Str,Oem);
   return Oem;
}
Oem( Str )
{
  return AnsiToOem(Str);
}

SRef(&buffer,bufsize,handle,&C_Params)
{ 
 //функция вызова простого справочника, см.описание функции CLASSIF

  char ss[bufsize+1];
  CharToOem(buffer,ss);
  SimpleRef(C_Params.NF,C_Params.WinX,C_Params.WinY,C_Params.DX,C_Params.DY,ss,bufsize-1,ss,C_Params.KF);
  OemToChar(ss, buffer);
return 1;
}

ChasInDay(mes,day,tip,_w,_a)
// mes - абсолютное значение месяца
// day - день ( 1 .. 31 )
// tip - 0 - по норме; 1 - по факту
// результат - количество рабочих часов
{
  double rc = 0.0;

  var Mes = CreateObject("KMonth");
  Mes.SetMonth(atoi(mes));

  char str[256],arg[256],rez[256];

  if (nkalend!=knorm)
  { 
     rwnorma(knorm,0); s118();
  }

  if ( day <= Mes.CountDay() )
  {
    int tmes = mrasch;
    s50(mes);
    sprintf(str,"%c",calm[day-1]);
    // Из-за особенности работы skoljko наверное для выходных
    // не надо выбирать число часов?
    // if ( !IsSubStrPresent(simv_vyhodn+simv_otpsub,str) )
    skoljko(rc,data,day,day,str,calm,tip);
    mrasch = tmes;
    s50(mrasch);
  }

  sprintf(rez,"%*.*f",_w,_a,rc);
  return static_cast_to_string(rez);
}

R_TaxSc4(c,m1,m2,t,w,a)
{
    char arg[256],str[256];
    sprintf(arg,"%d,1,_Beg(%d),_End(%d),%s,*,%c",c,m1,m2,"Источник выплаты",t);
    return static_cast_to_string(R_Tax(arg,str,w,a));
}

var vScriptGlobalRefOrg = 0;
int iScriptGlobalNumOrg = -1;
GetEnterpriseRefValueByPodr(podr,ps)
{
   // Важно!!! Для повышения скорости получения информации по организации
   // список настроек по последней организации сохраняется и может быть использован
   // в дальнейшем, НО если после создания этого списка, изменяли что-либо
   // в настройке по организации эти изменения не будут доступны до пересоздания
   // списка, поэтому желательно при начале работы с данной функцией (например для первой
   // строки таблицы, в которую принимаем данные, или в начале формы печати)
   // делать iScriptGlobalNumOrg = -1;
   int org = GetOrgForPodr(podr);
   return GetEnterpriseRefValue(org,ps);
}
GetEnterpriseRefValue(_Org,ps)
{
   return PriorityCall("UserGetEnterpriseRefValue","SysGetEnterpriseRefValue",_Org,ps);
}
SysGetEnterpriseRefValue(_Org,ps)
{
   int Org = _Org; // из таблиц может приходить как строка

   // Важно!!! Для повышения скорости получения информации по организации
   // список настроек по последней организации сохраняется и может быть использован
   // в дальнейшем, НО если после создания этого списка, изменяли что-либо
   // в настройке по организации эти изменения не будут доступны до пересоздания
   // списка, поэтому желательно при начале работы с данной функцией (например для первой
   // строки таблицы, в которую принимаем данные, или в начале формы печати)
   // делать iScriptGlobalNumOrg = -1;
   if ( iScriptGlobalNumOrg == -1 )
   {
      vScriptGlobalRefOrg=0;
      vScriptGlobalRefOrg = CreateObject("EnterpriseRefVar");
   }

   if ( Org!=iScriptGlobalNumOrg )
   {
      vScriptGlobalRefOrg.Initial(Org);
      iScriptGlobalNumOrg=Org;
   }
   return vScriptGlobalRefOrg.GetVar(ps);
}

GetEnterpriseRefValueByDate(Org,ps,date)
{
   // Важно!!! Для повышения скорости получения информации по организации
   // список настроек по последней организации сохраняется и может быть использован
   // в дальнейшем, НО если после создания этого списка, изменяли что-либо
   // в настройке по организации эти изменения не будут доступны до пересоздания
   // списка, поэтому желательно при начале работы с данной функцией (например для первой
   // строки таблицы, в которую принимаем данные, или в начале формы печати)
   // делать iScriptGlobalNumOrg = -1;
   if ( iScriptGlobalNumOrg == -1 )
   {
      vScriptGlobalRefOrg=0;
      vScriptGlobalRefOrg = CreateObject("EnterpriseRefVar");
   }

   if ( Org!=iScriptGlobalNumOrg )
   {
      vScriptGlobalRefOrg.Initial(Org);
      iScriptGlobalNumOrg=Org;
   }
   return vScriptGlobalRefOrg.GetVarByDate(ps,date);
}

R_TaxSc5(c,m1,m2,t,w,a)
{    
   char arg[256],str[256],rez[256],ts[256];
   sprintf(arg,"%d,1,_Beg(%d),_End(%d),%s,*,%c",c,m1,m2,"Источник выплаты",t);

   sprintf(ts,"%-255.255s",R_Tax(arg,str,w,a));
   FreeSpaceString(ts,3,"");

   var List = CreateObject("ParamFuncRW");

   List.IInitial(static_cast_to_string(ts),";",100);

   int cl = List.Count();

   rez[0] = 0;

   for ( int i = 0; i < cl; i++ )
   {
     var List1 = CreateObject("ParamFuncRW");
     sprintf(str,"%s",List.Get(i));
     List1.IInitial(static_cast_to_string(str),",",4);

     int cod = atoi(List1.Get(0));

     if ( cod == 1011 ) continue; // Сбербанк

     if ( rez[0]!=0 ) rez += ";";
     rez += List.Get(i);
   }

   return static_cast_to_string(rez);
}

AmbaMessageBoxRaz(Text, Title, Type, Dop)
{
  int R_C=0;
  do 
  {
     R_C=AmbaMessageBox(Text, Title, Type, Dop);
     if (R_C==IDCANCEL && (AmbaMessageBox("Прервать разноску?","",MB_YESNO|MB_ICONQUESTION|MB_DEFBUTTON2, 0)==IDYES) ) 
     {
       throw 0;   
     }
  } while (R_C==IDCANCEL);
  return R_C;
}

R_SelectCombForDoljn( &Arg, &pcT, W, A)   //"СОВМ_ПО_ДОЛЖН"
{
 // функция находит или создает совместительство в амбе для должности из "Контур-Персонал"
 // СОВМ_ПО_ДОЛЖН(парам1, парам2, парам3, парам4 )
 // парам1 - ID должности
 // парам2 - Наименование должности
 // парам3 - тип должности (ОСН, СОВМ, ЗАМС)
 // парам4 - код подразделения
 // парам5 - еще один тип должности (основная, по совместительству, договор...)
 //          в результате строки с типом (парам5=основная и парам3=СОВ) не разносятся
 
 // Если для заказчика необходимо сделать изменения в данной функции
 // необходимо скопировать эту функцию в файл USER\usfuncrw.s
 // изменив название например на R_SelectCombForDoljnMy 
 // и зарегистрировать ее в файле USER\usinit.s  добавив строку    
 // AddFunc("R_SelectCombForDoljnMy","СОВМ_ПО_ДОЛЖН2");
 // и использовать в таблице эту зарегистрированную функцию СОВМ_ПО_ДОЛЖН2
    
   var Param = CreateObject("ParamFuncRW");
   Param.IInitial(static_cast_to_string(Arg),", ",5);
   if (Param.Count()<3) throw 0;
   int KodDoljn=atoi(GetVarValue(Param.Get(0)));
   string NameDoljn=GetVarValue(Param.Get(1));
   FreeSpaceString(NameDoljn, 3, "");
   string TypeDoljn=GetVarValue(Param.Get(2));
   FreeSpaceString(TypeDoljn, 3, "");
   int Podr=0;
   if (Param.Count()>3) Podr=atoi(GetVarValue(Param.Get(3)));

   bool sovmesh=false;
   string tipDol2="";
   if (Param.Count()>4)
   {
     tipDol2=GetVarValue(Param.Get(4));
     FreeSpaceString(tipDol2, 3, "");
     if (Str_Cmp(TypeDoljn, "ОСН", " ") && !Str_Cmp(tipDol2,"основная"," "))
       sovmesh=true;
   } 

  var CL=CreateObject("CombineList");
  var it = CL.CreateIterator();

  var MapPanel = CreateObject("MapString");

  long num;
  polnyi_tn(num);
  long otdelKCH=num/sizetn; //подразделение в КЧ
  if (otdelKCH==0) //новый ЛС
  {
    if (!Podr) 
    { 
      AmbaMessageBox("Для новых ЛС обязательно должно быть указано подразделение!", "Ошибка!", 0, 0);
      throw 0;
    }
    char s[10];
    sprintf(s, "%d", Podr);
    kch_in("podr",s);
    otdelKCH=Podr;
  }

  char Name[70];
  rname0(Name, 1, 65);
  FreeSpaceString(Name, 3, "");
  string Title = Name+"\n\nВыберите совместительство для должности:\n("+tipDol2+", "+TypeDoljn+") "+NameDoljn;

  var MapRez = CreateObject("MapString");

  int Combine=0; // искомый код совместительства
  int New_Comb=0;//код для строки "Создать новое совместительство"

  for (it.SetBegin();!it.IsEnd();it.Next()) //цикл по совместительствам (  it.CurKey() - внутр.код совместительства )
  {  
     long IDdoljn = CL.GetIDDoljn(it.CurKey());
     if (IDdoljn==KodDoljn)              //нашли подходящий код совм-ва, сразу возвращаем его   
     {
       Combine=it.CurKey();
       New_Comb=max(New_Comb, Combine+1);// чтоб не случилось New_Comb==Combine
       break;
     }     

     if (IDdoljn==0) MapPanel.Add(it.CurKey(),"("+IntCombineToExt(it.CurKey())+")- "+CL.GetName(it.CurKey()));
     New_Comb=max(New_Comb, it.CurKey()+1);
  }

  // если не нашли подходящую должность и должность основная и у осн.совместительства нет ID должности, 
  // то запишем в основное совм-во без вопросов
  if (!Combine && (Str_Cmp(TypeDoljn, "ОСН", " ")==0 || sovmesh))
  {
    if (CL.GetIDDoljn(CL.GetBaseID())==0)
    {
      Combine=CL.GetBaseID();
    }
  }
  // иначе, если есть совместительства с пустым кодом должности, то спросим пользователя
  if (!Combine && MapPanel.Size()>0)
  {

     MapPanel.Add(New_Comb,"Создать новое совместительство");

     int R_C=0;
     do
     {
        R_C=PanelValueFromMap(MapPanel,MapRez,5, Title);
        if (R_C==ESC && (AmbaMessageBox("Прервать разноску?","",MB_YESNO|MB_ICONQUESTION|MB_DEFBUTTON2, 0)==IDYES) ) 
        {
           throw 0;   
        }
     } while (R_C==ESC);

     MapRez.InitIterator();
     Combine=atoi(MapRez.GetCurKey());
  }

  if (!Combine || Combine==New_Comb) 
  {                             //создаем новое совместительство
     Combine=AddNewCombine(0);
     CL.SetName(Combine,NameDoljn);
     CL.SetPodr(Combine,Podr);
     if (CL.GetKodAccess(1)==0)  //новый ЛС
        CL.SetKodAccess(Combine,0);

  }
  else
  {
    int PodrCL=CL.GetPodr(Combine); // подразделение выбранного совм-ва
    if (!PodrCL)
    {                
      PodrCL=otdelKCH;
    }
    if (Podr && Podr!=PodrCL &&  // подразделение в персонале не совпадает с подразделением в АМБе для данной должности!
         !sovmesh )  //для совмещений проверку подразделения не делаем, т.к. теперь они разносятся на основную должность
    {
       char sMessage[512];
       if (Combine!=CL.GetBaseID() || CL.GetPodr(Combine)!=0) //совместительство неосновное или основное но у него указано другое подразделение
       {                         
          string NameSovm=CL.GetName(it.CurKey());
          FreeSpaceString(NameSovm, 3, "");
          sprintf(sMessage, "У лицевого счета %s для должности \"%s\" в АМБе выбрано совместительство \"%s\""
             ". НО подразделение этого совместительства (%d) не совпадает "
             "с подразделением в Контур-Персонал (%d). Заменить подразделение у совместительства?" ,
              Name, NameDoljn, NameSovm, PodrCL, Podr);
       }
       else
         sprintf(sMessage, "%s Подразделение лицевого счета (%d) не совпадает "
          "с подразделением в Контур-Персонал (%d). Заменить подразделение в этом ЛС?" ,
           Name, PodrCL, Podr);
       int R_C=AmbaMessageBoxRaz(sMessage, "Внимание!",MB_YESNOCANCEL|MB_ICONQUESTION, 0);
       if (R_C==IDYES)
       {
         if (Combine!=CL.GetBaseID() || CL.GetPodr(Combine)!=0) CL.SetPodr(Combine,Podr);
         else 
         {               //для основного совместительства подразделение пишем в КЧ если до этого у основного совместительства не указано явно другого подразделения
             char s[10];
             sprintf(s, "%d", Podr);
             kch_in("podr",s);
         }
       }
    }
  }
  CL.SetIDDoljn(Combine,KodDoljn);
  
  Text_Text(pcT, IntCombineToExt(Combine), W);
  return pcT;
}

string GlobalTabelString;

ConvertTabelDay(str)  //преобразование двухсимвольного обозначения табеля из Т-12 в символ табеля АМБы
{
   return PriorityCall("UserConvertTabelDay","SysConvertTabelDay",str);
}

SysConvertTabelDay(str)  //преобразование двухсимвольного обозначения табеля из Т-12 в символ табеля АМБы
{
  for (int i=0;i<KolSimTab;i++)
   if (Str_Cmp(str, TB[i], " ")==0)
     return TA[i];
//  AmbaMessageBox("Неизвестный символ табеля", "Ошибка", 0, 0);
  return "0";
}

FirstTabelDay(str)                          //для разноски табеля, функция для первого дня табеля
{
 //Tabel_Sootv();
 GlobalTabelString=ConvertTabelDay(str);
}

MiddleTabelDay(str)                         //для разноски табеля, функция для 2..30 дня табеля
{
  GlobalTabelString+=ConvertTabelDay(str);
}

LastTabelDay_WriteTabel(str, month, Combine)   //последний день табеля 
{                                              // + запись собранного по дням табеля в ЛС
  GlobalTabelString+=ConvertTabelDay(str);     // Combine - внешний код совместительства
                                               // month - относительный месяц разноски
  int IDCombine=ExtCombineToInt(Combine);
  var tmp=CreateObject("TmpCurCombine");
  tmp.Init(IDCombine);

  int iWork=mtek;
  s50(month+mtek);
  stccpy(calm,GlobalTabelString,countday+1);
  s145(s120(mrasch),1);
  s50(iWork);

  tmp=0;
}

cpostsbor(CodAlim,W,A)
{
  double code = 0.0;
  double bDat;
  double eDat;

  int flag = 0;

  var mt = CreateObject("KMonth"); mt.SetMonth(mtek);

  var bm = CreateObject("KDate"); bm.SetDateIM(1,mt);
  var em = CreateObject("KDate"); em.SetDateIM(mt.CountDay(),mt);
  var bs = CreateObject("KDate");
  var es = CreateObject("KDate");

  for ( int row = 0; row < countkod; row++ )
  {
    bDat = GetBegDate(row); bs.SetDateD(bDat); // дата начала строки   
    eDat = GetEndDate(row); es.SetDateD(eDat); // дата конца строки   

    if ( bs.LE(em) && es.GE(bm) )
    {   
      code = GetCode(row);
     
      if ( 'С' != Sim_For_Intern_Cod(code,19) )
        continue;

      if ( nabs(atof(CodAlim) - GetBase(row)) < 0.001 )
      {
        code = Intern_To_ExternE(code);
        flag = 1;
        break;
      }
    }
  }

  if ( !flag )
    code = -1.0;

  char ts[12];
  sprintf(ts,"%*.*f",W,A,code);

  return static_cast_to_string(ts);
}

int StaticCodNUStudent=84;
IsItStudent()
{
   if ( !StaticCodNUStudent )
      return 0;
//   int rowkod[ROWMAX];
//   if ( poiskosnkod(StaticCodNUStudent,rowkod,0,CLL_TOTAL_SRC) )
//      return 1;

   int fs = 0;
   var BegPer = CreateObject("KMonth");
   var EndPer = CreateObject("KMonth");

   BegPer.SetDate(static_cast_to_string(Str_Date_0));
   EndPer.SetDate(static_cast_to_string(Str_Date_1));

   double dbeg = BegPer.GetYear() * 100 + BegPer.GetMonth() + 0.01;
   double dend = EndPer.GetYear() * 100 + EndPer.GetMonth() + EndPer.CountDay()/100.0;

   for ( int row = 0; row < countkod; row++ )
   {
     if ( static_cast_to_int(GetCode(row)) != StaticCodNUStudent ) continue;
     if ( GetEndDate(row) >= dbeg && GetBegDate(row) <= dend ) 
     {
       fs = 1; break;
     }
   }

   return fs;
}

GetNUStudent()
{
   if ( StaticCodNUStudent )
   {
      string s = GetLongNameNU(StaticCodNUStudent); // поставочный код вида для стипендии
      UpperString(s);
      if ( IsSubStrPresent(s,"СТИПЕН") )
         return StaticCodNUStudent;
      StaticCodNUStudent=0;
   }
   // если поставочный код не подошел, попробуем перебрать все виды в ТВХ
   for ( int row=0; row<cntplus; ++row )
   {
      string s = GetLongNameNU(kodnu1[row]);
      UpperString(s);
      if ( IsSubStrPresent(s,"СТИПЕН") )
         return StaticCodNUStudent=kodnu1[row];
   }
   return StaticCodNUStudent;
}

GetLongNameNU(code)
// Возвращает длинное имя вида Н-У, если имя пустая строка, возвращает короткое имя
{
   if ( code<0.5 ) return "";
   string Name = RTrimS(GetFullNameNU(code));
   if (Name == ""){
      int pos = poisk1(code, kodnu1, cntplus, 0);
      if (pos != -1){
         char buf[256];
         char func[256];
         sprintf(func,"НАИМ_ВИДА(%d)",Intern_To_Extern(code));
         CallFuncReceive(func,buf,255,0);
         buf[7]=0;
         Name = static_cast_to_string(buf);
      }
   }
   return Name;
}
GetShortNameNU(intCode)
{
   if ( intCode<0.5 ) return "";
   int pos = poisk1(intCode, kodnu1, cntplus, 0);
   if (pos != -1){
     char buf[256];
     char func[256];
     sprintf(func,"НАИМ_ВИДА(%d)",Intern_To_Extern(intCode));
     CallFuncReceive(func,buf,255,0);
     buf[7]=0;
     return to_string(buf);
   }
   return "";
}
//Единицы измерения базового значения
GetEdBz(intCode)
{
  int k=poisk1(atoi(intCode),kodnu1,cntplus,1);
  if ( k==-1 ) return "";
  string s=SubStr(GetNameKodNU(k),7);
  FreeSpaceString(s,3,"");
  return s;
}
RangePos1i5(rb,re,t,fv,w,a)
// Определяет число получателей пособий до 1.5 лет (1 пособие - 1 получатель) в диапазоне среднего заработка от rb до re (для формы ФСС-4)
// Возвращает число получателей для табл.3 - невменека, для табл.6 - вмененка
// Параметры: rb - нижняя граница диапазона;                                                                                      
//            re - верхняя граница диапазона;                                                                                     
//            t - тип выборки сумм (т.к. учитываются строки с ненулевыми суммами в периоде): 0-по принадлежности; 1-по начислению 
//            fv - 0-невмененка; 1-вмененка
//            w,a - соответственно размер и точность результата
{
  string rc = "";

  char arg[256];
  char str[256];
  char ts[256];

  var m1 = CreateObject("KMonth");
  var m2 = CreateObject("KMonth");

  m1.SetDate(static_cast_to_string(Str_Date_0));
  m2.SetDate(static_cast_to_string(Str_Date_1));

  int mbeg = m1.GetAbs(),
      mend = m2.GetAbs();

  var dbeg = CreateObject("KDate");
  var dend = CreateObject("KDate");

  dbeg.SetDateII(1, mbeg);
  dend.SetDateII(m2.CountDay(), mend);

  double code, proc, sm;
  double eps = 0.001;
  int vm = 0;

  int cv = 0, // число пособий по вмененке
      cn = 0; // число пособий по невмененке

  var de = CreateObject("KDate");
  var db = CreateObject("KDate");
    
  for ( int row = 0; row < countkod; row++ )
  { // цикл по строкам ЛС
    code = GetCode(row);

    if ( '3' != Sim_For_Intern_Cod(code,1101) ) continue;

    de.SetDateD(GetEndDate(row));
    if ( de.IsEqI(INVALID_DATE_VALUE) ) continue;
    if ( de.LT(dbeg) ) continue;
    db.SetDateD(GetBegDate(row));
    if ( db.GT(dend) ) continue;

    vm = IsVidVmenen(code); // 1 - вмененка; 0 - невмененка

//  int srz = GetBase(row) * 30.0 + 0.00000001;
    int srz = GetBase(row) * 30.4 + 0.00000001; // 08.10.2007
    if ( !(srz >= atoi(rb) && srz <= atoi(re)) ) continue;


    int fs = 0;
    int fp = 0;
    int fp100 = 1;

    for ( int mes = mbeg; mes <= mend; mes++ )
    { // цикл по месяцам
      sprintf(arg,"5,%d", mes); // находим первый день месяца
      sprintf(ts,"01.%s", R_DATA_EX(arg,str,7,4));  
      sprintf(arg,"d_vmenen,%s", ts);
      proc = atof(R_Face(arg,str,14,2));

//    if ( !atoi(t) ) sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_M,0);
//    else            sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_MV,0);
  
//    if ( nabs(sm) > eps ) 
//    {
        fs = 1;
        if ( proc > eps ) fp = 1;
        if ( proc < 100.0 ) fp100 = 0;
//    }
    }

    if ( fs )
    {
      if ( vm ) cv++;
      else
      {
        if ( fp100 ) cv++;
        else
        {
          if ( fp ) { cv++; cn++; }
          else cn++;
        }
      }
    }
  } // конец цикла по строкам ЛС
    
  if ( !atoi(fv) ) sprintf(ts,"%*d",atoi(w),cn);
  else             sprintf(ts,"%*d",atoi(w),cv);
  
  rc = static_cast_to_string(ts);

  return rc;
}


LsSrzPos1i5(fv,t,w,a)
// Возвращает сумму среднего заработка по последней ненулевой строке пособия до 1.5 лет (для формы ФСС-4, для табл.3 - невменека)
// Параметры: fv - 0 - невмененка, 1 - вмененка
//            t - тип выборки сумм (т.к. учитываются строки с ненулевыми суммами в периоде): 0-по принадлежности; 1-по начислению 
//            w,a - соответственно размер и точность результата                                                                   
{
  string rc = "";

  char arg[256];
  char str[256];
  char ts[256];

  var m1 = CreateObject("KMonth");
  var m2 = CreateObject("KMonth");

  m1.SetDate(static_cast_to_string(Str_Date_0));
  m2.SetDate(static_cast_to_string(Str_Date_1));

  int mbeg = m1.GetAbs(),
      mend = m2.GetAbs();

  var dbeg = CreateObject("KDate");
  var dend = CreateObject("KDate");

  dbeg.SetDateII(1, mbeg);
  dend.SetDateII(m2.CountDay(), mend);

  double code, proc, sm;
  double eps = 0.001;
  int vm = 0;

  int cv = 0, // вмененка
      cn = 0; // невмененка

  int cmax = 100;
  int cs = 0; // фактическое число строк

  int    sum[cmax]; // сумма среднего заработка
  double beg[cmax]; // дата начала строки

  var db = CreateObject("KDate");
  var de = CreateObject("KDate");
    
  for ( int row = 0; row < countkod; row++ )
  { // цикл по строкам ЛС
    code = GetCode(row);

    if ( '3' != Sim_For_Intern_Cod(code,1101) ) continue;

    de.SetDateD(GetEndDate(row));
    if ( de.IsEqI(INVALID_DATE_VALUE) ) continue; // отбрасываем пересчетные строки
    db.SetDateD(GetBegDate(row));

    vm = IsVidVmenen(code); // 1 - вмененка; 0 - невмененка

    int srz = GetBase(row) * 30.4 + 0.00000001;
    if ( !srz ) continue;

    int fs = 0;
    int fp = 0;
    int fp100 = 1;

    sm = 0.0;

    for ( int mes = mbeg; mes <= mend; mes++ )
    { // цикл по месяцам
      sprintf(arg,"5,%d", mes); // находим первый день месяца
      sprintf(ts,"01.%s", R_DATA_EX(arg,str,7,4));  
      sprintf(arg,"d_vmenen,%s", ts);
      proc = atof(R_Face(arg,str,14,2));

      if ( !atoi(t) ) sm += CashSumm(0,code,mes,mes,32,CL_EXACT|CL_M,0);
      else            sm += CashSumm(0,code,mes,mes,32,CL_EXACT|CL_MV,0);
  
//    if ( nabs(sm) > eps ) 
//    {
        fs = 1;
        if ( proc > eps ) fp = 1;
        if ( proc < 100.0 ) fp100 = 0;
//    }
    }

    if ( (de.LT(dbeg) || db.GT(dend)) && nabs(sm) < eps ) continue;

    if ( fs )
    {
      if ( vm ) cv = 1;
      else
      {
        if ( fp100 ) cv = 1;
        else
        {
          if ( fp ) { cv = 1; cn = 1; }
          else cn = 1;
        }
      }

      if ( !fv )
      { // невмененка
        if ( cn )
        {
          sum[cs] = srz;
          beg[cs] = GetBegDate(row);
          cs++;
        }
      }
      else
      { // вмененка
        if ( cv )
        {
          sum[cs] = srz;
          beg[cs] = GetBegDate(row);
          cs++;
        }
      }
    }

    cn = 0; cv = 0;

  } // конец цикла по строкам ЛС

  int rez = 0;

  if ( cs )
  {
    int max = 0;

    for ( int i = 1; i < cs; i++ )
    {
      if ( beg[max] < beg[i] ) max = i;
    }

    rez = sum[max];
  }
    
  sprintf(ts,"%*d",atoi(w),rez);
  
  rc = static_cast_to_string(ts);

  return rc;
}

// Функция по относительному месяцы выдает часовую ставку
R_NHour2(MOtn)
{
   int m=atoi(MOtn);
   char f[256];
   sprintf(f,"R_NHour(%d)",m);
   char B[256];
   if ( MOtn > 8)
   {
      return 0;
   }
   else
   {
      CallFuncReceive(f,B,255,2); 
      return atof(B);
   }
}

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

//int cFssLn = 24;
int cFssLn = 26;
var FssSocLines[cFssLn];
int cntFssColumns = 14;
var FssSocLinesMonth[cFssLn][cntFssColumns];
string StrFssSim = "";
double D15S[12]; // ???
double F15S1[6];
double F15S2[6];
double F15S3[6];
int F4FSS2009 = 1;
double FSS4_VREM[3];
double FSS4_VRES[3];
int fFSS4_VREM = 0;

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

InitPaySocStr()
{
  for ( int i = 0; i < cFssLn; i++ )
  {
     FssSocLines[i] = "";
     for ( int m=0; m<cntFssColumns; ++m ) FssSocLinesMonth[i][m]="";
  }
  StrFssSim = "";
  return 0;
}

ReadFssLine(Pay)
{
  char fsr[256]; fsr = StrFssSim; // FreeSpaceString(fsr,3,"");
  int cpay = strlen(fsr);
  int idxp = -1;

  for ( int i = 0; i < cpay; i++ )
  {
    if ( Pay == fsr[i] ) { idxp = i; break; } // если символ есть в списке, запоминаем и выходим из цикла
  }

  if ( -1 == idxp ) return -1;
  return FssSocLines[idxp];
}

ReadFssLineMonth(Pays,NumMonth)
{
  // Информация исходно собирается отдельно по каждой разновидности пособий
  // в таблицу выбрать можно как по отдельному виду пособий так и по набору однотипных пособий
    
  if ( NumMonth<0 || NumMonth>13 ) return -1;

  char fsr[256]; fsr=StrFssSim; // FreeSpaceString(fsr,3,"");
  char fsrPay[256]; sprintf(fsrPay,"%.255s",Pays); FreeSpaceString(fsrPay,3,"");
  int cpay = strlen(fsr);
  int cPays = strlen(fsrPay);
  if ( cPays<1 ) return -1;

  // Интересует информация об одном пособии - уже все готово
  if ( cPays==1 )
  {
     int idxp = -1;
     for ( int i = 0; i < cpay; i++ )
     {
       if ( fsrPay[0] == fsr[i] ) { idxp = i; break; } // если символ есть в списке, запоминаем и выходим из цикла
     }
     if ( -1 == idxp ) return -1;
     return FssSocLinesMonth[idxp][NumMonth];
  }
  // Если интересует информация по набору пособий - делаем объединение
  int cntPartsMax=6;
  double Parts[cntPartsMax];
  for ( int i=0; i<cntPartsMax; ++i ) Parts[i]=0.;
  var Razb = CreateObject("ParamFuncRW");
  int MaxParts=3;
  bool bExist = false;
  for ( int j=0; j<cPays; ++j )
  {
     int idxp = -1;
     for ( int i = 0; i < cpay; i++ )
     {
       if ( fsrPay[j] == fsr[i] ) { idxp = i; break; } // если символ есть в списке, запоминаем и выходим из цикла
     }
     if ( idxp==-1 ) continue;
     bExist = true;
     Razb.IInitial1(FssSocLinesMonth[idxp][NumMonth],",",cntPartsMax);
     if ( MaxParts<Razb.Count() )
     {
        MaxParts=Razb.Count();
        if ( MaxParts>cntPartsMax ) MaxParts=cntPartsMax;
     }

     for ( int idxv=0; idxv<MaxParts && idxv<Razb.Count(); ++idxv )
        Parts[idxv]+=atof(Razb.Get(idxv));
  }
  if ( !bExist ) return -1;
  string rez="";
  char ts[256];
  for ( int idxParts=0; idxParts<MaxParts; ++idxParts )
  {
     // РВ общее, сумма всего и сумма на второго - вещественные, остальное - целое
     if ( idxParts==1 || idxParts==2 || idxParts==5 )
     {
        sprintf(ts,"%14.2f",Parts[idxParts]); FreeSpaceString(ts,3,""); 
        rez = rez + "," + ts;
     }
     else
     {
        sprintf(ts,"%d",  static_cast_to_int(Parts[idxParts]+0.00001)); FreeSpaceString(ts,3,"");
        if ( idxParts ) rez += ",";
        rez += ts;
     }
  }
  return rez;
}

AllPaySocStr(Sim,Src,Typ)
//=============================================================================================
// Выплаты на цели обязательного социального страхования
// Используется в таблицах справок по ФСС 
// pay: вид выплаты
//   9 - по временной нетрудоспособности     
//   2 - по беременности и родам
//   3 - по уходу за ребенком до 1.5 лет
//   4 - при рождении ребенка
//   5 - пособие на погребение
//   6 - по уходу за детьми-инвалидами
//   7 - пособие женщинам, вставшим на учет в ранние сроки беременности
//   8 - пособие при усыновлении ребенка
//   А - детские оздоровительные лагеря
//   Б - санаторные оздоровительные лагеря
//   В - возмещещение командировочных расходов лицам, сопровождающим детей в детские санаторные
//       оздоровительные лагеря
//   Г - выплата денежной компенсации в случае невозможности предоставления путевки
// Src: главный источник финансирования ЛС
// Typ: тип выборки данных 0 - по месяцу принадлежности; 1 - по месяцу начисления  
// Ver: 1 - версия АМБы с функцией IsVidVmenen(); 0 - версия без данной функции
// Возвращает значение в виде списка: число случаев, дней, сумма, - для невмененного дохода
//                                    число случаев, дней, сумма  - для вмененного дохода
//                                    число случаев, дней, сумма, - для невмененного дохода (совместительство)
//                                    число случаев, дней, сумма  - для вмененного дохода   (совместительство)
// 5,31.00,30095.93,0,0,0.00,1,3,8000.00,0,0,0.00, 0,0,0.00,0,0,0.00,0,0,0.00,0,0,0.00
// Для пособий до 1.5 лет формат другой (он в двойном размере: на первого ребенка и на второго)
// 6,180.00,23540.00,0,0,0.00,2,62,7908.62,0,0,0.00,    2,62,9500.00,0,0,0.00,1,28,3065.69,0,0,0.00,1,28,3065.69,0,0,0.00
// 6,172.00,24539.31,0,0,0.00,2,62,7908.62,0,0,0.00,    2,62,9500.00,0,0,0.00,1,28,3065.69,0,0,0.00,1,20,4065.00,0,0,0.00
//=============================================================================================
{
  StrFssSim = static_cast_to_string(Sim);
  FreeSpaceString(StrFssSim,3,"");
  char fsr[256]; fsr = StrFssSim;
  char pay;
  int cpay = strlen(fsr);

  char arg[1024];
  char str[1024];
  char ts[1024];

  double eps  = 0.001;

  var m1 = CreateObject("KMonth");
  var m2 = CreateObject("KMonth");

  m1.SetDate(static_cast_to_string(Str_Date_0));
  m2.SetDate(static_cast_to_string(Str_Date_1));
  // Определимся с месяцами квартала
  var FirstMonthQuarter = KDateFromInt(GetFirstMonthQuarterAbs(m2));
  int qm1 = FirstMonthQuarter.GetMonth();
  int qm2 = qm1+1, qm3 = qm1+2;

  int mbeg = m1.GetAbs(),
      mend = m2.GetAbs();

  var dbeg = CreateObject("KDate");
  var dend = CreateObject("KDate");

  dbeg.SetDateII(1, mbeg);
  dend.SetDateII(m2.CountDay(), mend);

  // В помесячной разбивке в нулевом индексе хранится сумма, как и раньше
  // (по невмененке, основному месту работы и т.п., т.е. со всеми условиями выделения сумм)
  // В индексах 1-12 хранится помесячная сумма без всякого выделения т.е. всего по работнику
  // В индексе 13 - сумма на начало квартала
  int cnt[cFssLn][cntFssColumns];     // число случаев с помесячной разбивкой
  double dni[cFssLn][cntFssColumns];  // время с помесячной разбивкой
  double sum[cFssLn][cntFssColumns]; // сумма с помесячной разбивкой

  int cnt1[cFssLn][cntFssColumns];
  int dni1[cFssLn][cntFssColumns];
  double sum1[cFssLn][cntFssColumns];

  int cnt2[cFssLn][cntFssColumns];
  int dni2[cFssLn][cntFssColumns];
  double sum2[cFssLn][cntFssColumns];

  // Совместительства
  int cnts[cFssLn]; 
  int dnis[cFssLn]; 
  double sums[cFssLn];
  // вмененка
  int cnv[cFssLn]; 
  int dnv[cFssLn]; 
  double svm[cFssLn];
  // вмененка на совместительстве
  int cnvs[cFssLn];
  int dnvs[cFssLn];
  double svms[cFssLn];
  // вмененка по второму ребенку
  int cnv2[cFssLn]; 
  int dnv2[cFssLn]; 
  double svm2[cFssLn];

  for ( int i = 0; i < cFssLn; i++ )
  {
     for ( int idxm=0; idxm<cntFssColumns; ++idxm )
     {
        cnt[i][idxm] = 0;
        dni[i][idxm] = 0.0;
        sum[i][idxm] = 0.0;
        cnt1[i][idxm] = 0;
        dni1[i][idxm] = 0;
        sum1[i][idxm] = 0.0;
        cnt2[i][idxm] = 0;
        dni2[i][idxm] = 0;
        sum2[i][idxm] = 0.0;
     }

    cnts[i] = 0;
    dnis[i] = 0;
    cnv[i] = 0; cnvs[i] = 0; cnv2[i] = 0; 
    dnv[i] = 0; dnvs[i] = 0; dnv2[i] = 0; 

    svm[i] = 0.0;
    sums[i] = 0.0;
    svms[i] = 0.0;
    svm2[i] = 0.0;
  }

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

  FSS4_VREM[0] = 0.0;
  FSS4_VREM[1] = 0.0;
  FSS4_VREM[2] = 0.0;

  FSS4_VRES[0] = 0.0;
  FSS4_VRES[1] = 0.0;
  FSS4_VRES[2] = 0.0;

  fFSS4_VREM = 0;

//int VREM[99];
  var VREM;
  int cntVREM = 0;

//R_Tax(static_cast_to_string("4,1,*,*,*,*,Ц"),str,14,2);
  if ( IsEmpty(_VPStatusFSS) )
     str = static_cast_to_string(R_Tax(static_cast_to_string("option,VRPRB_STAT"),arg,255,0));
  else str = _VPStatusFSS;
  FreeSpaceString(str,3,"");
 
//if ( strlen(str) )
//{
//  var fp = CreateObject("ParamFuncRW");
//  var fp1 = CreateObject("ParamFuncRW");
//  fp.IInitial(static_cast_to_string(str),",",99);
//  int cl = fp.Count();
//  int cl1 = 0;
//
//  for ( int i = 0; i < cl; i++ )
//  {
//    fp1.IInitial(fp.Get(i),"-",99);
//    cl1 = fp1.Count();
//    if ( cl1 < 2 )
//    {
//      VREM[cntVREM] = atoi(fp.Get(i));
//      cntVREM++;
//    }
//    else
//    {
//      for ( int j = atoi(fp1.Get(0)); j <= atoi(fp1.Get(1)); j++ )
//      {
//        VREM[cntVREM] = j;
//        cntVREM++;
//      }
//    }
//  }
//}

  // заполняем массив VREM статусов временно пребывающих, cntVREM - количество статусов ВП
  cntVREM = ( str == "0" ) ? 0 : ListNUToSafeArray(str,',',VREM); // проверка на "0" - на случай если при отсутствии 238 алгоритма функция читающая настройку вернет ноль

  int idxp = -1; // номер соц.выплаты

  char src[50]; sprintf(src,"%s", static_cast_to_string(Src)); FreeSpaceString(src,3,"");

////////////////////////////////////////////////////////////////////////////////////////////
        
  double code, proc, sm;
  double mproc;

//int rv = 0;
  double rv = 0.0;
  int vm = 0;

  int cntvid = 0; // реальное число строк пособий до 1.5 лет
  int cntmax = 100;

  double code3[cntmax],
         dbeg3[cntmax];

  int flag3[cntmax];
  int nreb3[cntmax];

  int flag = 0;

  kch_from("det",str);
  int cntdet = atoi(str);

////////////////////////////////////////////////////////////////
// Обрабатываем пособия до 1.5 лет на предмет какие из них первые а какие вторые

  for ( int row = 0; row < countkod; row++ )
  { // цикл по строкам ЛС
    code = GetCode(row);

    var de = CreateObject("KDate");
    de.SetDateD(GetEndDate(row));
    if ( de.IsEqI(INVALID_DATE_VALUE) ) continue;
    if ( '3' != Sim_For_Intern_Cod(code,1101) ) continue;
    if ( cntmax <= cntvid ) continue;


    code3[cntvid] = code;
    dbeg3[cntvid] = GetBegDate(row);
    flag3[cntvid] = 1;
  
    Rkv_from(code,"нребенка",ts,str);
    nreb3[cntvid] = atoi(str);
  
    cntvid++;
  }
  
  // теперь посмотрим что мы насобирали и расставим флажки
  if ( cntdet > 1 )
  {
    bool bFirst = false;
    for ( int i = 0; i < cntvid; i++ ) 
    {
      if ( nreb3[i] == 1 )
      {
         bFirst = true;
         continue;
      }
      flag3[i] = 2; // в случае если детей больше чем строк считаем что те что в строках младшие
    }

    if ( !bFirst && cntdet <= cntvid && cntvid) 
    {
      // теперь найдем запись достойную первого флажка
      {
        // найдем запись с минимальной датой начала
        double dmin = dbeg3[0];
        int zmin = 0;
  
        for ( int i = 0; i < cntvid; i++ )
        {
          if ( nreb3[i] >= 1 ) continue;
          if ( dbeg3[i] - dmin < eps )
          {
            dmin = dbeg3[i]; // минимальная дата начала
            zmin = i;        // номер записи с минимальной датой начала
          }
        }
  
        if ( zmin>=0 )
        {
           // среди записей с минимальной датой найдем запись с минимальным расширением
           int ikod = code3[zmin];
           sprintf(str,"%5.0f",(code3[zmin]-ikod*1.0)*100.0);
           int extmin = atoi(str);
     
           for ( int i = 0; i < cntvid; i++ )
           {
             if ( nreb3[i] >= 1 ) continue;
             if ( nabs(dbeg3[i] - dmin) > eps ) continue;
     
             ikod = code3[i];
             sprintf(str,"%5.0f",(code3[i]-ikod*1.0)*100.0);
             int te = atoi(str);
     
             if ( te < extmin ) 
             {
               extmin = te;
               zmin = i;
             }
           }
     
           // найденной записи отдадим первый флажок
           flag3[zmin] = 1;
        }
      }
    }
  }
////////////////////////////////////////////////////////////////////////

// beg Чернобыльцы /////////////////////////////////////////////////////
//
  for ( int i = 0; i < 6; i++ ) 
  {
    F15S1[i] = 0.0;
    F15S2[i] = 0.0;
    F15S3[i] = 0.0;
  }

  int cntvidf = 0; // реальное число строк пособий

  double code3f[cntmax],
         dbeg3f[cntmax];

  int flag3f[cntmax];
  int nreb3f[cntmax];

  int flagf = 0;

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

  for ( int row = 0; row < countkod; row++ )
  { // цикл по строкам ЛС
    code = GetCode(row);

    var de = CreateObject("KDate");
    de.SetDateD(GetEndDate(row));
    if ( de.IsEqI(INVALID_DATE_VALUE) ) continue;

    if ( !( 'Э' == Sim_For_Intern_Cod(code,1101) 
         || 'Ю' == Sim_For_Intern_Cod(code,1101) 
         || 'Я' == Sim_For_Intern_Cod(code,1101) )
       ) continue;

    if ( cntmax <= cntvidf ) continue;

    code3f[cntvidf] = code;
    dbeg3f[cntvidf] = GetBegDate(row);
    flag3f[cntvidf] = 1;
  
    Rkv_from(code,"нребенка",ts,str);
    nreb3f[cntvid] = atoi(str);
  
    cntvidf++;
  }
  
  // теперь посмотрим что мы насобирали и расставим флажки
  if ( cntdet > 1 )
  {
    bool bFirst = false;
    for ( int i = 0; i < cntvidf; i++ ) 
    {
      if ( nreb3f[i] == 1 )
      {
         bFirst = true;
         continue;
      }
      flag3f[i] = 2; // в случае если детей больше чем строк считаем что те что в строках младшие
    }

    if ( !bFirst && cntdet <= cntvidf && cntvidf) 
    {
      // теперь найдем запись достойную первого флажка
      {
        // найдем запись с минимальной датой начала
        double dmin = dbeg3f[0];
        int zmin = 0;
  
        for ( int i = 0; i < cntvidf; i++ )
        {
          if ( nreb3f[i] >= 1 ) continue;
          if ( dbeg3f[i] - dmin < eps )
          {
            dmin = dbeg3f[i]; // минимальная дата начала
            zmin = i;        // номер записи с минимальной датой начала
          }
        }
  
        if ( zmin>=0 )
        {
           // среди записей с минимальной датой найдем запись с минимальным расширением
           int ikod = code3f[zmin];
           sprintf(str,"%5.0f",(code3f[zmin]-ikod*1.0)*100.0);
           int extmin = atoi(str);
     
           for ( int i = 0; i < cntvidf; i++ )
           {
             if ( nreb3f[i] >= 1 ) continue;
             if ( nabs(dbeg3f[i] - dmin) > eps ) continue;
     
             ikod = code3f[i];
             sprintf(str,"%5.0f",(code3f[i]-ikod*1.0)*100.0);
             int te = atoi(str);
     
             if ( te < extmin ) 
             {
               extmin = te;
               zmin = i;
             }
           }
     
           // найденной записи отдадим первый флажок
           flag3f[zmin] = 1;
        }
      }
    }
  }
//
// end Чернобыльцы ////////////////////////////////////////////////////

  var de = CreateObject("KDate"); // дата конца строки
  var db = CreateObject("KDate"); // дата начала строки

  int tmpSovm = 0;

  double daysDetInv = 0.0;
  int flagRvDetInv = GetCommonCnfInt("TypeRvDI","rsv2017");; // 0 - из табеля; 1 - из строк вида НУ

  for ( int mes = mbeg; mes <= mend; mes++ )
  { // цикл по месяцам
    var mb = CreateObject("KMonth");
    mb.SetMonth(mes);
    int month = mb.GetMonth();

    arg = "0," + static_cast_to_string(mes);
    int tmes = atoi(R_DATA_EX(arg,str,10,0)); // номер месяца в году для FssSocPays[]

    sprintf(arg,"5,%d", mes); // находим первый день месяца

    if ( mes >= 313 ) // c 01.2014
      sprintf(ts,"%04d%02d.%02d", mb.GetYear(), mb.GetMonth(), mb.CountDay()); // последний день месяца
    else              
      sprintf(ts,"01.%s", R_DATA_EX(arg,str,7,4)); // первый день месяца 

    sprintf(arg,"d_vmenen,%s", ts);
    proc = atof(R_Face(arg,str,14,2));
    // Если задан процент в КЧ, то корректно пока можно разделять
    // только если для вмененки задан отдельный набор видов б/л
    // поэтому зануляем здесь процент, за исключением 100%
    if ( proc<100 || mbeg>276)
       proc=0;
    mproc = proc;

    sprintf(arg,"inc_type,%s", ts);
    int sovm1 = atoi(R_Face(arg,str,14,0)); // 1 - совместительство

    sprintf(arg,"kod_rab,%s", ts);

    int sovm2 = atoi(R_Face(arg,str,14,0)); // 4 - совместительство

    sprintf(arg,"status2,%s", ts);
    int fSTAT2 = atoi(R_Face(arg,str,14,0)); // статус страховых взносов

    fFSS4_VREM = 0;
    for ( int j = 0; j < cntVREM; j++ ) { if ( fSTAT2 == atoi(VREM[j]) ) fFSS4_VREM = 1; }

    int sovm = 0;

//  if ( 1 == sovm1 || 4 == sovm2 ) sovm = 1;
    if ( 4 == sovm2 || 9 == sovm2 ) sovm = 1;

    int ckod = countkod + 1;
    int ck = 0; // ральное количество строк

    double COD[ckod];
    double SUM[ckod];
    double  RV[ckod];                                              
    char   SRC[ckod];
    int     VM[ckod];
    int    SOV[ckod];
    char   PAY[ckod];

    for ( int i = 0; i < ckod; i++ )
    {
      COD[i] = 0.0;
      SUM[i] = 0.0;
       RV[i] = 0.0;
      SRC[i] = 0;  
       VM[i] = 0;
      SOV[i] = 0;
    }

    int flagDetInv = 0;
    double rvDetInv = 0.0;

    for ( int row = 0; row < countkod; row++ )
    { // цикл по строкам ЛС
      code = GetCode(row);
      pay = Sim_For_Intern_Cod(code,1101); // читаем символ из 2ст.ТВХ для сводов

      idxp = -1;

      for ( int i = 0; i < cpay; i++ )
      {
        if ( pay == fsr[i] ) { idxp = i; break; } // если символ есть в списке, запоминаем и выходим из цикла
      }

      if ( -1 == idxp ) continue; // если символа нет в списке значит код не наш

      de.SetDateD(GetEndDate(row));
      if ( de.IsEqI(INVALID_DATE_VALUE) ) continue; // пропускаем пересчетные стороки
//    if ( de.LT(dbeg) ) continue;
//    db.SetDateD(GetBegDate(row));
//    if ( db.GT(dend) ) continue;

      proc = mproc;

      // с 2011 года выделять спец.режимы не требуется!
      vm = mbeg>276?0:IsVidVmenen(code); // 1 - вмененка; 0 - невмененка

      edType = Typ;
      edMv = mes;

      if ( !atoi(Typ) ) sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_M,0);
      else {            sm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_MV,0);
                        edSumm = CashSumm(0,code,mes,mes,32,CL_EXACT|CL_M,0);
//                      edSumm = CollectSumm(code,mes,mes,CL_M|CL_MV|CL_EXACT);
                        edCode = code;
      }

      if ( !atoi(Typ) ) rv = CashSumm(0,code,mes,mes,42,CL_EXACT|CL_M,0);
      else              rv = CashSumm(0,code,mes,mes,42,CL_EXACT|CL_MV,0);

      if ( pay == '6' ) // дети-инвалиды
      {
         if ( 0 == flagRvDetInv )
         {
            if ( !flagDetInv )
            {
               flagDetInv = 1;
               char simDetInv[9]; 
               simDetInv = "И"; // по-умолчанию по И, но можно переопределить через первый параметр алгоритма вида
               struct Struct_Alg Work;
               Get_AlgWithParam(Work,atoi(code));
               
               if( Work.Count_Par > 0 )
                  simDetInv = reinterpret_cast_to_string(Work.List_Par[0]);
               
               s50(mes);
               daysDetInv += dney_v_tab(simDetInv,calm,1,countday);
            
               s50(mrasch);
               rv = daysDetInv;
            }
         }
         else
         { // упрощенный способ борьбы с удвоением РВ по детям-инвалидам в случае если выплаты разбиты по совместительствам и т.п.
            if ( !flagDetInv )
            {
               if ( nabs(rv) > eps )
               {
                  flagDetInv = 1;
                  rvDetInv = rv;
               }
            }
            else
            {
               if ( nabs(rv) - nabs(rvDetInv) < eps )
               {
                  rv = 0.0;
               }
            }
         }
      }

      bool sfob = nabs(sm) > eps && pay == '9'; // запишем условие для случая когда надо проверить признак совместительства по дате строки вида

      // В том случае если вся должность относится к совместительской, вообще такой анализ не нужен. Точно так же в нем нет необходимости, если
      // выборка по месяцу принадлежности
      if ( sfob  )
      {
        tmpSovm = sovm; // запомним значение флага совместительства

        if (sovm1!=1 && atoi(Typ) )
        {
           // todo Очень странный анализ строчки больничного на совместительство через GetSomv
           // Он ориентируется на статус для среднесписочной численности действующий на дату начала строки или на дату конца строки. Но для больничных
           // дата конца строчки обычно заменяется, и ориентироваться на дату начала тоже странно. Потому что если в дату начала он был совместителем, то
           // все последующие суммы по этой строке будут считаться совместительскими?!
           int tso = GetSovm(row); // посмотрим совместительство на дату начала / конца строки
           // Отключил анализ. По факту сейчас совместительскими считаются любые суммы в рассматриваемом месяце если месяц относится к "совместительскому"
           // Если его включать, то "нормально" через анализ совместительства  на месяц принадлежности суммы, а не на даты строки. 
           if ( 0 && tso != -1 ) sovm = tso; // если одна из дат была задана берем вычисленное значение совместительства
        }
      }

      // "удержания" с выплат по уходу за детьми-инвалидами не собираем
      if ( '6' == pay  && !IsCodeNach(code) )
         sm=rv=0.;

      if ( nabs(sm) > eps &&  // если сумма не нулевая
           !vm            &&  // если это не источник и не совместительство на вмененке
           proc < eps     &&  // не 100% в КЧ (менее 100 ранее обнулили)
           ( pay == '9' ||  // временная нетрудоспособность (обычный БЛ)
             pay == '2' ||  // по беременности и родам
             pay == '3' ||  // до 1.5 лет

             pay == 'Э' ||  // ежемесячные детские пособия Чернобыльцы
             pay == 'Ю' ||  // ежемесячные детские пособия Маяк
             pay == 'Я' ||  // ежемесячные детские пособия подразделения особого риска

             pay == 'Щ' ||  // БЛ Чернобыльцы
             pay == 'Ы' ||  // БЛ Маяк
             pay == 'Ь' ||  // БЛ подразделения особого риска
             pay == 'Ъ' ||  // БЛ Семипалатинский полигон

             pay == 'У' ||  // БЛ - Доп. выплаты
             pay == 'Ч' ||  // По беременности и родам - Доп. выплаты

             pay == '4' ||  // при рождении
             pay == '5' ||  // на погребение
             pay == '6' ||  // дети-инвалиды
             pay == '7' ||  // ранние сроки беременности
             pay == '8' ||  // на усыновление
             pay == 'А' ||  // детские оздоровительные лагеря
             pay == 'Б' ||  // санаторные оздоровительные лагеря
             pay == 'Д' ||  // детские санатории
             pay == 'В' ||  // возмещещение командировочных расходов
             pay == 'Г' ))  // полная (частичная) оплата путевок на санаторно-курортное лечение работников
      {
        FssSocPays[tmes-1] += sm;
      }

      int fmsrc = 0;
      sprintf(ts,"%c",IntSrcToExt(GetSrcOfCod(code)));
      if ( ts == src ) fmsrc = 1;

      if ( '3' == pay )
      {
//        for ( int i = 0; i < 12; i++ ) D15S[i] = 0.0;

        for ( int i = 0; i < cntvid; i++ )
        {
          if ( nabs(code-code3[i]) < eps ) flag = flag3[i];
        }
      }

      if ( 'Э' == pay || 'Ю' == pay || 'Я' == pay )
      {
        for ( int i = 0; i < cntvidf; i++ )
        {
          if ( nabs(code-code3f[i]) < eps ) flagf = flag3f[i];
        }
      }

      if ( 'Т' == pay || 'П' == pay || 'О' == pay )
      {
        vm = 0;
        proc = 0.0;
      }

      int BL_FB = 0; if ( 'Щ' == pay || 'Ы' == pay || 'Ь' == pay || 'Ъ' == pay || 'У' == pay || 'Ч' == pay ) BL_FB = 1;

      if ( '9' != pay  && '2' != pay  && '6' != pay && !BL_FB )
      {
        if ( nabs(sm) > eps )
        {
          aPaySocCount(month,cnt, // число случаев для невмененки                                                        
                       dni, // число дней для невмененки                                                           
                       sum, // сумма для невмененки                                                                
                       cnv, // число случаев для вмененки                                                          
                       dnv, // число дней для вмененки                                                             
                       svm, // сумма для вмененки                                                                  
                      cnts, // число случаев для невмененки (совместительство) (до 1.5 лет 1-й ребенок)
                      dnis, // число дней для невмененки    (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      sums, // сумма для невмененки         (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      cnvs, // число случаев для вмененки   (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      dnvs, // число дней для вмененки      (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      svms, // сумма для вмененки           (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      cnt2, // число случаев для невмененки (до 1.5 лет 2-й ребенок)
                      dni2, // число дней для невмененки    (до 1.5 лет 2-й ребенок)                                    
                      sum2, // сумма для невмененки         (до 1.5 лет 2-й ребенок)                                    
                      cnv2, // число случаев для вмененки   (до 1.5 лет 2-й ребенок)                                    
                      dnv2, // число дней для вмененки      (до 1.5 лет 2-й ребенок)                                    
                      svm2, // сумма для вмененки           (до 1.5 лет 2-й ребенок)                                    
                        sm, // сумма                                                                               
                        rv, // РВ                                                                                  
                        vm, // флаг принадлежности суммы к источнику или совместительству отмеченным как "вмененка"
                      proc, // % вмененного дохода из КЧ                                                           
                      sovm, // 1 - совместительство
                       pay, // символ соц.выплаты
                      flag, // флаг количества детей
                     flagf, // флаг количества детей Чернобыльцы
                      idxp,
                      cnt1,
                      dni1,
                      sum1);// индекс соцвыплаты  
                          
        }
      }
      else
      {
        if ( nabs(sm) > eps )
        {
          COD[ck] = code;
          SUM[ck] = sm;
           RV[ck] = rv;
          SRC[ck] = ts[0]; 
           VM[ck] = vm;
          PAY[ck] = pay;
          SOV[ck] = sovm;
              ck++;
        }
      }

      if ( sfob ) sovm = tmpSovm; // вернем прежнее значение признака совместительства

    } // конец цикла по строкам ЛС

//  if ( '9' == pay  || '2' == pay || '6' == pay )
    if ( ck )
    {
      for ( int i = 0; i < ck-1; i++ )
      {
        for ( int j = i+1; j < ck; j++ )
        {
          if ( nabs(RV[i] - RV[j]) < eps && VM[i] == VM[j] && PAY[i] == PAY[j] && SRC[i] != SRC[j] ) 
          {
            SUM[i] += SUM[j];
            SUM[j] = 0.0;
          }
        }
      }

      for ( int i = 0; i < ck; i++ )
      {
        pay = Sim_For_Intern_Cod(COD[i],1101); // читаем символ из 2ст.ТВХ для сводов
        idxp = -1;

        for ( int i = 0; i < cpay; i++ )
        {
          if ( pay == fsr[i] ) { idxp = i; break; } // если символ есть в списке, запоминаем и выходим из цикла
        }

        if ( -1 == idxp ) continue; // если символа нет в списке значит код не наш

        if ( nabs(SUM[i]) > eps )
        {
          sm = SUM[i];
          rv = RV[i];
          vm = VM[i];
          sovm = SOV[i];

          aPaySocCount(month,cnt, // число случаев для невмененки                                                        
                       dni, // число дней для невмененки                                                           
                       sum, // сумма для невмененки                                                                
                       cnv, // число случаев для вмененки                                                          
                       dnv, // число дней для вмененки                                                             
                       svm, // сумма для вмененки                                                                  
                      cnts, // число случаев для невмененки (совместительство) (до 1.5 лет 1-й ребенок)
                      dnis, // число дней для невмененки    (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      sums, // сумма для невмененки         (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      cnvs, // число случаев для вмененки   (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      dnvs, // число дней для вмененки      (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      svms, // сумма для вмененки           (совместительство) (до 1.5 лет 1-й ребенок)                                    
                      cnt2, // число случаев для невмененки (до 1.5 лет 2-й ребенок)
                      dni2, // число дней для невмененки    (до 1.5 лет 2-й ребенок)                                    
                      sum2, // сумма для невмененки         (до 1.5 лет 2-й ребенок)                                    
                      cnv2, // число случаев для вмененки   (до 1.5 лет 2-й ребенок)                                    
                      dnv2, // число дней для вмененки      (до 1.5 лет 2-й ребенок)                                    
                      svm2, // сумма для вмененки           (до 1.5 лет 2-й ребенок)                                    
                        sm, // сумма                                                                               
                        rv, // РВ                                                                                  
                        vm, // флаг принадлежности суммы к источнику или совместительству отмеченным как "вмененка"
                      proc, // % вмененного дохода из КЧ                                                           
                      sovm, // 1 - совместительство
                       pay, // символ соц.выплаты
                      flag, // флаг количества детей
                     flagf, // флаг количества детей Чернобыльцы
                      idxp,
                      cnt1,
                      dni1,
                      sum1);// индекс соцвыплаты  
        }
      }
    }
  } // конец цикла по месяцам

  string rez = "";

  // цикл по всем типам выплат
  for ( int i = 0; i < cpay; i++ )
  {
    bool b15 = ('3' == fsr[i] || 'Э' == fsr[i] || 'Ю' == fsr[i] || 'Я' == fsr[i]);

    // Для помесячных сумм храним пока в простом виде (только то, что касается "невмененки", на самом деле
    // это будет общая сумма, так как с некоторого времени (absm=276) вмененка не выделяется

    // Подитогов несколько: в целом за период и на начало квартала
    int cntTotal = 2;
    int totalcnt[cntTotal];
    double totaldni[cntTotal];
    double totalsum[cntTotal];
    int totalcnt2[cntTotal];
    int    totaldni2[cntTotal];
    double totalsum2[cntTotal];
    for ( int ii=0; ii<cntTotal; ++ii )
    {
      totalcnt[ii]=0;
      totaldni[ii]=0.0;
      totalsum[ii]=0.0;
      totalcnt2[ii]=0;
      totaldni2[ii]=0.0;
      totalsum2[ii]=0.0;
    }

    // Информация по месяцам в сокращенном виде (число случаев, дней, сумма). 
    // Для пособия до 1.5 лет разбита на две части (на первого и второго ребенка)
    for ( int m=m1.GetMonth(); m<=m2.GetMonth(); ++m )
    {
       // В нулевом индексе хранится не полная сумма, а с учетом наличия совместительства, вмененки и т.п.
       // поэтому для получения полной суммы - делаем суммирование
       if ( !b15 ) 
       {
          totalcnt[0]  += cnt[i][m];
          totaldni[0]  += dni[i][m];
          totalsum[0]  += sum[i][m];
       }
       else
       {
          totalcnt[0]  += cnt1[i][m];
          totaldni[0]  += dni1[i][m];
          totalsum[0]  += sum1[i][m];
       }
       // подытог за месяцы до начала квартала
       if ( m<qm1 )
       {
          if ( !b15 )
          {
             totalcnt[1]  += cnt[i][m];
             totaldni[1]  += dni[i][m];
             totalsum[1]  += sum[i][m];
          }
          else
          {
             totalcnt[1]  += cnt1[i][m];
             totaldni[1]  += dni1[i][m];
             totalsum[1]  += sum1[i][m];
          }
       }

       if ( !b15 ) 
          sprintf(ts,"%d,%.2f,%.2f",cnt[i][m],dni[i][m],sum[i][m]);
       else
       {
          sprintf(ts,"%d,%d,%.2f,%d,%d,%.2f",cnt1[i][m],dni1[i][m],sum1[i][m],cnt2[i][m],dni2[i][m],sum2[i][m]);
          totalcnt2[0] += cnt2[i][m];
          totaldni2[0] += dni2[i][m];
          totalsum2[0] += sum2[i][m];
          // подытог за месяцы до начала квартала
          if ( m<qm1 )
          {
             totalcnt2[1] += cnt2[i][m];
             totaldni2[1] += dni2[i][m];
             totalsum2[1] += sum2[i][m];
          }
       }
       FssSocLinesMonth[i][m]=rez=ts;
    }

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

    // Подитоги за период и "на начало квартала" 
    for ( int ii=0; ii<cntTotal; ++ii )
    {
       rez = "";
       // общий итог по выплате (случаев, дней, сумма)
       sprintf(ts,"%d,%.2f,%.2f",totalcnt[ii],totaldni[ii],totalsum[ii]);
       rez = ts;

       // Для пособия до 1.5 лет - итоги по второму ребенку
       if ( b15 )
       {
          sprintf(ts,",%d,%d,%.2f",totalcnt2[ii],totaldni2[ii],totalsum2[ii]);
          rez += ts;
       }
       // в нулевую строчку сохраняем итоги по всем месяцам, в 13 строчку - сумму на начало квартала
       FssSocLinesMonth[i][ii==1?13:0]=rez;
    }
//-------------------------------------------------------------------------------------------------------
    if ( fsr[i] == '6' ) 
    {
       if ( !flagRvDetInv ) dni[i][0] = daysDetInv; // дети-инвалиды, РВ из табеля
    }

    // суммарно за расмотренный период храним информацию в большем разрезе.
    // обычные (случаи, дни, сумма)
    // вмененка (случаи, дни, сумма)
    // совместительства (случаи, дни, сумма)
    // вмененка на совместительстве (случаи, дни, сумма)
    // второй ребенок (случаи, дни, сумма)
    // второй ребенок вмененка (случаи, дни, сумма) 
    sprintf(ts,"%d,%.2f,%.2f,%d,%d,%.2f,%d,%d,%.2f,%d,%d,%.2f,%d,%d,%.2f,%d,%d,%.2f",
                cnt[i][0],dni[i][0],sum[i][0],
                cnv[i],dnv[i],svm[i],
                cnts[i],dnis[i],sums[i],
                cnvs[i],dnvs[i],svms[i],
                cnt2[i][0],dni2[i][0],sum2[i][0],
                cnv2[i],dnv2[i],svm2[i]);
    
    rez = ts;

    // пособия до 1.5 лет (3 и ЭЮЯ (фед.бюджет) )  + обычные больничные (9)
    if ( fsr[i] == '3' || fsr[i] == 'Э' || fsr[i] == 'Ю' || fsr[i] == 'Я' || fsr[i] == '9' )
    {
       if ( fsr[i] == '9' ) // больничные
       {
           // дописываем информацию по временно пребывающим и совместительствам временно пребывающих (число случаев,дней, сумма)
           sprintf(ts,",%.0f,%.0f,%.2f,%.0f,%.0f,%.2f",
                   atof(FSS4_VREM[0]),atof(FSS4_VREM[1]),atof(FSS4_VREM[2]),
                   atof(FSS4_VRES[0]),atof(FSS4_VRES[1]),atof(FSS4_VRES[2]));

           rez += ts;
       }
       else if ( fsr[i] == '3' || fsr[i] == 'Э' || fsr[i] == 'Ю' || fsr[i] == 'Я' ) // пособия до 1.5 лет
       {
         // дописываем информацию по совместительствам (на 1 и 2 ребенка + выделенная вмененка)
         sprintf(ts,",%.0f,%.0f,%.2f,%.0f,%.0f,%.2f,%.0f,%.0f,%.2f,%.0f,%.0f,%.2f",
                 D15S[0],D15S[1],D15S[2],D15S[3],D15S[4],D15S[5],      // 1-ый ребенок
                 D15S[6],D15S[7],D15S[8],D15S[9],D15S[10],D15S[11]);   // 2-ой ребенок
         rez += ts;

         if ( fsr[i] == 'Э' ) // до 1.5 лет ЧАЭС
         {
           sprintf(ts,",%.0f,%.0f,%.2f,%.0f,%.0f,%.2f",
                       F15S1[0],F15S1[1],F15S1[2],F15S1[3],F15S1[4],F15S1[5]);
           rez += ts;
         }
         else if ( fsr[i] == 'Ю' ) // до 1.5 лет Маяк
         {
           sprintf(ts,",%.0f,%.0f,%.2f,%.0f,%.0f,%.2f",
                       F15S2[0],F15S2[1],F15S2[2],F15S2[3],F15S2[4],F15S2[5]);
           rez += ts;
         }
         else if ( fsr[i] == 'Я' ) // до 1.5 лет прочее
         {
           sprintf(ts,",%.0f,%.0f,%.2f,%.0f,%.0f,%.2f",
                       F15S3[0],F15S3[1],F15S3[2],F15S3[3],F15S3[4],F15S3[5]);
           rez += ts;
         }
       }
//-------------------------------------------------------------------------------------------------------
    }

    FssSocLines[i] = static_cast_to_string(rez);
  }

  return 0;
}

// var MapCombinesAreExternal = GetEmpty();
GetSovm(row)
// возвращает признак совместитель (1) или нет (0) по датам начала / конца строки
// если даты не заданы, возвращает -1
{
/*
   if ( !IsEmpty(MapCombinesAreExternal) )
   {
   }
*/   
   var dbs = CreateObject("KDate"); dbs.SetDateD(GetBegDate(row));
   var des = CreateObject("KDate"); des.SetDateD(GetEndDate(row));

   if ( !dbs.IsEqI(INVALID_DATE_VALUE) ) return GetSovmFl(dbs);
   else
   if ( !des.IsEqI(INVALID_DATE_VALUE) ) return GetSovmFl(des);

   return -1;
}

GetSovmFl(dat)
// возвращает признак совместитель (1) или нет (0) на дату (dat)
{
   char s1[512]; char s2[512]; 
   sprintf(s1,"kod_rab,%.2f",dat.GetDouble());
   int tt = atoi(R_Face(s1,s2,14,0));
   if ( 4 == tt || 9 == tt ) return 1; else return 0;
}

double edCode = 0.0;
double edSumm = 0.0; // сумма по месяцу принадлежности

int edType = 0; // тип выборки данных 0 - по месяцу принадлежности; 1 - по месяцу начисления  
int edMv = 0;


CountEdPay(pay,sm)
// pay - символ соц.выплаты
// sm  - сумма по месяцу начисления ( edType=1 )
{
  if ( !edType ) return 1;

  if ( nabs(sm-edSumm) < 0.001 ) return 1;
  if ( !( pay == '3' || // до 1.5 лет
          pay == '4' || // при рождении
          pay == '5' || // на погребение
          pay == '7'    // ранние сроки беременности
        ) 
     ) return 1;

  int rc = 0;
  int mend = mtek - 24;
  double sum1 = 0.0;
  double sum2 = 0.0;

  for ( int m = mtek + B2MES; m > mend; m-- )
  {
    sum1 = CollectSumm(edCode,m,edMv,CL_M|CL_MV|CL_EXACT);

    if ( nabs(sum1) > 0.001 ) 
    {
      if ( m == edMv ) rc++;
      else
      {
        sum2 = CollectSumm(edCode,m,m,CL_MV|CL_EXACT);
        if ( nabs(sum2) < 0.001 ) rc++;
      }
    }
  }

  return rc;
}


aPaySocCount(month,&cnt, // число случаев для невмененки
             &dni, // число дней для невмененки
             &sum, // сумма для невмененки
             &cnv, // число случаев для вмененки
             &dnv, // число дней для вмененки   
             &svm, // сумма для вмененки        
            &cnts, // число случаев для невмененки (совместительство)
            &dnis, // число дней для невмененки    (совместительство)
            &sums, // сумма для невмененки         (совместительство)
            &cnvs, // число случаев для вмененки   (совместительство)
            &dnvs, // число дней для вмененки      (совместительство)
            &svms, // сумма для вмененки           (совместительство)
            &cnt2, // число случаев для невмененки 
            &dni2, // число дней для невмененки    
            &sum2, // сумма для невмененки         
            &cnv2, // число случаев для вмененки   
            &dnv2, // число дней для вмененки      
            &svm2, // сумма для вмененки           
               sm, // сумма
               rv, // РВ
               vm, // флаг принадлежности суммы к источнику или совместительству отмеченным как "вмененка"
             proc, // % вмененного дохода из КЧ
             sovm, // 1 - совместительство
              pay, // символ соц.выплаты
             flag, // флаг количества детей
            flagf, // флаг количества детей Чернобыльцы
             idxp, // индекс соц.выплаты
            &cnt1,
            &dni1,
            &sum1
)
{
  double tmp, eps = 0.001;
  int cEdPay = CountEdPay(pay,sm);
  
  // Помесячно накапливаем общую сумму без всякого разделения!
  cnt[idxp][month] += cEdPay;  
  dni[idxp][month] += rv;      
  sum[idxp][month] += sm;      

  
  if ( flag && ('3' == pay || 'Э' == pay || 'Ю' == pay || 'Я' == pay) )
  {  
     if ( flag == 2 )
     { // До 1.5 лет 2-ой ребенок
       cnt2[idxp][month] += cEdPay;  
       dni2[idxp][month] += rv;      
       sum2[idxp][month] += sm;      
     }
     else
     { // До 1.5 лет 1-й ребенок
       cnt1[idxp][month] += cEdPay;  
       dni1[idxp][month] += rv;      
       sum1[idxp][month] += sm;      
     }
  }

  int BL_FB = 0; if ( 'Щ' == pay || 'Ы' == pay || 'Ь' == pay || 'Ъ' == pay || 'У' == pay || 'Ч' == pay ) BL_FB = 1;

  if ( nabs(sm) > eps )
  {
    if ( '9' == pay && fFSS4_VREM )
    {
      FSS4_VREM[0] += atof(cEdPay);
      FSS4_VREM[1] += atof(rv);
      FSS4_VREM[2] += atof(sm);

      if ( 1 == sovm )
      {
        FSS4_VRES[0] += atof(cEdPay);
        FSS4_VRES[1] += atof(rv);
        FSS4_VRES[2] += atof(sm);
      }

      return 0;
    }

    if ( BL_FB )
    {
      cnt[idxp][0] += cEdPay;
      dni[idxp][0] += rv; 
      sum[idxp][0] += sm; 

      if ( 1 == sovm )
      {
        cnts[idxp] += cEdPay;
        dnis[idxp] += rv;
        sums[idxp] += sm;
      }

      return 0;
    }

    if ( 'Э' == pay ) // ежемесячные детские пособия - Чернобыльцы
    {
      if ( 1 == flagf ) // 1-й ребенок
      {
        F15S1[0] += cEdPay;
        F15S1[1] += rv;
        F15S1[2] += sm;
      }
  
      if ( 2 == flagf ) // 2-й ребенок
      {
        F15S1[3] += cEdPay;
        F15S1[4] += rv;
        F15S1[5] += sm;
      }
    }

    if ( 'Ю' == pay ) // ежемесячные детские пособия - Маяк
    {
      if ( 1 == flagf ) // 1-й ребенок
      {
        F15S2[0] += cEdPay;
        F15S2[1] += rv;
        F15S2[2] += sm;
      }
  
      if ( 2 == flagf ) // 2-й ребенок
      {
        F15S2[3] += cEdPay;
        F15S2[4] += rv;
        F15S2[5] += sm;
      }
    }

    if ( 'Я' == pay ) // ежемесячные детские пособия - подразделения особого риска
    {
      if ( 1 == flagf ) // 1-й ребенок
      {
        F15S3[0] += cEdPay;
        F15S3[1] += rv;
        F15S3[2] += sm;
      }
  
      if ( 2 == flagf ) // 2-й ребенок
      {
        F15S3[3] += cEdPay;
        F15S3[4] += rv;
        F15S3[5] += sm;
      }
    }

    if ( !vm ) 
    { // невмененка
      if ( proc < eps )
      { // % вмененного дохода в КЧ нулевой
        cnt[idxp][0] += cEdPay;
        dni[idxp][0] += rv;    
        sum[idxp][0] += sm;    

        if ( '9' == pay || '2' == pay || 'П' == pay ) // по временной нетрудоспособности
        {
          if ( 1 == sovm )
          {
            cnts[idxp] += cEdPay;
            dnis[idxp] += rv;
            sums[idxp] += sm;
          }
        }

        if ( 'Т' == pay && 1 == sovm ) // Травма совместители
        {
          cnts[idxp] += cEdPay;
          dnis[idxp] += rv;
          sums[idxp] += sm;
        }

        if ( '3' == pay ) // до 1.5 лет
        {
          if ( !sovm || F4FSS2009 )
          {
            if ( 1 == flag ) // 1-й ребенок
            {
              cnts[idxp] += cEdPay;
              dnis[idxp] += rv;
              sums[idxp] += sm;
            }
    
            if ( 2 == flag ) // 2-й ребенок
            {
              cnt2[idxp][0] += cEdPay;
              dni2[idxp][0] += rv;
              sum2[idxp][0] += sm;
            }
          }
          else
          {
            if ( 1 == flag ) // 1-й ребенок
            {
              D15S[0] += cEdPay;
              D15S[1] += rv;
              D15S[2] += sm;

            }
    
            if ( 2 == flag ) // 2-й ребенок
            {
              D15S[6] += cEdPay;
              D15S[7] += rv;
              D15S[8] += sm;
            }
          }
        }
      }
  
      if ( proc > eps && proc < 99.999 )
      { // % вмененки в КЧ больше нуля и меньше 100
        tmp = sm * proc / 100.0; round( tmp ); 
        svm[idxp] += tmp;
        sum[idxp][0] += ( sm - tmp );
  
        cnt[idxp][0] += cEdPay;
        dni[idxp][0] += rv;    
        cnv[idxp] += cEdPay;
        dnv[idxp] += rv;

        if ( 1 == sovm && '3' != pay )
        {
          tmp = sm * proc / 100.0; round( tmp ); 
          svms[idxp] += tmp;
          sums[idxp] += ( sm - tmp );
  
          cnts[idxp] += cEdPay;
          dnis[idxp] += rv;
          cnvs[idxp] += cEdPay;
          dnvs[idxp] += rv;
        }

        if ( 1 == flag  && '3' == pay )
        {
          tmp = sm * proc / 100.0; round( tmp ); 

          if ( !sovm || F4FSS2009 )
          {
            svms[idxp] += tmp;
            sums[idxp] += ( sm - tmp );
  
            cnts[idxp] += cEdPay;
            dnis[idxp] += rv;
            cnvs[idxp] += cEdPay;
            dnvs[idxp] += rv;
          }
          else
          {
            D15S[5] += tmp;
            D15S[2] += ( sm - tmp );
  
            D15S[0] += cEdPay;
            D15S[2] += rv;
            D15S[3] += cEdPay;
            D15S[4] += rv;
          }
        }

        if ( 2 == flag && '3' == pay )
        {
          tmp = sm * proc / 100.0; round( tmp ); 

          if ( !sovm || F4FSS2009 )
          {
            svm2[idxp] += tmp;
            sum2[idxp][0] += ( sm - tmp );
  
            cnt2[idxp][0] += cEdPay;
            dni2[idxp][0] += rv;
            cnv2[idxp] += cEdPay;
            dnv2[idxp] += rv;
          }
          else
          {
            D15S[11] += tmp;
            D15S[ 8] += ( sm - tmp );
                
            D15S[ 6] += cEdPay;
            D15S[ 7] += rv;
            D15S[ 9] += cEdPay;
            D15S[10] += rv;
          }
        }
      }
  
      if ( proc > 99.999 )
      { // 100% вмененки в КЧ
        cnv[idxp] += cEdPay;
        dnv[idxp] += rv;
        svm[idxp] += sm;

        if ( 1 == sovm && '3' != pay )
        {
          cnvs[idxp] += cEdPay;
          dnvs[idxp] += rv;
          svms[idxp] += sm;
        }

        if ( 1 == flag && '3' == pay )
        {
          if ( !sovm || F4FSS2009 )
          {
            cnvs[idxp] += cEdPay;
            dnvs[idxp] += rv;
            svms[idxp] += sm;
          }
          else
          {
            D15S[3] += cEdPay;
            D15S[4] += rv;
            D15S[5] += sm;

          }
        }

        if ( 2 == flag && '3' == pay )
        {
          if ( !sovm || F4FSS2009 )
          {
            cnv2[idxp] += cEdPay;
            dnv2[idxp] += rv;
            svm2[idxp] += sm;
          }
          else
          {
            D15S[ 9] += cEdPay;
            D15S[10] += rv;
            D15S[11] += sm;
          }
        }
      }
    }
    else 
    { // вмененка
      cnv[idxp] += cEdPay;
      dnv[idxp] += rv;
      svm[idxp] += sm;

      if ( 1 == sovm && '3' != pay )
      {
        cnvs[idxp] += cEdPay;
        dnvs[idxp] += rv;
        svms[idxp] += sm;
      }

      if ( 1 == flag && '3' == pay )
      {
        if ( !sovm || F4FSS2009 )
        {
          cnvs[idxp] += cEdPay;
          dnvs[idxp] += rv;
          svms[idxp] += sm;
        }
        else
        {
          D15S[3] += cEdPay;
          D15S[4] += rv;
          D15S[5] += sm;
        }
      }

      if ( 2 == flag && '3' == pay )
      {
        if ( !sovm || F4FSS2009 )
        {
          cnv2[idxp] += cEdPay;
          dnv2[idxp] += rv;
          svm2[idxp] += sm;
        }
        else
        {
          D15S[ 9] += cEdPay;
          D15S[10] += rv;
          D15S[11] += sm;
        }
      }
    }
  }
  
  return 0;
}

CalcStrahStagT57(Dat,W)
{
  int len = 256;
  char Rez[len];
  int year = 0;
  int month = 0;

  var DatRas = CreateObject("KDate");
  DatRas.SetDate(static_cast_to_string(Dat));

  if ( !DatRas.IsEqI(INVALID_DATE_VALUE) )
  {
    char Str[81];
    GetKchValue("data_st",Str,80,DatRas);

    if ( !Str_Cmp(Str," "," ./%%") ) kch_from("data_rb",Str);  // дата приема на работу

    var DatStg = CreateObject("KDate");
    DatStg.SetDate(static_cast_to_string(Str));
    DatStg.ImproveDay();

    char Offs[len]; Offs = "";
    double Proc = 0.0;
    bool ZeroStag = false;

    if ( DatStg.IsEqI(INVALID_DATE_VALUE) )
    { // Если в КЧ не дата, то либо процент, либо стаж на определенную дату
      char StrDat[21];
      GetKchDate("data_st",StrDat,20,DatRas);
      DatStg.SetDate(static_cast_to_string(StrDat));
      DatStg.ImproveDay();

      if ( DatStg.IsEqI(INVALID_DATE_VALUE) ) ZeroStag = true;

      if ( !reinterpret_cast_to_long(strrchr(Str,'%')) ) // if ( !strchr(Str,'%') ) 
         Offs = Str;
      else
         Proc = atof(Str);
    }

    if ( !ZeroStag )
    {
       int day = 0;
       int TypeCalcStrSt = 0; // GetCommonCnfInt("CalcStrSt",BL_CNF_TABLE);
       CalculateStag(DatStg,DatRas,year,month,day,TypeCalcStrSt,Offs);
    }
  }

  char ts[len];
  sprintf(ts,"%2dг%2dм",year,month);
  sprintf(Rez,"%*.*s",W,W,ts);

  return static_cast_to_string(Rez);
}

FlagKchInvMes(m)
// m - месяц (относительный)
// ф-ция возвращает 1 в случае если в данном месяце (на последний день месяца)
// человек был инвалидом 1, 2 или 3 группы, в противном случае возвращается 0
{
  char arg[256];
  char str[256];

  sprintf(arg,"7,%d",atoi(m));
  var me = CreateObject("KMonth");
  me.SetMonth(atoi(R_DATA_EX(arg,str,10,0)));
  sprintf(str,"%02d.%02d.%4d",me.CountDay(),me.GetMonth(),me.GetYear());
  sprintf(arg,"d_inv,%s",str);
  R_Face(arg,str,100,0); 
  FreeSpaceString(str,3,"");
  int rc = GetGroupInv(str);
  if ( rc < 1 || rc > 3 )
    rc = 0;
  else
    rc = 1;

  return rc;
}

AddNewKin(&SurnameK,&NameK,&PatronK,&Kin,&BirthDay)
{
   var kin=CreateObject("KKin");
   var lkin=CreateObject("ListOfKin");
   string s;
   s=SurnameK;FreeSpaceString(s,2,"");kin.SetF(s);
   s=NameK;   FreeSpaceString(s,2,"");kin.SetI(s);
   s=PatronK; FreeSpaceString(s,2,"");kin.SetO(s);
   kin.SetIdKind(atoi(Kin));
   kin.SetBirthDay(static_cast_to_string(BirthDay));
   lkin.Add(kin);
}
AddNewKin2(&SurnameK,&NameK,&PatronK,&Kin,&BirthDay,&DopParams)
//DopParams - строка "дополнительных" параметров с разделителем ^
//первый элемент - вид родства для фсс
//второй элемент - дата усыновления
//третий элемент - строка с информацией об инвалидности
{
  var kin=CreateObject("KKin");
  var lkin=CreateObject("ListOfKin");
  string s;
  s=SurnameK;FreeSpaceString(s,2,"");kin.SetF(s);
  s=NameK;   FreeSpaceString(s,2,"");kin.SetI(s);
  s=PatronK; FreeSpaceString(s,2,"");kin.SetO(s);
  kin.SetIdKind(atoi(Kin));
  kin.SetBirthDay(static_cast_to_string(BirthDay));

  int kindFss=atoi(GetElementFromString(0,DopParams,"^"));
  if (kindFss) 
    kin.SetIDKindFSS(kindFss);
    
  var DayAdoption=KDateFromStr(GetElementFromString(1,DopParams,"^"));
  if (DayAdoption.IsValid())
    kin.SetDayAdoption(DayAdoption.GetStr());
    
  string strInv=GetElementFromString(2,DopParams,"^");
  if(strlen(strInv))
    kin.SetInv(strInv);

  lkin.Add(kin);
}
GetStrYMD(y,m,d)
{
   string rez[3];
   int val[3];
   val[0]=y;val[1]=m;val[2]=d;
   string info[3][3];
   info[0][0]="год";    info[0][1]="года";   info[0][2]="лет";
   info[1][0]="месяц";  info[1][1]="месяца"; info[1][2]="месяцев";
   info[2][0]="день";   info[2][1]="дня";    info[2][2]="дней";
   for ( int i = 0; i<3; ++i)
   {
      rez[i]="";
      int ed = val[i]%10;
      int des= val[i]%100;
      string tmp = (ed==1)?info[i][0]:info[i][1];
      rez[i]=(ed>0 && ed<5 && (des<10 || des>20))?tmp:info[i][2];
   }
   return rez;
}

DefineTravmParam(Podr,&str_inv,&I,&NomSet)
{
   var Dat = CreateObject("KDate");
   Dat.SetDateD(GetDateEndInv(str_inv));
   I = (GetGroupInv(str_inv)!=0 && 
        (Dat.IsEqI(INVALID_DATE_VALUE) || Dat.GetAbs()>=mrasch))?1:0;

   int org = GetOrgForPodr(atoi(Podr));
   var vEntRef = CreateObject("EnterpriseRefVar");
   vEntRef.Initial(org);

   int tmi = atoi(vEntRef.GetVar("СТТАРИФ"));
   if ( tmi )
       NomSet=tmi;
}

double FssSocPays[12]; // Выплаты за счет ФСС за каждый месяц расчетного периода

InitFssSocPays()
{
  for ( int i = 0; i < 12; i++ )
    FssSocPays[i] = 0.0;

  return 0;
}

GetFssSocPays(n,w,a)
// Возвращает значения выплат за счет ФСС
// 0 - получаем значения выплат за весь период - числа через запятую
// 1 - 12 : за определенный месяц
{
  string rc = static_cast_to_string("");

  char ts[256];

  if ( n < 0 || n > 12 ) return rc;

  if ( n == 0 )
  {
    for ( int i = 0; i < 12; i++ )
    {
      sprintf(ts,"%15.2f", FssSocPays[i]);
      FreeSpaceString(ts,3,"");
      rc = rc + static_cast_to_string(ts);
      if ( i < 12 ) rc = rc + static_cast_to_string(",");
    }
    return rc;
  }
  else
  {
    sprintf(ts,"%*.*f", atoi(w), atoi(a), FssSocPays[n-1]);
    rc = static_cast_to_string(ts);
    return rc;
  }

  return 0;
}


GetTravmaValue(mes,n,w)
{
  var lst1 = CreateObject("ParamFuncRW");
  var lst2 = CreateObject("ParamFuncRW");
  lst1.IInitial1(TravmaString,";",12);
  lst2.IInitial1(lst1.Get(mes-1),",",4);

  return atof(lst2.Get(n-1));
}

GetTotalBZByExtCod(ExtKod,ExtSrc)
{
   int rowkod[ROWMAX];
   int i,j;
   double kod = Extern_To_InternE(ExtKod);
   double rztotal=0.,rz=0.;
   char Src = 0;
   if ( Str_Cmp(ExtSrc,"*","") ) Src = ExtSrcToInt(ExtSrc[0]);
   int n=poiskosnkod(kod,rowkod,0,Src);
   for(j=n-1;j>=0;j--)
   {
      i=rowkod[j];

      if (    GetEndDate(i)+0.001<data+.01
           || GetBegDate(i)-0.001>data+countday/100.)
         continue;

      if (GetBase(i))
      {
         bz_kod(GetCode(i),data,GetBase(i),rz);
         rztotal += rz;
      }
   }
   return rztotal;
}

SumDopStrVzn(StrM1,StrM2)
{
   return SumDopStrVznCommon(StrM1,StrM2,"CllNU_DV");
}

SumDopStrVznR(StrM1,StrM2)
{
   return SumDopStrVznCommon(StrM1,StrM2,"CllNU_DVR");
}

SumDopStrVznCommon(StrM1,StrM2,cllnuDv)
{
   var PFOND_CNF_TABLE="п/фонд";
   char dopstbuf[MAXKOD];
   memcpy(dopstbuf,dopst,MAXKOD);
   probely(dopst,MAXKOD-1,'0');
   char Buf[256];
   GetCommonCnf(to_string(cllnuDv),PFOND_CNF_TABLE,Buf,255);
   var Arr; 
   int countElem = ListNUToSafeArray(to_string(Buf),' ',Arr);
   for ( int ii=0; ii<countElem; ++ii)
   {
      int pos = -1;
      if ( (pos=poisk1(to_int(Arr[ii]),kodnu1,cntplus,1))==EOF ) continue;
      dopst[pos]='1';
   }
   long Flag;
   if ( cllnuDv == "CllNU_DV" ) Flag =  CL_COL | CL_UD | CL_REAL; else Flag =  CL_COL | CL_NACH;
   if ( GetCommonCnfInt("TypeGetDV",PFOND_CNF_TABLE) ) Flag |= CL_MV; else Flag |= CL_M;
   double TotalSum=0.;
   var Date = CreateObject("KDate");
   Date.SetDateD(GetDateFromFuncRWScript(StrM1));
   int m1 = Date.GetAbs();
   Date.SetDateD(GetDateFromFuncRWScript(StrM2));
   int m2 = Date.GetAbs();
   for ( int m=m1; m<=m2; ++m)
      TotalSum += CollectSummSrcSimv("1",'d',m,m,Flag,0);
   memcpy(dopst,dopstbuf,MAXKOD);
   return TotalSum;
}

GetFIOFromNameORG(NameOrg,&f,&i,&o)
{
   var list = CreateObject("ParamFuncRW");
   list.IInitial(static_cast_to_string(NameOrg)," ,.\"",10);
   int idx = list.Count();
   if ( idx>2 )
   {
      o=list.Get(--idx); o=TrimN(o);
   }
   if ( idx>1 )
   {   
      i=list.Get(--idx); i=TrimN(i);
   }
   f=list.Get(--idx); f=TrimN(f);
}

CodRabMes(m)
// m - месяц (относительный)
{
  char arg[256];
  char str[256];

  int inv = 0;
  sprintf(arg,"7,%d",atoi(m));
  var me = CreateObject("KMonth");
  me.SetMonth(atoi(R_DATA_EX(arg,str,10,0)));
  sprintf(str,"%02d.%02d.%4d",me.CountDay(),me.GetMonth(),me.GetYear());
  sprintf(arg,"kod_rab,%s",str);
  R_Face(arg,str,100,0); 
  return atoi(str);
}

StrInvMes(m,n)
// m - месяц (относительный)
// ф-ция возвращает группу в случае если в данном месяце (на последний день месяца)
// человек был инвалидом 1, 2 или 3 группы или еще какой, в противном случае возвращается 0
// 0 - возвращается строка, 1 - группа инвалидности
{
  char arg[256];
  char str[256];

  int inv = 0;
  sprintf(arg,"7,%d",atoi(m));
  var me = CreateObject("KMonth");
  me.SetMonth(atoi(R_DATA_EX(arg,str,10,0)));
  sprintf(str,"%02d.%02d.%4d",me.CountDay(),me.GetMonth(),me.GetYear());
  sprintf(arg,"d_inv,%s",str);
  R_Face(arg,str,100,0); 

/*
  var me = CreateObject("KDate");
  int absm = atoi(m)+mtek;
  me.SetMonth(absm);
  me.SetDateII(me.CountDay(),me.GetAbs());
  GetKchValue("data_uv",str,100,me);
  var dat_uv = CreateObject("KDate");
  dat_uv.SetDate(static_cast_to_string(str));
  if ( !dat_uv.IsEqI(INVALID_DATE_VALUE) && dat_uv.GetAbs()<absm )
     return !atoi(n)?"":0;
  GetKchValue("d_inv",str,100,me);
*/

  var SprInv = CreateObject("ParamFuncRW");
  SprInv.IInitial(static_cast_to_string(str),",",6);

  if ( SprInv.Count()<=1 ) inv = atoi(str);
  else                     
  {
    var Dat = CreateObject("KDate");
    Dat.SetDateD(GetDateEndInv(str));

    int aMesEnd = Dat.GetAbs();
    if ( Dat.GetDay() < Dat.CountDay() ) aMesEnd--;

    int gr = GetGroupInv(str);
//  inv = (gr!=0 && 
//         (Dat.IsEqI(INVALID_DATE_VALUE) || Dat.GetAbs()>=me.GetAbs()))?1:0;

    inv = (gr!=0 && (Dat.IsEqI(INVALID_DATE_VALUE) || aMesEnd >= me.GetAbs()))?gr:0;

  }

  FreeSpaceString(str,3,""); 

  if ( !atoi(n) )
  {
    if ( inv ) return static_cast_to_string(str);
    else       return static_cast_to_string("");
  }
  else
  {
    return inv;
  }

}

GetCodNUDolgPF(Kod)
{
   var PFOND_CNF_TABLE = "п/фонд"; // настройки для ПФ
   string ps = (Kod)?"CllNU_DNak":"CllNU_DStr";
   return GetCommonCnfInt(ps,PFOND_CNF_TABLE);
}

PoiskNUDolgPF(&ArrayCod,Kod,KodCatPay)
{
  int rowkod[ROWMAX];
  int CountNU = 0;
  int iCod = GetCodNUDolgPF(Kod);
  char DopRkv[256], comm[256];
  int c=poiskosnkod(iCod,rowkod,0,CLL_TOTAL_SRC);
  bool AllNU = !Str_Cmp(KodCatPay," "," ");
  for (int i=0; i<c; ++i)
  {
      double Cod = GetCode(rowkod[i]);
      if ( AllNU )
        ArrayCod[CountNU++]=Cod;
      else
      {
         Rkv_from(Cod,"кодкат",comm,DopRkv);
         // Сравниваем с точностью до запятой и символов 1 и 7
         if ( !Str_Cmp(KodCatPay,DopRkv," ,17") ||
              (!Str_Cmp(KodCatPay,"НР"," ,17") && !Str_Cmp(" ",DopRkv," ,17")) )
           ArrayCod[CountNU++]=Cod;
      }
  }
  return CountNU;
}

GetSumDolgPF(OtnMonBeg,OtnMonEnd,Kod,KodCatPay)
//////////////////////////////////////////////////////////////////
// Функция получения задолженности по взносам ПФ (страх.,накопит.)
// с разбивкой по кодам тарифов (KodCatPay):
// ОСНО (основные виды деятельности)
// ОЗОИ (особая эк.зона, орзанизации инвалидов)
// УСЕН,ЕСХН (упрощенная система налогообложения, вмененка )
// Используется в качестве функции приема в таблицах.
// Kod = 0 - страховая часть
// Kod = 1 - накопительная часть
//////////////////////////////////////////////////////////////////
{
   var Param = CreateObject("ParamFuncRW");
   Param.IInitial(static_cast_to_string(KodCatPay),",",2);
   KodCatPay = Param.Get(0);
   int KodRab = atoi(Param.Get(1));
   double Sum = 0.;
   /*
   bool bFirst = true;
   var kcp = CreateObject("KPeriodsIterations");
   if ( kcp.Size()>1 )
   {
      int Cur=kcp.SetBegin();
      int idx=0;
      for ( idx=0; Cur; Cur=kcp.Next(),++idx )
         if ( !Str_Cmp(kcp.GetCurCod(),KodCatPay," ") )
            break;
      bFirst = 0==idx;
   }
   // Долг хранится общий без разбивки по категориям,
   // поэтому возвращаем только один раз
   if ( !bFirst ) return 0.;
   */

   int OMB = atoi(OtnMonBeg), OME = atoi(OtnMonEnd);
   int absmB = mrasch+OMB, absmE = mrasch+OME;
   var Month = CreateObject("KMonth");
   Month.SetMonth(absmB);
   int idxMonthB=Month.GetMonth()-1;
   int idxMonthE=idxMonthB+OME-OMB;
   bool bOsnExist=false;
   bool bDogovExist=false;

   for ( int idx=idxMonthB; idx<=idxMonthE; ++idx )
   {
      if ( GlobalKodRabPFMonth[idx]&0x02 ) bDogovExist=true;
      if ( GlobalKodRabPFMonth[idx]!=2 )   bOsnExist=true;
   }
   if ( !bDogovExist && !bOsnExist ) bOsnExist = true;
   string OsnCodCat = GlobalCodCatPFMonth[idxMonthE][0];
   if ( bGlobalOneDolgPF && (Str_Cmp(OsnCodCat,KodCatPay," ,.17") || (KodRab==7 && bOsnExist)) )
      return 0.;

   int YearCur = Month.GetYear(); // календарный год отчетного периода
   int TargetAbsM = absmB-1;
   Month.SetMonth(TargetAbsM);
   int YearPred = Month.GetYear(); // календарный год откуда берем задолженность

   // Хочется верить, что в течение одного года коды категорий менять не будут
   string ArOldKodCatPay[21];
   int cntOldKodCatPay=0;
   if ( YearCur==YearPred )
      ArOldKodCatPay[cntOldKodCatPay++]=KodCatPay;
   else
   {
      if ( YearCur != 2011 )
         ArOldKodCatPay[cntOldKodCatPay++]=KodCatPay;
      else
      {
         FreeSpaceString(KodCatPay,2,"");
         switch(KodCatPay)
         {
            case "ООИ":             // для ООИ ищем ОЗОИ в 2011
               ArOldKodCatPay[cntOldKodCatPay++]="ОЗОИ";
               break;

            case "ОДИТ": // они действовали с 2010 поэтому добавляем сам код, и на всякий случай УСЕН,
            case "ИЦС":  // если код сменился
            case "СХ":
            case "СМИ":
            case "НР":
               ArOldKodCatPay[cntOldKodCatPay++]=KodCatPay;
            case "ХМН":  // появились с 2011 и не могут смешиваться, поэтому переводим в них НР и УСЕН
            case "ХО":
            case "ТВЭЗ":
            case "ПНЭД":
               ArOldKodCatPay[cntOldKodCatPay++]="УСЕН";
               // ArOldKodCatPay[cntOldKodCatPay++]="НР"; !!! НР не надо добавлять, т.к. долг по предыдущему периоду
               // лучше оставить на действующем "старом" коде НР, чтобы "закрыть" по нему долг.
               // Хотя, возможно. это лучше сделать по настройке.
               break;

            default:
               ArOldKodCatPay[cntOldKodCatPay++]=KodCatPay;
         }
      }
   }
//"ВЖЕН","ВЖИЖ","ВЖИЖ","ВЖИТ","ВЖМН","ВЖНР","ВЖОИ","ВЖСБ","ВЖСИ","ВЖСХ","ВЖТЗ","ВЖХО","ВЖЦС","ВЖЭД","ВЖЭС",
//"ВПЕН","ВПИЖ","ВПИЖ","ВПИТ","ВПМН","ВПНР","ВПОИ","ВПСБ","ВПСИ","ВПСХ","ВПТЗ","ВПХО","ВПЦС","ВПЭД","ВПЭС",

//   int TmpMrasch=mrasch;
   double ArrCodeNU[ROWMAX];
   char DopRkv[256], comm[256];
   for ( int idxKodCatPay=0; idxKodCatPay<cntOldKodCatPay; ++idxKodCatPay )
   {
      int cntNU=PoiskNUDolgPF(ArrCodeNU,Kod,bGlobalOneDolgPF?"":ArOldKodCatPay[idxKodCatPay]);
      if ( !cntNU ) continue;
      
      for ( int idx=0; idx<cntNU; ++idx)
      {
          bool NeedAdd = true;
          if ( !bGlobalOneDolgPF  )
          {
             Rkv_from(ArrCodeNU[idx],"кодкат",comm,DopRkv);
             Param.IInitial(static_cast_to_string(DopRkv),",",2);
             int KodRabNU = atoi(Param.Get(1));
             if ( KodRab!=KodRabNU )
             {
                // Если у вида код работы = ГПХ и в периоде этот работник у нас проходит в том числе и как ГПХ
                // то сейчас долг суммировать не надо.
                // Или если у вида код работы не равен ГПХ и этот работник у нас проходит в том числе и с
                // трудовым договором
                if ( KodRabNU==7 && bDogovExist && KodRab!=7 )
                   NeedAdd = false;
                if ( KodRabNU!=7 && bOsnExist && KodRab==7 )
                   NeedAdd = false;
             }
          }
          if ( NeedAdd )
             Sum += CollectSumm(ArrCodeNU[idx],TargetAbsM,TargetAbsM,CL_M|CL_EXACT);
      }
   }
//   if ( mrasch!=TmpMrasch )
//      s50(TmpMrasch);
   return Sum;
}

GetKodCatPay()
{
   return GetKodCatPayBase(0,1,true);
}

GetKodCatPayC3B63()
{
   return GetKodCatPayBase(1,0,true);
}

GetKodCatPayC3B64()
{
   return GetKodCatPayBase(1,1,true);
}

GetKodCatPayIndCart2015()
{
   return GetKodCatPayBase(1,0,false);
}

ArrNU2Dopst(Arr,CountElem,Simv,flag)
{
   char BufDopst[MAXKOD+1];
   int isBufDopst = (flag & 0x01)!=0;
   if ( isBufDopst )
   {
      for ( int i=0; i<MAXKOD; ++i )
         BufDopst[i]='0';
      BufDopst[MAXKOD]=0;
   }

   for ( int i=CountElem-1; i>=0; --i )
   {
      int ikod = Arr[i];
      int pos = poisk1(ikod, kodnu1, cntplus, 0);
      if (pos != -1) 
      {
         if ( isBufDopst )
              BufDopst[pos]=Simv;
         else dopst[pos]=Simv;
      }
   }
   if ( !isBufDopst )
   {
      memcpy(BufDopst,dopst,MAXKOD);
      BufDopst[MAXKOD]=0;
   }
   return BufDopst;
}

StrNU2Dopst(StrNU)
{
   var Arr;
   int CountElem=ListNUToSafeArray(StrNU,' ',Arr);
   return ArrNU2Dopst(Arr,CountElem,'1',1);
}

NUDogovInDopst()
{
   char BufDopst[MAXKOD+1];
   Fill_Dopst(BufDopst,19);
   for ( int i=0; i<cntplus; ++i )
      if ( BufDopst[i]!='Р' )
         BufDopst[i]='0';
   for ( int i=cntplus; i<MAXKOD; ++i )
      BufDopst[i]='0';
   BufDopst[MAXKOD]=0;

   char Str[256];
   var DOGOVOR_CNF_TABLE="ДОГОВОР";
   string StrDogovor=GetCommonCnf("LST_NU_DGV",DOGOVOR_CNF_TABLE,Str,255);
   StrDogovor += " "+GetCommonCnf("LST_NU_AVT",DOGOVOR_CNF_TABLE,Str,255);
   var Arr;
   int CountElem=ListNUToSafeArray(StrDogovor,' ',Arr);
   for ( int i=CountElem-1; i>=0; --i )
   {
      int ikod = Arr[i];
      int pos = poisk1(ikod, kodnu1, cntplus, 0);
      if (pos != -1)
         BufDopst[pos]='Р';
   }
   return BufDopst;
}

AddOnePeriodPF(&kcp,&Kod,&d1,&d2,FlagDogov,&bOsnExist,&bDogovExist)
{
   if ( !FlagDogov )
     AddOnePeriodPFByKodRab(kcp,Kod,d1,d2,FlagDogov,bOsnExist,bDogovExist,1);

   bDogovExist = false;
   bOsnExist = false;

   // Дата конца действия очередного значения кода работы
   // В самом начале она равна дате окончания периода [_d1,_d2]
   var DateEnd = CreateObject("KDate");
   DateEnd.SetDate(static_cast_to_string(d2));

   // Найдем дату начала действия очередного значения кода работы
   char StrD[21];
   GetKchDate("kod_rab",StrD,10,DateEnd);
   var Date=CreateObject("KDate");
   Date.SetDate(static_cast_to_string(StrD));
   var DateBPer=CreateObject("KDate");
   DateBPer.SetDate(static_cast_to_string(d1));

   // Если вдруг дата начала пустая или выходит за рамки нашего периода
   // то установим ее равной началу периода
   if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.LT(DateBPer) )
      Date.SetDate(DateBPer.GetStr());

   // Ну и просматриваем все значения кода работы, действовавшие в
   // рассматриваемом периоде
   char StrKodRab[21];
   while ( 1 )
   {
      // находим очередное значение кода работы
      int KodRab=atoi(GetKchValue("kod_rab",StrKodRab,20,DateEnd));
      bool bLocalOsnExist=true;
      bool bLocalDogovExist=false;
      AddOnePeriodPFByKodRab(kcp,Kod,Date.GetStr(),DateEnd.GetStr(),FlagDogov,bLocalOsnExist,bLocalDogovExist,KodRab);
      if ( !bDogovExist && bLocalDogovExist ) bDogovExist = true;
      if ( !bOsnExist   && bLocalOsnExist   ) bOsnExist = true;

      // Устанавливаем дату конца очередного значения кода работы
      // равной дате начала уже рассмотренного значения минус один день.
      DateEnd.SetDateD(Date.GetDouble());
      DateEnd.Dec();

      // Если дата конца вышла за пределы рассматриваемого периода - выходим
      if ( DateEnd.IsEqI(INVALID_DATE_VALUE) || DateEnd.LT(DateBPer) )
         break;

      // Находим дату начала для очередного значения кода работы
      GetKchDateP("kod_rab",StrD,10,Date);
      Date.SetDate(static_cast_to_string(StrD));
      // Если вдруг дата начала пустая или выходит за рамки расчетного
      // месяца, то установим ее равной первому числу расчетного месяца
      if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.LT(DateBPer) )
         Date.SetDate(DateBPer.GetStr());
   }
}

DefineFlagsOsnAndDogovor(&DBeg,&DEnd)
{
   FillPeriodsDogovGPX();
   int Year = DEnd.GetYear();
   if ( DBeg.GetYear()!=Year ) DBeg.SetDateIII(1,1,Year);
   var kod_rab;
   KchToPeriods("kod_rab",DBeg.GetStr(),DEnd.GetStr(),1,kod_rab);
   // kod_rab.OnlyOneCodPerMonth(1);

   // найдем периоды "чистого ГПХ".
   var PeriodsTotalGPX = GetNothing();
   kod_rab.SetBeginCod("7");
   if ( !kod_rab.End() )
   {
      PeriodsTotalGPX = kod_rab.GetCurPer();
      PeriodsTotalGPX.Cut(DBeg.GetStr(),DEnd.GetStr());
   }

   var d1 = CreateObject("KDate"), d2 = CreateObject("KDate");
   for ( int m=DBeg.GetAbs(); m<=DEnd.GetAbs(); ++m )
   {
      d1.SetDateII(1,m); d2.SetDateII(d1.CountDay(),m);
      int idxMonth = d1.GetMonth()-1;
      GlobalKodRabPFMonth[idxMonth]=0;

      if ( !IsNothing(PeriodsTotalGPX) )
      {
         var p = PeriodsTotalGPX.FindFreePeriods(d1.GetStr(),d2.GetStr());
         if ( p.CountDays() == 0 ) // все занято 7 кодом среднесписочной (то есть весь месяц относим на ГПХ)
         {
            GlobalKodRabPFMonth[idxMonth] = 2;
            continue;
         }
         if ( p.CountDays()<d1.CountDay() ) // что-то все таки занято действием 7
            GlobalKodRabPFMonth[idxMonth] += 2;
      }
      GlobalKodRabPFMonth[idxMonth] += 1;
      // если код среднесписочной не сработал, то проверяем по суммам и периодам
      if ( (GlobalKodRabPFMonth[idxMonth]&0x02) == 0 )
      {
         double SumDogov = CollectSummSrcSimv("*",PARCOL+GPCN_NU_DOGOV_GPX,0,m,CL_MV,0);
         if ( nabs(SumDogov)>0.001 )
            GlobalKodRabPFMonth[idxMonth] += 2;
         else // Проверяем есть ли заполненный объект с датами периодов договоров ГПХ. Если есть,
              // то находим там период пересекающийся с заданным. Если пересечение есть, то взводим флаг.
              if ( IsObject(PeriodsNUDogovGPX) )
              {
                 string p1D1,p2D1;
                 if ( PeriodsNUDogovGPX.FindFirstAndLast(DBeg.GetStr(),DEnd.GetStr(),p1D1,p2D1) )
                 {
                    if ( PeriodsNUDogovGPX.SetPeriodExact(p1D1) )
                       GlobalKodRabPFMonth[idxMonth] += 2;
                    else if ( p1D1!=p2D1 && PeriodsNUDogovGPX.SetPeriodExact(p2D1) )
                       GlobalKodRabPFMonth[idxMonth] += 2;
                 }
              }

      }
   }
}

AddOnePeriodPFByKodRab(&kcp,&Kod,&d1,&d2,FlagDogov,&bOsnExist,&bDogovExist,KodRab)
{
   bDogovExist = false;
   bOsnExist = true;
   bool AddDoneGPX=false;
   if ( FlagDogov )
   {
      var BegPer=CreateObject("KDate"); // начало периода    
      var EndPer=CreateObject("KDate"); // конец периода   
      BegPer.SetDate(static_cast_to_string(d1));
      EndPer.SetDate(static_cast_to_string(d2));
      // char Buf[256];
      // GetKchValue("kod_rab",Buf,255,EndPer);
      // bOsnExist = atoi(Buf)!=7;
      bOsnExist = KodRab!=7;
      // Если в КЧ не стоит 7 в коде работы, смотрим наличие договорников по наличию сумм договоров в периоде
      if ( !bOsnExist )
      {
         bDogovExist = true;
      }
      else if ( bOnlyPureGPX_TD!=0 )
      {
         bDogovExist = false;
      }
      else
      {
         double SumDogov = 0.;
         for ( int m=BegPer.GetAbs(); m<=EndPer.GetAbs(); ++m )
             SumDogov += CollectSummSrcSimv("*",'d',0,m,CL_MV,0);
         bDogovExist = SumDogov>0.001;

         // Проверяем есть ли заполненный объект с датами периодов договоров ГПХ. Если есть,
         // то находим там период пересекающийся с заданным и его берем в качестве добавляемого периода
         // Если объекта нет, или пересечения не найдено, то добавляем с периодом d1-d2, как раньше
         if ( IsObject(PeriodsNUDogovGPX) && (!bExistLongDogovGPX || SumDogov<0.001) )
         {
            string p1D1,p2D1;
            if ( PeriodsNUDogovGPX.FindFirstAndLast(static_cast_to_string(d1),static_cast_to_string(d2),p1D1,p2D1) )
            {
               if ( PeriodsNUDogovGPX.SetPeriodExact(p1D1) )
               {
                  kcp.AddPeriod(Kod+",7",p1D1,PeriodsNUDogovGPX.GetCurEnd().GetStr());
                  bDogovExist=AddDoneGPX=true;

               }
               if ( p1D1!=p2D1 && PeriodsNUDogovGPX.SetPeriodExact(p2D1) )
               {
                  kcp.AddPeriod(Kod+",7",p2D1,PeriodsNUDogovGPX.GetCurEnd().GetStr());
                  bDogovExist=AddDoneGPX=true;
               }
            }
         }
      }
   }
   if ( bOsnExist )
   {
      kcp.AddPeriod(Kod+(FlagDogov?",1":""),static_cast_to_string(d1),static_cast_to_string(d2));
   }
   if ( bDogovExist || !bOsnExist )
   {
      if ( !AddDoneGPX )
         kcp.AddPeriod(Kod+",7",static_cast_to_string(d1),static_cast_to_string(d2));
   }
}

int    GlobalStatus2PFMonth[12];
int    GlobalKodRabPFMonth[12];
string GlobalCodCatPFMonth[12][2];
string GlobalCodCatFarm="АСБ,ВЖСБ,ВПСБ";
string GlobalCodCatInv="ООИ,ВЖОИ,ВПОИ";
int bGlobalPureASB=1; // признак что АСБ не смешивается с другими режимами внутри работника (т.е. все что есть у работника-фармацевта попадает на АСБ)
int bGlobalOneDolgPF=0;
DefineKodCatPFByMonth(&DefaultCodCat,&dat,&fl,bSplitCodCatByStaus2)
{
   // значения получаемые из КЧ ниже нужны на конец месяца (во всяком случае для status2 точно, т.к. в налогах
   // status2 отрабатывает по концу месяца)
   dat.SetDateII(dat.CountDay(),dat.GetAbs());
   int fl_nr = 1; // =1 проверяем по суммам (не возникает две строки, при 100% УСЕН)
                  // =0 всегда ставим код из КЧ если не инвалид
   int idxMonth=dat.GetMonth()-1;
   GlobalCodCatPFMonth[idxMonth][0]=GlobalCodCatPFMonth[idxMonth][1]="";
   GlobalKodRabPFMonth[idxMonth]=0;
   GlobalStatus2PFMonth[idxMonth]=0;

   char Str[256],Buf[256];
   string DefaultCodCatEnterprise="НР";
   // Значение по умолчанию берем из настройки организации
   GetEnterpriseVarCurLS("КОДКАТПФ",Buf,4);
   if ( Str_Cmp(Buf," "," ") )
   {
      FreeSpaceString(Buf,2,"");
      DefaultCodCatEnterprise=Buf;
   }
   if ( !Str_Cmp(DefaultCodCat," "," ") ) 
      DefaultCodCat=DefaultCodCatEnterprise;

   GetKchValue("status2",Str,4,dat);
   int status2=atoi(Str);
   GlobalStatus2PFMonth[idxMonth]=status2;
   GetKchValue("kodpayPF",Str,4,dat);
   FreeSpaceString(Str,3,"");
   UpperString(Str);
   if ( !Str_Cmp(Str,""," ") ) Str = DefaultCodCat;
   DefaultCodCat=Str;

   int MOtn = dat.GetRel(),
       TYear = dat.GetYear();
   bool bSpec = !Str_Cmp(Str,"ЕСХН"," ") || !Str_Cmp(Str,"УСЕН"," ");
   bool bSpecFarm = IsSubStrPresent(GlobalCodCatFarm,Str);
   bool bOsnExist=true;
   bool bDogovExist=false;

   // Если инвалид (их надо учитывать до 2015 года)
   if ( TYear<2015 && atoi(StrInvMes(MOtn,1)) ) 
   {
      Str=(TYear<2011)?"ОЗОИ":"ООИ";
      fl = true;
   }
   else
   {
      // С 2001 года все суммы по основному тарифу
      if ( TYear>=2011 || (fl_nr && CheckOsnMes(MOtn)) ) 
      {  // Основные тарифы
         // AddOnePeriodPF(kcp,static_cast_to_string(Str),static_cast_to_string(d1),static_cast_to_string(d2),FlagDogov,bOsnExist,bDogovExist);
         if ( bSpecFarm && !bGlobalPureASB )
            Str = DefaultCodCatEnterprise;
         fl = true;
      }
 
      if ( TYear<2011 && CheckVmMes(MOtn) )
      {  // Вмененка    
         if (!bSpec) Str="УСЕН";
         // AddOnePeriodPF(kcp,kod,static_cast_to_string(d1),static_cast_to_string(d2),FlagDogov,bOsnExist,bDogovExist);
         if ( fl_nr ) fl = true;
      }
   }

   if ( bSplitCodCatByStaus2 )
   {
      if ( status2==2 || status2==4 || status2==6 ) Str="";
      else if ( status2==1 || status2==3 || status2==5 )
      {
         char KodInostr[11];
         GetValueClassif("T_GUIDE\\kategpay.tab",Str,KodInostr,10,status2==1?"STATUS2_1":"STATUS2_3","Kod");
         if ( Str_Cmp(KodInostr," "," ") )
            Str=KodInostr;
      }
   }
   GlobalCodCatPFMonth[idxMonth][0]=Str;
   // Если это не временно пребывающий, и если у него в КЧ стоит спец.код категории АСБ и сейчас в качестве
   // кода стоит не он же, то у нас ситуация смешанных кодов (НР+АСБ или ООИ+АСБ)
   if ( (status2!=2 && status2!=4) && bSpecFarm && !IsSubStrPresent(GlobalCodCatFarm,Str) )
   {
      Str = "АСБ";
      if ( status2==1 || status2==3 )
      {
         char KodInostr[11];
         GetValueClassif("T_GUIDE\\kategpay.tab",Str,KodInostr,10,status2==1?"STATUS2_1":"STATUS2_3","Kod");
         if ( Str_Cmp(KodInostr," "," ") )
            Str=KodInostr;
      }
      GlobalCodCatPFMonth[idxMonth][1]=Str;
      Str = GlobalCodCatPFMonth[idxMonth][0]+","+GlobalCodCatPFMonth[idxMonth][1];
   }
   return Str;
}

GetFromLSStatus2ByMonth(&DBeg,&DEnd)
{
   char Buf[256];
   for ( int i=0; i<DBeg.GetMonth()-1; ++i ) GlobalStatus2PFMonth[i]=0;
   for ( int i=DEnd.GetMonth(); i<12;  ++i ) GlobalStatus2PFMonth[i]=0;
   for ( int am = DBeg.GetAbs(); am<=DEnd.GetAbs(); ++am )
   {
      var d = KDateFromInt_LastDay(am);
      GlobalStatus2PFMonth[d.GetMonth()-1]= atoi(GetKchValue("status2",Buf,255,d));
   }
}

var PeriodsNUDogovGPX=0;
bool bExistLongDogovGPX=false;
bool bExistCombineGPX=false;
bool bOnlyPureGPX_TD=0;


FillPeriodsDogovGPX()
{
   if ( !IsObject(PeriodsNUDogovGPX) )
      PeriodsNUDogovGPX=CreateObject("KDatePeriods");
   PeriodsNUDogovGPX.Clear();
   bExistLongDogovGPX=false;
   bExistCombineGPX=false;

   char dopstbuf[MAXKOD];
   int rowkod[ROWMAX];
   var DopstDogov = NUDogovInDopst();
   memcpy(dopstbuf,dopst,MAXKOD);
   memcpy(dopst,DopstDogov,MAXKOD);
   var Dat1=CreateObject("KDate");
   var Dat2=CreateObject("KDate");
   for ( int pos=0; pos<MAXKOD; ++pos )
   {
      if ( dopst[pos]=='0' ) continue;
      int ikod = kodnu1[pos];
      
      int n=poiskosnkod(ikod,rowkod,0,CLL_TOTAL_SRC);
      for(int j=n-1;j>=0;j--)
      {
         int row=rowkod[j];
         double d1 = GetBegDate(row);
         double d2 = GetEndDate(row);

         if ( d2+0.001>=datakon || d1-0.001<=1900 )
         {
            bExistLongDogovGPX=true;
            continue;
         }
         Dat1.SetDateD(d1);
         Dat2.SetDateD(d2);
         PeriodsNUDogovGPX.Update(Dat1.GetStr(),Dat2.GetStr());
      }
   }
   memcpy(dopst,dopstbuf,MAXKOD);

   // по коду среднесписочной численности 7
   var PerKch;
   KchToPeriods("kod_rab","01.01.1988","01.01.2099",1,PerKch);
   PerKch.SetBeginCod("7");
   if ( !PerKch.End() )
      PeriodsNUDogovGPX.UpdatePeriods(PerKch.GetCurPer());

   // по коду работы ==2 в исполняемой должности
   char Buf[256];
   var CL=CreateObject("CombineList");
   var it = CL.CreateIterator();

   var dat_rb = CreateObject("KDate");
   var dat_uv = CreateObject("KDate");
   for (it.SetBegin();!it.IsEnd();it.Next()) //цикл по ИД (  it.CurKey() - внутр.код совместительства )
   {  
      var tmp_comb = CreateObject("TmpCurCombine");
      tmp_comb.InitSimple(it.CurKey());
      kch_from("inc_type", Buf);
      bool isGPX = atoi(Buf) == 2;
      if ( isGPX )
      {
         kch_from("data_rb",Buf);
         dat_rb = KDateFromStr(Buf);
         kch_from("data_uv",Buf);
         dat_uv = KDateFromStr(Buf);

         if ( dat_uv.GetDouble()>=datakon || !dat_rb.GetYear()<=1900 )
         {
            bExistLongDogovGPX=true;
            continue;
         }
         PeriodsNUDogovGPX.Update(dat_rb.GetStr(),dat_uv.GetStr());
      }
   }
}

GetKodCatPayBase(FlagDogov,CheckDolg,bSplitCodCatByStaus2)
//////////////////////////////////////////////////////////////////
// Функция получения кодов тарифов категорий плателищиков ПФ:
// НР,... (основные виды деятельности)
// ОЗОИ (особая эк.зона, орзанизации инвалидов)
// УСЕН,ЕСХН (упрощенная система налогообложения, вмененка )
// Заполнения объекта "KPeriodsIterations"
// используются в качестве функции приема в таблицах 
//////////////////////////////////////////////////////////////////
{
   for ( int idxM=0; idxM<12; ++idxM )
   {
      GlobalCodCatPFMonth[idxM][0]=GlobalCodCatPFMonth[idxM][1]="";
      GlobalStatus2PFMonth[idxM]=0;
      GlobalKodRabPFMonth[idxM]=0;
   }

   var BegPer=CreateObject("KMonth"); // начало периода    
   var EndPer=CreateObject("KMonth"); // конец периода   
   BegPer.SetDate(static_cast_to_string(Str_Date_0)); //Период - Str_Date_0, Str_Date_1  
   EndPer.SetDate(static_cast_to_string(Str_Date_1));   
   int Year = BegPer.GetYear();
   // if ( Year>2012 ) FlagDogov=1;
   var PFOND_CNF_TABLE="п/фонд";
   bGlobalOneDolgPF=GetCommonCnfInt("OneDolgPF",PFOND_CNF_TABLE)!=1?0:1;
   bOnlyPureGPX_TD=GetCommonCnfInt("PureGPX",PFOND_CNF_TABLE);


   char dopstbuf[MAXKOD];
   if ( FlagDogov )
   {
      FillPeriodsDogovGPX();

      var DopstDogov;
      memcpy(dopstbuf,dopst,MAXKOD);
      DopstDogov = NUDogovInDopst();
      memcpy(dopst,DopstDogov,MAXKOD);
   }

   int AMB = atoi(BegPer.GetAbs()), 
       AME = atoi(EndPer.GetAbs());
   char Arg[256],Str[256],d_rb[256],d_uv[256];
   char d1[256],d2[256];
   int MOtn = 0, TYear = 0;

   var dat = CreateObject("KDate");
   var kcp = CreateObject("KPeriodsIterations");
   kcp.ClearAll();

   var dat_rb = CreateObject("KDate");
   var dat_uv = CreateObject("KDate");
   //AddOnePeriodPF(kcp,"НР","01.01.2010","30.06.2010",FlagDogov,bOsnExist,bDogovExist);

   string DefaultCodCat = "";
   bool bOsnExist=true;
   bool bDogovExist=false;

   for ( int m = AMB; m<=AME ; m++ )
   {
      dat.SetMonth(m);
      dat.ImproveDay();
      MOtn = dat.GetRel();
      TYear = dat.GetYear();

      // Если временно пребывающий в РФ (Страх.взносы=0) не учитываем
      if ( atoi(StatusStrMes(MOtn))==2 ) continue;

      sprintf(d1,"%02d.%02d.%d",1,dat.GetMonth(),dat.GetYear());
      sprintf(d2,"%02d.%02d.%d",dat.CountDay(),dat.GetMonth(),dat.GetYear());
      bool fl = false;
      Str=DefineKodCatPFByMonth(DefaultCodCat,dat,fl,bSplitCodCatByStaus2);
      if ( Str=="" ) continue;

      if ( !fl)  // Если никуда не отнесли, то проверяем: 
            // принят работник в тек. месяце,
            // есть не пустые периоды стажа, до даты приема 
            // не уволен в тек. месяце,
            // - если условия выполняются, то относим ЛС к тарифу из КЧ
      {
         char buf[256], func[256];

         // смотрим дату поступления на работу 
         GetKchValue("data_rb",d_rb,10,dat);
         dat_rb.SetDate(static_cast_to_string(d_rb));
         int m_rb = dat_rb.GetAbs();

         if ( Str_Cmp(d_rb,"",".0 ") && m_rb>dat.GetAbs() )
         {
            dat_rb.Dec();
            // проверим нет ли периодов работы, до даты поступления на работу
            sprintf(func,"СТАЖ_ЗА_ПЕРИОД(-100,3,%s,%s)",dat.GetStr(),dat_rb.GetStr());
            CallFuncReceive(func,buf,250,2);
            sprintf(func,"СТАЖ_ЗА_ПЕРИОД(100,СКОЛЬКО,%s,%s)",dat.GetStr(),dat_rb.GetStr());
            CallFuncReceive(func,buf,250,2);
            if( atoi(buf)>1 )
               fl = true;
            else if( atoi(buf)==1 )
            {
               sprintf(func,"СТАЖ_ЗА_ПЕРИОД(1,ПОЛНТР,%s,%s)",dat.GetStr(),dat_rb.GetStr());
               CallFuncReceive(func,buf,250,2);
               if ( Str_Cmp(buf,""," 2,.;") )
                  fl = true;
            }
            CallFuncReceive("СТАЖ_ЗА_ПЕРИОД(-1)",buf,250,2);
         }

         // смотрим дату увольнения 
         GetKchValue("data_uv",d_uv,10,dat);
         dat_uv.SetDate(static_cast_to_string(d_uv));
         int m_uv = dat_uv.GetAbs();
         // если месяц между приемом и увольнением - надо добавлять.
         if ( Str_Cmp(d_rb,"",".0 ") && m_rb<=dat.GetAbs()  &&
              (!Str_Cmp(d_uv,"",".0 ") || m_uv>=dat.GetAbs()) ) fl = true;
      }
      if ( fl )
      {
         int idxMonth = dat.GetMonth()-1;
         // Возможно что в месяце два кода категории (АСБ плюс еще что-то)
         if ( GlobalCodCatPFMonth[idxMonth][1]!="" )
         {
            AddOnePeriodPF(kcp,GlobalCodCatPFMonth[idxMonth][0],static_cast_to_string(d1),static_cast_to_string(d2),FlagDogov,bOsnExist,bDogovExist);
            AddOnePeriodPF(kcp,GlobalCodCatPFMonth[idxMonth][1],static_cast_to_string(d1),static_cast_to_string(d2),FlagDogov,bOsnExist,bDogovExist);
         }
         else
            AddOnePeriodPF(kcp,static_cast_to_string(Str),static_cast_to_string(d1),static_cast_to_string(d2),FlagDogov,bOsnExist,bDogovExist);
         GlobalKodRabPFMonth[idxMonth]=0;
         if ( bOsnExist )
            GlobalKodRabPFMonth[idxMonth] += 1;
         if ( bDogovExist )
            GlobalKodRabPFMonth[idxMonth] += 2;
      }
   }

   // долги учитывать не надо для СЗВ-6-3 или если настройка "вести один долг" установлена 
   if ( CheckDolg && !bGlobalOneDolgPF )
   {
      // На тот случай, если код плательщика мог смениться, чтобы не потерять "долги"
      // за прошлые периоды. Анализируем еще виды с долгами по уплате в ПФ.
      double ArrayDolgPFNU[ROWMAX];
      char comm[256];
      char DopRkv[256];
      var Param = CreateObject("ParamFuncRW");
      for ( int i=0; i<2; ++i )
      {
         int cnt = PoiskNUDolgPF(ArrayDolgPFNU,i," ");
         for ( int idx=0; idx<cnt; ++idx)
         {
             double Cod=ArrayDolgPFNU[idx];
             Rkv_from(Cod,"кодкат",comm,DopRkv);
             FreeSpaceString(DopRkv,3,"");
             Param.IInitial(static_cast_to_string(DopRkv),",",2);
             DopRkv = Param.Get(0);
             int KodRab = atoi(Param.Get(1));
             if ( TYear>=2011 )
             {
                // ОЗОИ 2010 года переходит в ООИ 2011
                // УСЕН переходит в код по умолчанию
                if ( TYear>=2015 || DopRkv=="УСЕН" ) DopRkv=DefaultCodCat;
                else if ( DopRkv=="ОЗОИ" ) DopRkv="ООИ";
             }
             if ( !Str_Cmp(DopRkv," "," ") )
                DopRkv=DefaultCodCat;
             bool bExistCod = true;
             // Ищем "чистый" код, если договора не учитываем  и дополнительно еще ищем код +",1" или +",7" если учитыавем
             if ( !kcp.SetBeginCod(static_cast_to_string(DopRkv)) && 
                  (!FlagDogov || (!kcp.SetBeginCod(static_cast_to_string(DopRkv)+",1") && !kcp.SetBeginCod(static_cast_to_string(DopRkv)+",7")))
                )
                bExistCod = false;

             // если такого кода еще не было
             if ( !bExistCod )
             {
                double Sum=CollectSumm(Cod,AMB-1,AMB-1,CL_M|CL_EXACT);
                if ( nabs(Sum)>0.001 )
                {
                   dat.SetMonth(AMB-1);
                   sprintf(d1,"%02d.%02d.%d",1,dat.GetMonth(),dat.GetYear());
                   sprintf(d2,"%02d.%02d.%d",dat.CountDay(),dat.GetMonth(),dat.GetYear());
                   AddOnePeriodPF(kcp,static_cast_to_string(DopRkv),static_cast_to_string(d1),static_cast_to_string(d2),FlagDogov,bOsnExist,bDogovExist);
                }
             }
         }
      }
   }

   if ( FlagDogov )
      memcpy(dopst,dopstbuf,MAXKOD);
   return 0;
}

GetStagsRaw(DBegInt,DEndInt,StagList)
{
   var DBeg = CreateObject("KDate"); DBeg.SetInt(DBegInt);
   var DEnd = CreateObject("KDate"); DEnd.SetInt(DEndInt);

   // ╧Ёшчэръ "фюуютюЁр" юяЁхфхы хЄё  ш яю ёЄЁюърь ═-╙, хёыш эх шэшЎшрышчшЁютрЄ№ ёЄюысхЎ
   // Єю ЁрсюЄэшъш ьюуєЄ эрўрЄ№ ёўшЄрЄ№ё  "ёьх°рээ√ьш"
   var ParcolDogov = CreateObject("KParcol");
   int FlgParCol=ParcolDogov.InitByGlobalParcol(GPCN_NU_DOGOV_GPX);
   if ( FlgParCol!=-1 )
   {
      ParcolDogov.Clear();
      ParcolDogov.AddFromCol("*",static_cast_to_string(NUDogovInDopst()),'1');
   }
   for (int i = 0; i < 12; i++) GlobalKodRabPFMonth[i] = 0;
   DefineFlagsOsnAndDogovor(DBeg, DEnd);
   int fullKodRab = 0; // 0x01 - ЁрсюЄры юс√ўэю, 0x02 - ЁрсюЄры яю ├╧╒, Є.х. == 2 - ¤Єю ўшёЄ√щ ├╧╒
   for (int i = DBeg.GetMonth(); i <= DEnd.GetMonth(); i++)
      fullKodRab |= GlobalKodRabPFMonth[i-1];

   int flag = 3; // 3 - яюыєўшь Єюы№ъю юс√ўэ√х, 9 - Єюы№ъю ├╧╒, 19 - ш Єх ш фЁєушх
   if (fullKodRab & 0x02) flag = fullKodRab == 2 ? 9 : 19;

   char Func[256], Buf[256];
   sprintf(Func, AnsiToOem("╤╥└╞_╟└_╧┼╨╚╬─(-500,%d,%s,%s)"), flag, DBeg.GetStr(), DEnd.GetStr());
   CallFuncReceive(Func,Buf,255,0);
         
   sprintf(Func, AnsiToOem("╤╥└╞_╟└_╧┼╨╚╬─(500,╤╩╬╦▄╩╬,%s,%s)"), DBeg.GetStr(), DEnd.GetStr());
   CallFuncReceive(Func,Buf,255,0);
   int CountStag = atoi(Buf);
         
   for (int i = 1; i <= CountStag; i++)
   {
      Buf[0]=0;
      sprintf(Func, AnsiToOem("╤╥└╞_╟└_╧┼╨╚╬─(%d,╤╥└╞╤1,%s,%s)"), i, DBeg.GetStr(), DEnd.GetStr());
      CallFuncReceive(Func, Buf,255,0);
      if ( !Str_Cmp(Buf," "," ") ) continue;
      StagList.Add(TrimN(OemToAnsi(Buf)));
         
      sprintf(Func, AnsiToOem("╤╥└╞_╟└_╧┼╨╚╬─(%d,╤╥└╞╤2,%s,%s)"), i, DBeg.GetStr(), DEnd.GetStr());
      CallFuncReceive(Func, Buf,255,0);
      StagList.Add(TrimN(OemToAnsi(Buf)));
   }
         
   sprintf(Func, AnsiToOem("╤╥└╞_╟└_╧┼╨╚╬─(-1)"));
   CallFuncReceive(Func, Buf,255,0);

   return flag;
}


CheckVmMes(MOtn)
// Проверка есть ли в этом месяце у ЛС суммы по вмененке
{
   char Arg[256], Str[256];
   double sum_vm = 0.; // Суммы ЕНВД
   double eps = 0.001;
   
   sprintf(Arg,"7,1,%d,%d,*,*,О",MOtn,MOtn); 
   sum_vm += atof(R_Tax(Arg,Str,14,2));

   sprintf(Arg,"7,1,%d,%d,*,*,Е",MOtn,MOtn); 
   sum_vm += atof(R_Tax(Arg,Str,14,2));

   if ( nabs(sum_vm)>eps ) return 1; 
   return 0;
}

CheckOsnMes(MOtn)
// Проверка есть ли в этом месяце у ЛС суммы по основному тарифу
{
   char Arg[256], Str[256];
   double sum_osn = 0.; // Суммы ОСНОВНЫЕ
   double eps = 0.001;
   
   sprintf(Arg,"7,1,%d,%d,*,*,А",MOtn,MOtn);
   sum_osn += atof(R_Tax(Arg,Str,14,2));

   sprintf(Arg,"7,1,%d,%d,*,*,Л",MOtn,MOtn);
   sum_osn += atof(R_Tax(Arg,Str,14,2));

   if ( nabs(sum_osn)>eps ) return 1; 
   return 0;
}

int FillByAllSimplePeriods=3; // 0x01 - после автозаполнения стажа с особенностями в дополнительном параметре тр.стажа
                            // 0x02 - только "простые" записи из настройки ПФ (по табелю и по видам)
                            // 0x04 - все простые периоды после автозаполнения стажа
GetPeriodKodBL()
//////////////////////////////////////////////////////////////////
// Функция получения периода и кодов БЛ, для ПФ ОТЧЕТ:
// Заполнения объекта "KPeriodsIterations"
// используются в качестве функции приема в таблицах 
//////////////////////////////////////////////////////////////////
{
   string PFOND_CNF_TABLE = "п/фонд";
   string ST_EMPTY_CNF_TABLE = "ПУСТОЙ";
   char Arg[256],Str[256],d1[256],d2[256];
   char buf[256], func[256], kodbl[256];

   var kbl = CreateObject("KPeriodsIterations");
   kbl.ClearAll();

   int NumPP = 1;
   if ( FillByAllSimplePeriods & 0x02 )
   {
      try
      {
         var Dat=CreateObject("KDate");
         Dat.SetDate(static_cast_to_string(Str_Date_0));
         Dat.SetDateIII(1,Dat.GetMonth(),Dat.GetYear());
         Str_Date_0 = Dat.GetStr();
         Dat.SetDate(static_cast_to_string(Str_Date_1));
         Dat.SetDateIII(Dat.CountDay(),Dat.GetMonth(),Dat.GetYear());
         Str_Date_1 = Dat.GetStr();
         var SimplePeriods;
//         if ( 0 ) // способ номер 1 - возложить все на функцию автозаполнения стажа, временно отключив остальное автозаполнение
//         {        // способ плох тем, что не работает если стаж в КЧ сам по себе простой
//            char SaveCnf[11];
//            GetCommonCnf("NotAddStg",PFOND_CNF_TABLE,SaveCnf,10);
//            char Buf[256];
//            int Flag = 0xFFF ^ 0x10;
//            sprintf(Buf,"%-d",Flag);
//            SetCommonCnfInMem("NotAddStg",Flag,PFOND_CNF_TABLE,'N',4,0);
//            AddDopRowStag(Str_Date_0,Str_Date_1,SimplePeriods);
//            SetCommonCnfInMem("NotAddStg",SaveCnf,PFOND_CNF_TABLE,'N',4,0);
//         }
//         else // способ номер 2, самостоятельно заполнить по табелю и по видам указанным в настройке ПФ
         {
            GetCommonCnf("LST_NU_STG",ST_EMPTY_CNF_TABLE,Str,255);
            FindPeriodsByNU(Str,Str_Date_0,Str_Date_1,SimplePeriods);
            var Tmp;
            GetCommonCnf("SimvTabel",ST_EMPTY_CNF_TABLE,Str,255);
            if ( FindPeriodsByTabel(Str,Str_Date_0,Str_Date_1,3,Tmp) )
               SimplePeriods.UpdatePeriods(Tmp);
         }
         SimplePeriods.SetBegin();
         for ( ; !SimplePeriods.End(); SimplePeriods.Next() )
         {
            string d1 = SimplePeriods.GetCurBeg().GetStr();
            string d2 = SimplePeriods.GetCurEnd().GetStr();
            sprintf(kodbl,"%03d,%s,%s,УЧОТПУСК",NumPP++,d1,d2);
            kbl.AddPeriod(static_cast_to_string(kodbl),d1,d2);
         } 
      }
      catch (...)
      {
         ;
      }
   }

   if ( FillByAllSimplePeriods & 0x01 )
   {
      CallFuncReceive("СТАЖ_ЗА_ПЕРИОД(-100,3)",buf,250,2);
      CallFuncReceive("СТАЖ_ЗА_ПЕРИОД(100,СКОЛЬКО)",buf,250,2);
      int CountStag = atoi(buf);
      var TStagEmpty = CreateObject("TStag");
      TStagEmpty.InitS("");

      for ( int i=1; i<=CountStag ; ++i )
      {
         sprintf(func,"СТАЖ_ЗА_ПЕРИОД(%d)",i);
         CallFuncReceive(func,buf,250,2);
         if ( Str_Cmp(buf,""," 2,.;") )
         {
            var TStag = CreateObject("TStag");
            TStag.InitS(static_cast_to_string(buf));
            buf = TStag.GetStagS("ДОПТРСТ"); FreeSpaceString(buf,3," ");
            d1 = TStag.GetStagS("ДАТАНАЧ");
            d2 = TStag.GetStagS("ДАТАКОН");
            FreeSpaceString(d1,3," ");
            FreeSpaceString(d2,3," ");

            if ( Str_Cmp(buf,""," ,.;") )
            {
               sprintf(kodbl,"%03d,%s,%s,%s",NumPP++,d1,d2,buf);   
               kbl.AddPeriod(static_cast_to_string(kodbl),static_cast_to_string(d1),static_cast_to_string(d2));
            }
            else if ( FillByAllSimplePeriods & 0x04 )
            {
               //TStagEmpty.SetStagS("ДАТАНАЧ",static_cast_to_string(d1));
               //TStagEmpty.SetStagS("ДАТАКОН",static_cast_to_string(d2));
               if ( !Str_Cmp(TStag.GetStagS("ТРСТАЖ"), TStagEmpty.GetStagS("ТРСТАЖ"), " ") )
               {
                  sprintf(kodbl,"%03d,%s,%s,УЧОТПУСК",NumPP++,d1,d2);   // УЧОТПУСК - условное слово по которому отрабатывает ПФ-Отчет
                  kbl.AddPeriod(static_cast_to_string(kodbl),static_cast_to_string(d1),static_cast_to_string(d2));
               }
            }
         }
      }
      CallFuncReceive("СТАЖ_ЗА_ПЕРИОД(-1)",buf,250,2);
   }
   return 0;
}

StatusStrMes(m)
// m - месяц (относительный)
// ф-ция возвращает статус для страховых взносов (на последний день месяца)
{
  char arg[256],str[256];
  var me = CreateObject("KMonth");
  me.SetMonth(m+mtek);
  sprintf(arg,"status2,%02d.%02d.%4d",me.CountDay(),me.GetMonth(),me.GetYear());
  R_Face(arg,str,100,0);
  return str;
}



var mapFindTnForKch; // мэп "значение - ТН" (или массив таких мэпов)
var psFindTnForKch;  // псевдоним(ы), по которому(ым) создавался мэп
int cntMapTnForKch=0; // "размерность" массива mapFindTnForKch;
int psNewTn;

SelectTnFromMap(&_map, _value)
{
  var MapPanel[cntMapTnForKch];
  int count[cntMapTnForKch];
  string tn="";
  var ArrMap[cntMapTnForKch];
  var ArrValue[cntMapTnForKch];
  var Par=CreateObject("ParamFuncRW");
  Par.IInitial1(_value,"~",cntMapTnForKch);

  for ( int idx=0; idx<cntMapTnForKch; ++idx )
  {
      count[idx]=0;
      MapPanel[idx] = CreateObject("MapString");
      ArrMap[idx] = cntMapTnForKch<2?_map:_map[idx];
      ArrValue[idx]=Par.Get(idx);
  }

  for ( int idx=0; idx<cntMapTnForKch; ++idx )
  {
     var map = cntMapTnForKch<2?_map:_map[idx];
     var value = Par.Get(idx);
     for ( bool Cur=map.InitIteratorLowB(static_cast_to_string(value)); Cur; Cur=map.NextV() )
     {
        count[idx]++;
        tn=map.GetCurValue();
        string fio = fio(VisIndexForTn(tn));
        RTrim(fio);
        MapPanel[idx].Add(tn,tn+" "+fio+" - "+value);
     }
     if (count[idx] < 2) return tn;
  }

  var MapRez = CreateObject("MapString");
  int c=PanelValueFromMap(MapPanel[0],MapRez,5, "Найдено "+static_cast_to_string(count[0])+" ЛС со значением "+Par.Get(0));
  if (c==ESC)
  {
     return " "; //пробел!
  }
  MapRez.InitIterator();
     
  return MapRez.GetCurKey();
}


FindTnForKCH(flag, ps)
{
   return FindTnForKCH_Ex(flag,ps,mapFindTnForKch);
}
GetFamWithInitials()
{
  char tmp[256],fio[256];
  kch_from("f",tmp); FreeSpaceString(tmp,3,"");  fio=tmp;
  kch_from("i",tmp); FreeSpaceString(tmp,3,"");  fio+=" "+tmp[0]+".";
  kch_from("o",tmp); FreeSpaceString(tmp,3,"");  fio+=" "+tmp[0]+".";
  return fio;

}
FindTnForKCH_Ex(flag,ps,&Map)
{
   // flag==0  освобождение памяти
   // flag==1  создание массива данных КЧ по псевдониму ps
   // flag==2  определение ТН по данным КЧ, в ps передаем значение . Если не нашли возвращает 0
   // flag==3  --------||---------- плюс если не нашли то возвращаем НОВЫЙ несуществующий ТН
	 // flag & 0x04 - при поиске заменяем ё на е
	 // flag & 0x08 - игнорировать регистр
   // flag+10  строка КЧ дополняется спереди кодом организации, напрмер "1;страховой номер"

  char ls[256]; // буфер для имени ЛС  
  char buf[256];
  
	bool replaceSimilar= flag  & 0x04;
	if( replaceSimilar)
		flag-=4;
	
	bool ignoreCase= flag & 0x08;
	if( ignoreCase)
		flag-=8;
	
	bool flagOrg = flag>=10;
  if (flagOrg) flag-=10;
  	
	 
  if (flag==0)
  {
     Map=GetEmpty();   //очистка
     psFindTnForKch = GetEmpty();
     cntMapTnForKch;
  }

  if (flag==1)                      
  {
     var Par=CreateObject("ParamFuncRW");
     Par.IInitial(ps,"~",1000);
     cntMapTnForKch = Par.Count();
     if ( cntMapTnForKch<1 ) cntMapTnForKch=1;
   
     var ArrMap[cntMapTnForKch];
     var ArrPs[cntMapTnForKch];
     for ( int idx=0; idx<cntMapTnForKch; ++idx )
     {
         ArrMap[idx]=CreateObject("MMapString");
         ArrPs[idx]=Par.Get(idx);
     }
    psNewTn = 1;

    var CMsg  = CreateObject("ProgressBar");
    CMsg.Initial(0,100,5);
    CMsg.SetShowTime(static_cast_to_int(0));

    for(int i=0;i<counttn;i++)
    {
       int tnum=tn(i)%sizetn;
       int RC=LSRead(tnum, 1);
       if ( RC!=1 ) continue;
       if ( CMsg.Msg_Proc(" Чтение лицевых счетов.",100.*(i+1)/counttn)==ESC )
       {
          Map=GetEmpty();
          return 0;
       }
       string s;
       if (flagOrg) 
       {
         int podr = tn(i)/sizetn;
         s= static_cast_to_string(GetOrgForPodr(podr))+";";
       }
       s+=static_cast_to_string(tnum);

       for ( int idx=0; idx<cntMapTnForKch; ++idx )
       {
				   if ( ArrPs[idx]=="fio" )
           {
						  //buf=GetFioFromKch();
              buf=GetFamWithInitials();
            }
					 else
						 kch_from(ArrPs[idx],buf);
					 
					 RTrim(buf);
					 if(replaceSimilar)
					 {
						 replac0('ё','е',buf,strlen(buf));
						 replac0('Ё','Е',buf,strlen(buf));
					 }
					 if(ignoreCase)	 
					  UpperString(buf);

					if ( ArrPs[idx]=="pasport" )
					 {
							var Pasp = CreateObject("Pasport");
							Pasp.Initial(to_string(buf));
							buf = Pasp.GetPasport("СЕРИЯ")+" "+Pasp.GetPasport("НОМЕР");
							FreeSpaceString(buf,2," ");
					 }
	         ArrMap[idx].Add(static_cast_to_string(buf),s);
       }
    }
    Map = cntMapTnForKch<2?ArrMap[0]:ArrMap;
    psFindTnForKch = cntMapTnForKch<2?ArrPs[0]:ArrPs;

  }

  if (flag==2 || flag==3)
  {    
      var tab="";
      if (IsEmpty(Map)) return 0;
			 if(replaceSimilar)
			 {
				 replac0('ё','е',ps,strlen(ps));
				 replac0('Ё','Е',ps,strlen(ps));
			 }
			 if(ignoreCase)	 
				UpperString(ps);
      if (RTrim(ps)!="")
         tab = SelectTnFromMap(Map, static_cast_to_string(ps));
      if (tab!="" || flag==2)
        return atoi(tab);
      
      for (psNewTn++; ;psNewTn++)
      {
        int found = 0;
        for(int i=0;i<counttn;i++)
        {
           int tnum=tn(i)%sizetn;
           if (tnum==psNewTn)
           {
                found=1;
                break;
           }
        }
         
        if (!found) return psNewTn;
      }
   

  }
   
}

R_IncomeBL(m1,m2,W,A)
//////////////////////////////////////////////////////////////////
// Доход для соц.страха                      
// Используется в качестве функции приема в таблицах.
//////////////////////////////////////////////////////////////////
{
    char Str[256];
    double SumIncome = atof(R_TaxScIncomeBL(4,m1,m2,W,A));
    string StrDiscount=R_TaxScIncomeBL(112,m1,m2,255,0);
    var Par=CreateObject("ParamFuncRW");
    Par.IInitial(StrDiscount,";",1000);
    for ( int i = 0; i<Par.Count(); ++i )
    {
       if ( atoi(Par.Get(i))==901 )
       {
          Par.IInitial(Par.Get(i),",",20);
          SumIncome += atof(Par.Get(1));
          break;
       }
    }
    Double_Text(Str,SumIncome,A,W>255?255:W);
    return static_cast_to_string(Str);
}

R_TaxScIncomeBL(Code,m1,m2,W,A)
//////////////////////////////////////////////////////////////////
// Вызов функции R_Tax(Code,1,m1,m2,*,*,'Ц') 
// Используется в качестве функции приема в таблицах.
//////////////////////////////////////////////////////////////////
{
    char Arg[256],Str[256];
    char dop[100];
    dop="";
    if (m1+mtek<277)
      dop=",DateTaxCnf=01.2011";
    sprintf(Arg,"%d,1,%s,%s,*,*,Ц%s",Code,m1,m2,dop);
    return static_cast_to_string(R_Tax(Arg,Str,W,A));
}

R_BoundIncomeBL(m1)
{
   if (m1+mtek<277) m1=276;
   double MaxBound = 0.;
   /*
   try
   {
      var Map = CreateObject("MapString");
      // Для годов до 2011 насильно настройки читаются из настроек 2011 года,
      // поэтому приходится пользоваться более полной функцией (которая прочитает настройку)
      // для остальных лет используется упрощенная, которая пользуется уже прочитанной настройкой налога (т.е. должна
      // вызываться после вызова нужного R_Tax
      if ( m1==276 )
         ProcentTaxAlg(238,static_cast_to_string(m1),1,Map);
      else
         ProcentTax(1,Map);
      if ( Map.Size() )
      {  
         string key = "zzzzzzzzzzzzzzzzzzzzzz";
         Map.Add(key,key);
         Map.InitIteratorLowB(key);
         if ( Map.Prev() )
           MaxBound = atof(Map.GetCurKey());
      }
   }
   catch(...)
   {
   */
      MaxBound=GetMaxBoundary(238,1,static_cast_to_string(m1));
   //}
   return MaxBound;
}

GetRowForIntCode(IntCode)
{
   int rowkod[ROWMAX];
   int n=poiskosnkod(IntCode,rowkod,1,0);
   if (n>0) return rowkod[0];
   return -1;
}

// получение названия должности из КЧ 
// buf - буфер для названия, bufsize - размер буфера
// date - на какую дату рассматривать (если 0 - то рассматривается на начало текущего 
// месяца, иначе должен быть заполненный объект KDate)
// idcombine - код совместительства (CLL_TOTAL_COMBINE -  для текущего совместительства)
GetKchDoljn(&buf, bufsize, date, idcombine) 
{
   var cur_combine;
   if (idcombine!=CLL_TOTAL_COMBINE) 
   {
      cur_combine=CreateObject("TmpCurCombine");
      cur_combine.Init(idcombine);
   }
   char kchvalue[256];
   if (IsObject(date))
   {
      if (date.IsEqI(INVALID_DATE_VALUE)) date.ImproveDay();
      if (!date.IsEqI(INVALID_DATE_VALUE))
      {
         GetKchValue("dolgnost",kchvalue,255,date);
  
         GetDoljnNameFromKCH(kchvalue,buf,bufsize);
//         GetDoljnNameFromID(atol(kchvalue),buf,bufsize);

         cur_combine=0;
         return;
      }
   }
   var kdate=CreateObject("KDate");
   kdate.SetDateII(1,mtek);    
   GetKchValue("dolgnost",kchvalue,255,kdate);

   GetDoljnNameFromKCH(kchvalue,buf,bufsize);   
//   GetDoljnNameFromID(atol(kchvalue),buf,bufsize);
   cur_combine=0;
}


// получение названия должности по ее внутреннему коду
GetDoljnNameFromID(iddoljn, &buf, bufsize)
{
   if (iddoljn!=0)
   {
     var doljnlist=CreateObject("DoljnList");
     Text_Text(buf,doljnlist.GetName(iddoljn),bufsize);
     doljnlist=0;
   }   
   else Text_Text(buf," ",bufsize);  
}

int ColTVH4FSS=1102-1;
int cntGlobalDopDaysInvNU=-1;
int cntGlobalDopDaysInvStrVzn=-1;
var GlobalDopDaysInvNU;
char BufDopstDaysInvNU[MAXKOD+1];

DefineNUForDopDaysInv()
{
   if ( cntGlobalDopDaysInvNU<0 )
   {
      GlobalDopDaysInvNU=GetNothing();
      /*
      char Buf[256];
      GetCommonCnf("LST_NU_INV","spr2Year",Buf,255);
      // виды оплаты по уходу за ребенком инвалидом берем из настройки
      // если же она пустая (в поставке по умолчанию отсутствует), 
      // то по 2 столбцу ТВХ для сводов или по 107 коду алгоритма.
      if ( Str_Cmp(Buf," "," ") )
         cntGlobalDopDaysInvNU=ListNUToSafeArray(Buf,' ',GlobalDopDaysInvNU);
      else
      */
      {
         cntGlobalDopDaysInvNU=0;
         cntGlobalDopDaysInvStrVzn=0;
         int Buf[MAXKOD+1];
         for ( int row=0; row<cntplus && cntGlobalDopDaysInvNU<10; ++row )
         {
            // для ФСС данные виды помечались 6 во 2-ом столбце ТВХ для сводов
            if ( Sim_For_Position(row,ColTVH4FSS)=='6' )
            {
                if ( IsCodeNach(kodnu1[row]) )               
                   Buf[cntGlobalDopDaysInvNU++]=kodnu1[row];
                else
                   cntGlobalDopDaysInvStrVzn++;
            }
         }
         if ( cntGlobalDopDaysInvNU ) GlobalDopDaysInvNU=Buf;
      }
      if ( cntGlobalDopDaysInvNU<1 )
         cntGlobalDopDaysInvNU=CodeAlgToListNUSafeArray("107"," ",GlobalDopDaysInvNU);

      for ( int i=0; i<MAXKOD; ++i ) BufDopstDaysInvNU[i]='0';
      BufDopstDaysInvNU[MAXKOD]=0;

      for ( int idxInvNU=0; idxInvNU<cntGlobalDopDaysInvNU; ++idxInvNU )
      {
         int ikod = GlobalDopDaysInvNU[idxInvNU];
         int pos = poisk1(ikod, kodnu1, cntplus, 0);
         if (pos != -1)
            BufDopstDaysInvNU[pos]='6';
      }
   }
}

   IsExistDopDaysInvNU()
// ~~~~~~~~~~~~~~~~~~~
// Проверка что в ЛС присутствуют нужные виды начислений
{
   int rowkod[ROWMAX];
   for ( int idxInvNU=0; idxInvNU<cntGlobalDopDaysInvNU; ++idxInvNU )
      if ( poiskosnkod(GlobalDopDaysInvNU[idxInvNU],rowkod,0,CLL_TOTAL_SRC) )
         return true;
   return false;
}

// Функция расчета
CalcualateTaxForDaysInvNU(StrTax,OtnB,OtnE)
{
   bool defaultTaxes = !Str_Cmp(StrTax," "," ");
   double FullTax=0.;
   DefineNUForDopDaysInv();
   if ( !cntGlobalDopDaysInvNU || !IsExistDopDaysInvNU() ) return 0.;
   

   if ( cntGlobalDopDaysInvStrVzn && defaultTaxes )
   {
       double summ=0.;
       for ( int m=OtnB; m<=OtnE; ++m )
       {
          s100simv("*","у", m, ColTVH4FSS,summ,0);
          FullTax+=summ;
       }
   }
   else
   {
      // если не указаны коды налогов, которые нас интересуют, то берем "по умолчанию"
      // проинициализирован
      if ( defaultTaxes ) StrTax=  "А,Ц,М,Г,1,2,131,132,133,134,140,231,232,233,234,240";
      var TaxAlg = CreateObject("ParamFuncRW");
      TaxAlg.IInitial(to_string(StrTax)," ,;",20);

      var Parcol = CreateObject("KParcol");
      int FlgParCol=Parcol.InitByGlobalParcol(GPCN_EXCLUDE_NU_TAX);
      if ( FlgParCol!=-1 )
      {
         Parcol.Clear();
         Parcol.AddFromCol("*",to_string(BufDopstDaysInvNU),'1');
      }

      // как считать страховые взносы с выплат на детей инвалидов.
      // 1 - по максимуму, 0 - по минимуму
      // тип обложения играет роль в месяце, когда срабатывает ограничение базы лимитом
      // в этот момент возникает вопрос "какие суммы не попали в базу" и/или облагаются
      // меньшим процентом взносов.
      // "по максимуму" - это значит упомянутая оплата включается в базу в первую очередь
      // "по минимуму" - значит оплата включается в базу в последнюю очередь

      // ToDo: Когда придет ответ из ФСС включить в поставку настройку с вариантом по умолчанию
      // соответствующим ответу ФСС
      // TStrDnInv, N,1,0,78,Как считать страховые с оплаты дней по уходу за ребенком-инвалидом
      // 1 - по максимуму (включаются в базу первыми), 0 - по минимуму (включаются в базу последними)
      int HowCalcStr = GetCommonCnfInt("TStrDnInv","fss4");
      int Col = PARCOL+GPCN_EXCLUDE_NU_TAX;
      if ( HowCalcStr ) Col = -Col;

      char Arg[256],Str[256],ArgExclude[256];
      sprintf(ArgExclude,"|ExcludeNUCol=%d",FlgParCol!=-1?Col:-1);

      if ( HowCalcStr )
      {
         var dat = CreateObject("KDate");
         dat.SetDateII(1,OtnB+mtek); 
         for ( int idxAlg=0; idxAlg<TaxAlg.Count(); ++idxAlg )
         {
            string StrCodTax = MakeCodAlgForTax(TaxAlg.Get(idxAlg));
            sprintf(Arg,"7,1,%d,%d,*,*,%s%cDateTaxCnf=%s",OtnB,OtnE,StrCodTax,(atoi(StrCodTax)==261?'|':','),dat.GetStr());
            FullTax += atof(R_Tax(Arg+ArgExclude,Str,14,2));
         }
      }
      else
      {
         for ( int idxAlg=0; idxAlg<TaxAlg.Count(); ++idxAlg )
         {
            for ( int i = 0; i<=OtnE-OtnB; ++i )
            {
               var dat = CreateObject("KDate");
               dat.SetDateII(1,OtnB+i+mtek); 

               string StrCodTax = MakeCodAlgForTax(TaxAlg.Get(idxAlg));
               sprintf(Arg,"7,1,%d,%d,*,*,%s%cDateTaxCnf=%s",OtnB+i,OtnB+i,StrCodTax,(atoi(StrCodTax)==261?'|':','),dat.GetStr());
               double ShortTax = atof(R_Tax(Arg+ArgExclude,Str,14,2));
               FullTax += atof(R_Tax(Arg,Str,14,2))-ShortTax;
            }   
         }
      }
   }
   return FullTax;
}

MakeArrayPFTarif(Year)
{
   if ( Year==2010 )
      return GetArray("01 - Уплачивающие по основному тарифу",
                      "02 - с/х, промыслы, общины, малые народы Севера",
                      "03 - особая экономическая зона, организации инвалидов",
                      "04 - ЕСХН",
                      "05 - УСН, ЕНВД");
   else if ( Year==201100 )
      return GetArray("01 - Уплачивающие по основному тарифу",
                      "02 - ОСНО и УСН"
                      "03 - ОСНО и ЕНВД",
                      "04 - с/х товаропроизводители - ст.346.2 НК РФ",
                      "05 - с/х, промыслы, общины, малые народы Севера",
                      "06 - ЕСХН",
                      "07 - выплаты инвалидам I,II,III группы и орг. инвалидов",
                      "08 - орг., собственниками которых являются орг.инвалидов",
                      "09 - хоз.общества, созданные бюджетными научными учрежд.",
                      "10 - резидент технико-внедренческой особой эконом. зоны",
                      "11 - IT организации",
                      "12 - радиовещание, телевещание, информационные агенства",
                      "13 - издание газет или журналов и периодических публикаций",
                      "14 - УСН (п.8 ч.1 ст.58 ФЗ № 212)",
                      "15 - Сколково");
   else if ( Year==2011 )
      return GetArray("01 - Уплачивающие по основному тарифу (НР)",
                      "51 - УСН и ЕНВД применяющие основной тариф (НР)",
                      "02 - с/х, промыслы, общины, малые народы Севера (СХ и ХМН)",
                      "03 - выплаты инвалидам I,II,III гр. и орг. инвалидов (ООИ)",
                      "04 - ЕСХН",
                      "36 - резиденты особой экономичкской зоны (ТВЭЗ)",
                      "06 - IT организации (ОДИТ)",
                      "07 - УСН (п.8 ч.1 ст.58 ФЗ № 212) (ПНЭД)",
                      "08 - хоз.общества, созданные бюджетными научными учр. (ХО)",
                      "09 - СМИ",
                      "10 - Сколково");
   else if ( Year==2012 )
      return GetArray("01 - Уплачивающие по основному тарифу (НР)",
                      "52 - УСН применяющие основной тариф (НР)",
                      "53 - ЕНВД применяющие основной тариф (НР)",
                      "18 - с/х товаропризводители (СХ)",
                      "19 - народные художественные промыслы (ХМН)",
                      "20 - семейные общины малых народов Севера (ХМН)",
                      "03 - общественные организации инвалидов (ООИ)",
                      "04 - ЕСХН",
                      "06 - IT организации (ОДИТ)",
                      "07 - УСН (п.8 ч.1 ст.58 ФЗ № 212) (ПНЭД)",
                      "08 - хоз.общества, созданные бюджетными научными учр. (ХО)",
                      "09 - СМИ",
                      "10 - Сколково",
                      "11 - аптечные организации (АСБ)",
                      "12 - организации социального обслуживания населения (АСБ)",
                      "13 - благотворительные организации (АСБ)",
                      "14 - Инжиниринговые услуги (ИНЖУ)",
                      "15 - экипажи судов (ЧЭС)",
                      "36 - резиденты особой экономичкской зоны (ТВЭЗ)");
   else if ( Year==2013 )
      return GetArray("01 - Уплачивающие по основному тарифу (НР)",
                      "52 - УСН применяющие основной тариф (НР)",
                      "53 - ЕНВД применяющие основной тариф (НР)",
                      "18 - с/х товаропризводители (СХ)",
                      "19 - народные художественные промыслы (ХМН)",
                      "20 - семейные общины малых народов Севера (ХМН)",
                      "03 - общественные организации инвалидов (ООИ)",
                      "04 - ЕСХН",
                      "06 - IT организации (ОДИТ)",
                      "07 - УСН (п.8 ч.1 ст.58 ФЗ № 212) (ПНЭД)",
                      "08 - хоз.общества, созданные бюджетными научными учр. (ХО)",
                      "09 - СМИ",
                      "10 - Сколково",
                      "11 - аптечные организации (АСБ)",
                      "12 - организации социального обслуживания населения (АСБ)",
                      "13 - благотворительные организации (АСБ)",
                      "14 - Инжиниринговые услуги (ИНЖУ)",
                      "15 - экипажи судов (ЧЭС)",
                      "16 - ИП применяющие патентную систему",
                      "36 - резиденты особой экономичкской зоны (ТВЭЗ)");
   else if ( Year==2014 )
      return GetArray("01 - Уплачивающие по основному тарифу (НР)",
                      "52 - УСН применяющие основной тариф (НР)",
                      "53 - ЕНВД применяющие основной тариф (НР)",
                      "18 - с/х товаропризводители (СХ)",
                      "19 - народные художественные промыслы (ХМН)",
                      "20 - семейные общины малых народов Севера (ХМН)",
                      "03 - общественные организации инвалидов (ООИ)",
                      "04 - ЕСХН",
                      "06 - IT организации (ОДИТ)",
                      "07 - УСН (п.8 ч.1 ст.58 ФЗ № 212) (ПНЭД)",
                      "08 - хоз.общества, созданные бюджетными научными учр. (ХО)",
                      "09 - СМИ",
                      "10 - Сколково",
                      "11 - аптечные организации (АСБ)",
                      "12 - организации социального обслуживания населения (АСБ)",
                      "13 - благотворительные организации (АСБ)",
                      "15 - экипажи судов (ЧЭС)",
                      "16 - ИП применяющие патентную систему",
                      "36 - резиденты особой экономичкской зоны (ТВЭЗ)");
   // else if ( Year==2015 )
      return GetArray("01 - Уплачивающие по основному тарифу (НР)",
                      "52 - УСН применяющие основной тариф (НР)",
                      "53 - ЕНВД применяющие основной тариф (НР)",
                      "06 - IT организации (ОДИТ)",
                      "07 - УСН (п.8 ч.1 ст.58 ФЗ № 212) (ПНЭД)",
                      "08 - хоз.общества, созданные бюджетными научными учр. (ХО)",
                      "10 - Сколково",
                      "11 - аптечные организации (АСБ)",
                      "12 - организации социального обслуживания населения (АСБ)",
                      "13 - благотворительные организации (АСБ)",
                      "15 - экипажи судов (ЧЭС)",
                      "16 - ИП применяющие патентную систему",
                      "36 - резиденты особой экономичкской зоны (ТВЭЗ)",
                      "23 - Крым и Севастополь (КРС)",
                      "24 - территория опережающего соц.-эконом. развития (ТОР)");
}

GetFirstMonthQuarterAbs(&Date)
{
   int FirstMonthQuarter = Date.GetAbs();
   int OffsetFirstMonth = Date.GetMonth()%3;
   if ( OffsetFirstMonth==2 ) FirstMonthQuarter -= 1;
   else if ( OffsetFirstMonth==0 ) FirstMonthQuarter -= 2;
   return FirstMonthQuarter;
}

AddOnePeriod(&DateBeg, &DateEnd, &Periods)
{
   Periods.Update(DateBeg, DateEnd);
   return 0;
}