
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[80];
      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,0);
      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];
    sprintf(Arg,"%d,1,%s,%s,*,*,%c",Code,m1,m2,Type);
    return static_cast_to_string(R_Tax(Arg,Str,W,A));
}


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));
}
*/
PutSummTime ( &Arg,  &pcT, W, A)
//////////////////////////////////////////////////////////////////
// Разноска суммы и РВ в строку.
// код, мп, мн, флаг (см.BE_?????), рв, ист., сумма, дата
//////////////////////////////////////////////////////////////////
{
   var FuncParam =  CreateObject("ParamFuncRW");
   FuncParam.IInitial(static_cast_to_string(Arg),",",8);
   int CountParam=FuncParam.Count();
   
   // Как минимум должны задать код вида, месяц принадлежности и месяц начисления.
   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_MACTIVE")) )
          Flag |= BE_MACTIVE;
      }

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


      var Src=CreateObject("APropBE");
      if ( CountParam>5 ) // задан источник
      {
        char s[21];
        s = GetVarValue(FuncParam.Get(5));
        if (s[0]=='*' && s[1]=='*') Src.Initial(GetCommonProp(CMN_SRC_REFS2));
        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();
         }   
      }

      PutSummProp(Cod,E,Src,Flag);
      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 ) 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);

        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;  
}

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();

  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));
    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 + ",";

    // признак инвалидности
    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                     inv = GetGroupInv(Str); 
    if ( inv ) inv = 1;
    sprintf(ts,"%d", inv); FreeSpaceString(ts,3,"");
    rez = rez + ts + ",";

    // признак особых условий труда
    int out = 0;
    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;
   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,0);
         CountHours += rv;
      }
   }
   Hours = CountHours;
   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;
}

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

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 ( day <= Mes.CountDay() )
  {
    int tmes = mrasch;
    s50(mes);
    sprintf(str,"%c",calm[day-1]);
    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)
{
   // Важно!!! Для повышения скорости получения информации по организации
   // список настроек по последней организации сохраняется и может быть использован
   // в дальнейшем, НО если после создания этого списка, изменяли что-либо
   // в настройке по организации эти изменения не будут доступны до пересоздания
   // списка, поэтому желательно при начале работы с данной функцией (например для первой
   // строки таблицы, в которую принимаем данные, или в начале формы печати)
   // делать iScriptGlobalNumOrg = -1;
   if ( iScriptGlobalNumOrg == -1 )
   {
      vScriptGlobalRefOrg=0;
      vScriptGlobalRefOrg = CreateObject("EnterpriseRefVar");
   }

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

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 в символ табеля АМБы
{
  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 = GetFullNameNU(code); FreeSpaceString(Name, 3, "");
   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;
}

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; // отбрасываем пересчетные строки
    if ( de.LT(dbeg) ) continue;
    db.SetDateD(GetBegDate(row));
    if ( db.GT(dend) ) continue;

    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;

    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 = 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 = 20;
var FssSocLines[cFssLn];
string StrFssSim = "";

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

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


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

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

  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));

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

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

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

  int cnt[cFssLn]; int cnts[cFssLn]; int cnt2[cFssLn]; 
  int dni[cFssLn]; int dnis[cFssLn]; int dni2[cFssLn]; 
  int cnv[cFssLn]; int cnvs[cFssLn]; int cnv2[cFssLn]; 
  int dnv[cFssLn]; int dnvs[cFssLn]; int dnv2[cFssLn]; 

  double sum[cFssLn];
  double svm[cFssLn];
  double sums[cFssLn];
  double svms[cFssLn];
  double sum2[cFssLn];
  double svm2[cFssLn];

  for ( int i = 0; i < cFssLn; i++ )
  {
    cnt[i] = 0; cnts[i] = 0; cnt2[i] = 0; 
    dni[i] = 0; dnis[i] = 0; dni2[i] = 0; 
    cnv[i] = 0; cnvs[i] = 0; cnv2[i] = 0; 
    dnv[i] = 0; dnvs[i] = 0; dnv2[i] = 0; 

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

  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;
  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;
        }
      }
    }
  }
////////////////////////////////////////////////////////////////////////

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

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

    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));
    // Если задан процент в КЧ, то корректно пока можно разделять
    // только если для вмененки задан отдельный набор видов б/л
    // поэтому зануляем здесь процент, за исключением 100%
    if ( proc<100 )
       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 - совместительство

    int sovm = 0;

    if ( 1 == sovm1 || 4 == 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];
    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;
    }

    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;

      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 ( nabs(sm) > eps &&  // если сумма не нулевая
           !vm            &&  // если это не источник и не совместительство на вмененке
           proc < eps     &&  // не 100% в КЧ (менее 100 ранее обнулили)
           ( pay == '9' ||  // временная нетрудоспособность (обычный БЛ)
             pay == '2' ||  // по беременности и родам
             pay == '3' ||  // до 1.5 лет
             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 < 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 )
        {
          aPaySocCount(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, // флаг количества детей
                      idxp);// индекс соцвыплаты
        }
      }
      else
      {
        if ( nabs(sm) > eps )
        {
          COD[ck] = code;
          SUM[ck] = sm;
           RV[ck] = rv;
          SRC[ck] = ts[0]; 
           VM[ck] = vm;
          PAY[ck] = pay;
              ck++;
        }
      }
    } // конец цикла по строкам ЛС

//  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];

          aPaySocCount(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, // флаг количества детей
                      idxp);// индекс соц.выплаты
        }
      }
    }
  } // конец цикла по месяцам

  string rez = "";

  for ( int i = 0; i < cpay; i++ )
  {
    rez = "";

    sprintf(ts,"%d",    cnt[i]); FreeSpaceString(ts,3,""); rez =             ts; // невмененка
    sprintf(ts,"%d",    dni[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",sum[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    
    sprintf(ts,"%d",    cnv[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // вмененка
    sprintf(ts,"%d",    dnv[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",svm[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    
    sprintf(ts,"%d",    cnts[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // невмененка (совместительство) (до 1.5 лет 1-й ребенок)
    sprintf(ts,"%d",    dnis[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",sums[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    
    sprintf(ts,"%d",    cnvs[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // вмененка   (совместительство) (до 1.5 лет 1-й ребенок)
    sprintf(ts,"%d",    dnvs[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",svms[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    
    sprintf(ts,"%d",    cnt2[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // невмененка (до 1.5 лет 2-й ребенок)
    sprintf(ts,"%d",    dni2[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",sum2[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    
    sprintf(ts,"%d",    cnv2[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts; // вмененка   (до 1.5 лет 2-й ребенок)
    sprintf(ts,"%d",    dnv2[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;
    sprintf(ts,"%14.2f",svm2[i]); FreeSpaceString(ts,3,""); rez = rez + "," + ts;

    FssSocLines[i] = static_cast_to_string(rez);
  }

  return 0;
}


aPaySocCount(&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, // флаг количества детей
             idxp  // индекс соц.выплаты
)
{
  double tmp, eps = 0.001;

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

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

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

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

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

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

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

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

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

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

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

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

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

ReadFssLine(Pay)
{
  char fsr[256]; sprintf(fsr,"%s",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];
}

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);
}


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)
{
   var PFOND_CNF_TABLE="п/фонд";
   char dopstbuf[MAXKOD];
   memcpy(dopstbuf,dopst,MAXKOD);
   char Buf[256];
   GetCommonCnf("CllNU_DV",PFOND_CNF_TABLE,Buf,255);
   var Param = CreateObject("ParamFuncRW");
   Param.IInitial(static_cast_to_string(Buf)," ",200);
   for ( int ii=0; ii<Param.Count(); ++ii)
   {
      int pos = -1;
      if ( (pos=poisk1(static_cast_to_int(Param.Get(ii)),kodnu1,cntplus,1))==EOF ) continue;
      dopst[pos]='1';
   }
   long Flag =  CL_COL | CL_UD | CL_REAL;
   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;
}

SumDopStrVznR(StrM1,StrM2)
{
   var PFOND_CNF_TABLE="п/фонд";
   char dopstbuf[MAXKOD];
   memcpy(dopstbuf,dopst,MAXKOD);
   char Buf[256];
   GetCommonCnf("CllNU_DVR",PFOND_CNF_TABLE,Buf,255);
   var Param = CreateObject("ParamFuncRW");
   Param.IInitial(static_cast_to_string(Buf)," ",200);
   for ( int ii=0; ii<Param.Count(); ++ii)
   {
      int pos = -1;
      if ( (pos=poisk1(static_cast_to_int(Param.Get(ii)),kodnu1,cntplus,1))==EOF ) continue;
      dopst[pos]='1';
   }
   long 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); Trim(o);
   }
   if ( idx>1 )
   {   
      i=list.Get(--idx); Trim(i);
   }
   f=list.Get(--idx); Trim(f);
}

PCollectSumTabl(kod,typ,w,a,ext)
// kod - внутренний код вида НУ
// typ - 0 - выборка по принадлежности; 1 - по начислению
// w,a - размерность и точность для результата
// ext - 0 - выборка по всем расширениям вида НУ; 1 - по точному расширению
{
  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 flag = 0;

  if ( !typ && !ext ) flag = CL_M;
  if ( !typ &&  ext ) flag = CL_EXACT|CL_M;
  if (  typ && !ext ) flag = CL_MV;
  if (  typ &&  ext ) flag = CL_EXACT|CL_MV;

  double sm = 0.0;

  for ( int mes = mbeg; mes <= mend; mes++ )
  {
    sm += CashSumm(0,kod,mes,mes,32,flag,0);
  }

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

  return static_cast_to_string(s);
}
