import "layer92.dll"

FindValidVid(vkod)
/*
  Ф-ция возвращает точный код вида (c внутренним кодом vkod), действовавший в mrasch 
*/
//d1,d2 - дата в формате ДД.ММ.ГГГГ 
//vkod- внутренний код вида
{
  var db=CreateObject("KDate"); db.SetDateII(1,mrasch); //начало периода
//  var de=CreateObject("KDate"); de.SetDate(db.CountDay(),mrasch); //конец  периода
 var de=CreateObject("KDate"); de.SetDateII(db.CountDay(),mrasch); //конец  периода

  if (db.LT(de)) return 0;
  
  var Prop;//=GetCommonProp(CMN_SRC_COUNT_LS);//определяем атрибуты глобального фильтра
  int rowkod[ROWMAX];//массив с номерами строк

int cntrow=poiskosnkod(vkod,rowkod,0,"П");//получаем список строк с внутренним кодом==vkod

//  int cntrow=poiskosnkodProp(vkod,rowkod,0,Prop);//получаем список строк с внутренним кодом==vkod
  for (int i=0; i<cntrow; i++)                    //перебираем все строки
  {
    double ikod=GetCode(rowkod[i]);  //точный внутренний код строки
    var DatB = CreateObject("KDate"); DatB.SetDateD(GetBegDate(rowkod[i])); //дата начала действия строки
    var DatE = CreateObject("KDate"); DatE.SetDateD(GetEndDate(rowkod[i])); //дата конца действия строки 
  
    //фильтруем строки не действующие в периоде d1,d2
    if (DatB.GT(db)||DatE.LT(de)) continue; //дата_начала вида больше d1 или дата_окончания вида меньше d2
    return ikod;
  }
  return 0;
}

////////////
GetFirstValidNuCode()
{
   int stolbec=37;
   string sims="1"; 
   var nuList=GetValidNuList(mrasch,stolbec,sims); //список точных внутренних кодов видов НУ (действующих в указанном месяце)    
   if(nuList.Size()<1) //нет действующих видов
    return -1;
   nuList.InitIterator(); 
   return atof(nuList.GetCurKey());//возвращаем первый
}
////////////

GetValidNuList(m,stolb,Simv)
{  
  var map=CreateObject("MapString");map.Clear();
  var db=KDateFromInt_WithDay(1,m); //первое    число 
  var de=KDateFromInt_LastDay(m);   //последнее число 
  for (int i=0;i < cntplus;i++)
  {
    char Sim[2];Sim[1]=0;
    Sim[0]=Sim_For_Intern_Cod(kodnu1[i],stolb-1);  //определяем символ в ТВХ
    if ( IsSubStrPresent(Simv,"*")&&(Sim!="0") || IsSubStrPresent(Simv,Sim))
    {
      int rowkod[ROWMAX];//массив с номерами строк
      var Prop=GetCommonProp(CMN_SRC_COUNT_LS);//определяем атрибуты глобального фильтра
      int cntrow=poiskosnkodProp(kodnu1[i],rowkod,0,Prop);//получаем список строк с внутренним кодом==kodnu1[i]
      for (int row=0; row < cntrow; row++)                    //перебираем все строки
      {
        var dbRow = KDateFromD(GetBegDate(rowkod[row]));
        var deRow = KDateFromD(GetEndDate(rowkod[row]));
        //фильтр на действующие строки
        if (( dbRow.IsValid() && dbRow.GT(de))|| //дата_начала вида больше даты окончания периода
          (deRow.IsValid() && deRow.LT(db)) )   //дата_окончания вида меньше даты начала период
        continue; 
        map.Add(to_string(GetCode(rowkod[row])),"");
      }
    }      
  }
  return map;
}



UserAlgorithmCalc(&info,&r)
{
   // инициализация локальных переменных
   int RetFlag       = code_Break,

       crow          = info.crow,
       b3            = info.b3,
       ikod          = info.ikod,
       kod_alg       = info.kod_alg,
       pos           = info.pos,
       mkat          = info.mkat,
       krabot        = info.krabot,
       tip_s9600     = info.tip_s9600,
       flag_propusk0 = info.flag_propusk0,
       z1            = info.z1,
       z2            = info.z2;

   double h[4];
   double kod        = info.kod,
//	 okl		   = info.okl,
          n1         = info.n1,
          d1         = info.d1,
          d2         = info.d2,
          bz         = info.bz;
          h[0]       = info.h[0],
          h[1]       = info.h[1],
          h[2]       = info.h[2],
          h[3]       = info.h[3];

   int rowkod[ROWMAX],i,m,m1,b1,b2,mvrem;
   char t[20],str[81],str1[81];
   double n2,n3,n4,n5,n6,n7,n8,n9,n10,r8,r9,k;
   double nSNG1,nSNG2,nSNG3,nSNG4,nSNG5,nSNG6,nNAM1;          //================================================================SNG 


//====================================================
// rono 10.08.99 для расчета категории после даты-n11
// 10.08.99
   double n11; // для даты, начиная с которой категория
               // не входит в расчет ставки
   int n12;    // для N ст. табл.вх-ти при расчете гим-
               // назических (case SCH_ALG(31))

   /*-----------------------------------------------------*/
   /* tip_s9600=0 - функция обработки СУММЫ по строке     */
   /*               (s9600) - обнуляет РВ, если СУММА==0. */
   /* tip_s9600=1 - не обнуляет (в спец.случаях)          */
   /*-----------------------------------------------------*/

   /*-----------------------------------------------------*/
   /* Если flag_propusk0=1, то расчет данного вида по его */
   /* алгоритму производится только через режимы "Расчет  */
   /* произвольного вида", "Доп.расчеты" и при расчете от-*/
   /* дельной строки в "Просмотре, корректировке ЛС".     */
   /* flag_propusk0=3, то же, что =1, только в этом случае*/
   /* программа работает со строкой вида даже если у нее  */
   /* вышли даты действия (например, для квартал.дотаций).*/
   /* В остальных режимах - если есть СУММА, то подается  */
   /* на корректировку, иначе - вид пропускается в расчете*/
   /*-----------------------------------------------------*/

   int c=-4096;

   switch(kod_alg)
   {
      // Сюда можно вставлять вызов собственных алгоритмов расчета.
      // Примеры функций с алгоритмами  находятся
      // в файле SCRIPT\ALGSYS.S

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

	case 714:
      return UserAlg714(info,r);

	case 715:
      return UserAlg715(info,r);

/*------------------Установленный должностной оклад-----------------------------------------*/

case 818:      /* 2023 УДО */
               /*-----------------------------------------------------------*/
               /* оклад = (база(bz)* образ * стаж * квалиф * спец)          */
               /*-----------------------------------------------------------*/

 /* чтение формы 205 */
      	StartRkv(GetCode(crow));
	//К_Образование
               ReadRkv("спец_к1",str);
               nSNG1=atof(str);
			if (nSNG1==0) nSNG1=1;
	//К_Квалификация
               ReadRkv("спец_к2",str);
               nSNG2=atof(str);
			if (nSNG2==0) nSNG2=1;
	//К_Стаж
               ReadRkv("спец_к3",str);
               nSNG3=atof(str);
			if (nSNG3==0) nSNG3=1;
	//К_Специфика
               ReadRkv("спец_к4",str);
               nSNG4=atof(str);
			if (nSNG4==0) nSNG4=1;
           FinishRkv();

	/* Установленный должностной оклад учителя */
		n1=bz*nSNG1*nSNG2*nSNG3*nSNG4;
		round2(n1,2,1,n1); //округляем результат произведения

	if(FL_V_ALG && uprc != NO_SCREEN)
      {
         infolist.add_record("Оклад",bz);
         infolist.add_record("К_Образование",nSNG1);
         infolist.add_record("К_Квалификация",nSNG2);
         infolist.add_record("К_Стаж",nSNG3);
         infolist.add_record("К_Специфика",nSNG4);
         infolist.add_record("Уст.Долж.Оклад",n1);
      }
     break;

/*------------------Установленный должностной оклад(конец)--------------------*/


case 817:      /* 2023 УДО ставка */
               /*-----------------------------------------------------------*/
               /* оклад = (база(bz)* образ * стаж * квалиф * спец)          */
               /*-----------------------------------------------------------*/
       /* чтение формы 205 */
      	StartRkv(GetCode(crow));
	//К_Образование
               ReadRkv("спец_к1",str);
               nSNG1=atof(str);
			if (nSNG1==0) nSNG1=1;
	//К_Квалификация
               ReadRkv("спец_к2",str);
               nSNG2=atof(str);
			if (nSNG2==0) nSNG2=1;
	//К_Стаж
               ReadRkv("спец_к3",str);
               nSNG3=atof(str);
			if (nSNG3==0) nSNG3=1;
	//К_Специфика
               ReadRkv("спец_к4",str);
               nSNG4=atof(str);
			if (nSNG4==0) nSNG4=1;
           FinishRkv();

	 /* заполнение рабоч.дней в табеле */

	worktime(info.crow,info.b3,0);
		if(nkalend == knorm)
	      r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);
	if ((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1) return code_ReturnCode;


	/* Установленный должностной оклад учителя */
		n5=bz*nSNG1*nSNG2*nSNG3*nSNG4;
		round2(n5,2,1,n5); //округляем результат произведения

	// Вычисляем

		n1=r[2]*n5/norm(1);

	if(FL_V_ALG && uprc != NO_SCREEN)
      {
         infolist.add_record("Оклад ПКГ",bz);
         infolist.add_record("К_Образование",nSNG1);
         infolist.add_record("К_Квалификация",nSNG2);
         infolist.add_record("К_Стаж",nSNG3);
         infolist.add_record("К_Специфика",nSNG4);
         infolist.add_record("Уст.Долж.Оклад",n5);
         infolist.add_record("НРВ",norm(1));
         infolist.add_record("ФРВ",r[2]);
      }
     break;


     case 606: /*Компенсация тр-ра руб/день  17.03.2004 */

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */
               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                  r[2]=dney_v_tab(rsimv,calm,z1,z2);
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }
               n1=r[2]*bz;
	if(FL_V_ALG && uprc != NO_SCREEN)
      {
         infolist.add_record("Рабочее время",r[2]);
         infolist.add_record("БЗ",info.bz);
         infolist.add_record("Результат",info.n1);
      }
      break;

     case 666:   /* оклад в школе в часах     02.2001 */
               /*----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                         */
               /* ставка= база * (100 + % за категорию) * (100 + % спец. ) */
               /* оклад = ставка * ФРВчасы /НРВчасы                        */
               /*----------------------------------------------------------*/
               // чтение формы 205
               StartRkv(GetCode(crow));
               // % за категорию
               ReadRkv("ставка",str);
               n4=atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n6=atof(str)/100.;
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
               FinishRkv();

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */
               if (nkalend==knorm)  /* если строка считается по основному графику ЛС */
               {
                skoljko(r[2],data,z1,z2,rsimv,calm,cht);     // в часах
               }
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
                {
                 RetFlag=code_ReturnCode;
                 break; 
                 //goto return_c;
                } 
  
             if (n6==0) n6=1;

               n1=r[2]*bz*n4*n5*n6/norm(2);

               break;

     


      case 888:   /* оклад в школе */      /* 02.2001 */
               /* 2   - социолога, психолога */
               /* 8   - административный     */
               /* 57  - лаборант             */
               /* 59  - зав.канцелярией      */
               /* 132 - кружки               */
               /* 140 - библиотекарь         */
               /*----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                         */
               /* ставка= база * (100 + % за категорию) * (100 + % спец. ) */
               /* оклад = ставка * ФРВ /НРВ                                */
               /*----------------------------------------------------------*/
               // чтение формы 205
               StartRkv(GetCode(crow));
               // % за категорию
               ReadRkv("ставка",str);
               n4=atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n6=atof(str)/100.;
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
//SNG это моЯ вставка от 13.01.2011=========================================================================================SNG
               ReadRkv("спец_к1",str);
               nSNG1=atof(str);
if (nSNG1==0) nSNG1=1;
               ReadRkv("спец_к2",str);
               nSNG2=atof(str);
if (nSNG2==0) nSNG2=1;
               ReadRkv("спец_к3",str);
               nSNG3=atof(str);
if (nSNG3==0) nSNG3=1;
               ReadRkv("спец_к4",str);
               nSNG4=atof(str);
if (nSNG4==0) nSNG4=1;
               ReadRkv("спец_к5",str);
               nSNG5=atof(str);
if (nSNG5==0) nSNG5=1;
               ReadRkv("спец_к6",str);
               nSNG6=atof(str);
if (nSNG6==0) nSNG6=1;

//=======================================================================================================================SNG
              
ReadRkv("допл", str);
nNAM1 = atof(str);


 FinishRkv();

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */
               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                  r[2]=dney_v_tab(rsimv,calm,z1,z2);
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 

//                 goto return_c;
               }

      // 10.08.99
//               if (data>n11) n4=1.0;
      //---------

               if (n6==0) n6=1;

             //  n1=r[2]*bz*n4*n5*n6/norm(1);
               


// SNG это моЯ вставка от 13.01.2011 ======================================================================================= SNG

             //  n1=n1*nSNG1*nSNG2*nSNG3*nSNG4*nSNG5*nSNG6;

//======================================================================================================================SNG

//Николишин начало 20.09.13
//n1=r[2]*(bz*n5*n6*nSNG1*nSNG2*nSNG3*nSNG4*nSNG5*nSNG6 + nNAM1)/norm(1);
//n1=n1*n4;
//округление без коэффициентом занятости
n1=bz*n5*n6*nSNG1*nSNG2*nSNG3*nSNG4*nSNG5*nSNG6+nNAM1;
round2(n1,2,1,n1); //округляем результат произведения БЗ на коэффициенты с суммой доплаты за метод.литературу
n1=n1*n4*r[2]/norm(1); //приводим сумму в соответствие с фактически отработанным временем и ставкой
//Николишин конец

            break;

      case 11:   /* надбавка в % от ставки изменен 02.2001 */
               /*-----------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                    */
               /* ставка=база * (100 + % за категорию)*(100 + % спец.)*/
               /* надбавка = (ставка * %надбавки * ФРВ) / (НРВ * 100.)*/
               /*-----------------------------------------------------*/
               // чтение формы 205
               StartRkv(GetCode(crow));
               // % надбавки
               ReadRkv("надбавка",str);
               n6=atof(str);
               // % за категорию
               ReadRkv("ставка",str);
               n4=atof(str)/100.;
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n7=1+atof(str)/100.;
               if (n7==0) n7=1;
               FinishRkv();

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */

               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                  r[2]=dney_v_tab(rsimv,calm,z1,z2);
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

               n1=(bz*n4*n5*r[2]*n6*n7)/(norm(1)*100.);

               break;
      case 171:   /* Доплата в часах  02.2001 */
               /*------------------------------------------------------*/
               /* база = оклад                                         */
               /* доплата = кол-во часов * база * процент/НРВ(в часах) */
               /* с учетом спецпроцента школы                          */
               /*------------------------------------------------------*/
               StartRkv(GetCode(crow));
               // % надбавки
               ReadRkv("надбавка",str);
               n6=atof(str);
               // % за категорию
               ReadRkv("катег",str);
               n4=1+atof(str)/100.;
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n7=1+atof(str)/100.;
               if (n7==0) n7=1;
               FinishRkv();

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */

               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                    skoljko(r[2],data,z1,z2,rsimv,calm,cht);     // для Куковякиной 27.12.98
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

               n1=(bz*n5*r[2]*n6*n7)/(norm(2)*100);

               break;


      case 39:    /* оклад дежурного */   /* 02.2001 */
                  /* ночные дежурного */
                  /* праздничные */
               // n7 - коэффициент из сетки 83
               StartRkv(GetCode(crow));
               // % за ночные часы
               ReadRkv("коэффиц",str);
               n4=atof(str)/100.;
               // норма ночных часов
               ReadRkv("норм_наг",str);
               n5=atof(str);
               // % спец.
               ReadRkv("спец_прц",str);
               n6=1+atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n7=1+atof(str)/100.;
               if (n7==0) n7=1;
               FinishRkv();

               if (nkalend==knorm)

               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

               n1=r[2]*bz*n4*n6*n7/n5;

               break;

      case 46: /* категория для замены */
               /* 10 - в младших классах */
               /* 42 - в старших классах */
               /* 46 - ГПД30 */
               /* 42 - ГПД25 */
               /*---------------*/

               // n3 - норма для тарификации из сетки 82
               if (Value_For_Table_Cod(82,ikod,data,n3)==EOF) break;
               if (n3==0.) break;

               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

               n1=(r[2]*bz)/n3;

               break;


      case 116: /* оклад преподавателей */
               /* 116 - младших классов                  */
               /* 117 - старших классов                  */
               /* 118 - ГПД из расчета 25 часов в неделю */
               /* 119 - ГПД из расчета 30 часов в неделю */
               /* 120 - ГПД из расчета 36 часов в неделю */
               /* 135 - компенсирующих мл.классов        */
               /* 136 - компенсирующих ст.классов        */
               /* 145 - концертмейстера                  */
               /* 146 - методиста                        */
               /*-----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                          */
               /* ставка=база * (100+% за категорию) * (100 + % спец.)      */
               /* оклад = (ставка * нагрузка в неделю * ФРВ) /              */
               /*         / (норма для тарификации * НРВ)                   */
               /*-----------------------------------------------------------*/
               // n3 - норма для тарификации из сетки 82
               if (Value_For_Table_Cod(82,ikod,data,n3)==EOF) break;
               if (n3==0.) break;
               // чтение формы 205
               StartRkv(GetCode(crow));
               // нагрузка в часах за неделю
               ReadRkv("нагрузка",str);
               n2=atof(str);
//SNG это моЯ вставка от 13.01.2011=========================================================================================SNG
               ReadRkv("спец_к1",str);
               nSNG1=atof(str);
if (nSNG1==0) nSNG1=1;
               ReadRkv("спец_к2",str);
               nSNG2=atof(str);
if (nSNG2==0) nSNG2=1;
               ReadRkv("спец_к3",str);
               nSNG3=atof(str);
if (nSNG3==0) nSNG3=1;
               ReadRkv("спец_к4",str);
               nSNG4=atof(str);
if (nSNG4==0) nSNG4=1;
               ReadRkv("спец_к5",str);
               nSNG5=atof(str);
if (nSNG5==0) nSNG5=1;
               ReadRkv("спец_к6",str);
               nSNG6=atof(str);
if (nSNG6==0) nSNG6=1;
//=======================================================================================================================SNG
 
ReadRkv("допл", str);
nNAM1 = atof(str);


              FinishRkv();

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */
               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                  r[2]=dney_v_tab(rsimv,calm,z1,z2);
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

               if (data>n11) n4=1.0;

           //    n1=(r[2]*bz*n2)/(n3*norm(1));
    //         n1=(r[2]*bz*n2*n4*n5)/(n3*norm(1));


// SNG это моЯ вставка от 13.01.2011 ======================================================================================= SNG

           //    n1=n1*nSNG1*nSNG2*nSNG3*nSNG4*nSNG5*nSNG6;

//======================================================================================================================SNG

//Николишин начало 20.09.13
//n1=n2*(bz*nSNG1*nSNG2*nSNG3*nSNG4*nSNG5*nSNG6+nNAM1)/n3;
//n1=r[2]*n1/norm(1);
n1=bz*nSNG1*nSNG2*nSNG3*nSNG4*nSNG5*nSNG6+nNAM1;
round2(n1,2,1,n1); //округляем результат произведения БЗ на коэффициенты с суммой доплаты за метод.литературу
n1=n1*n2/n3; //приводим сумму в соответствии с нагрузкой
n1=n1*r[2]/norm(1); //приводим сумму в соответствие с фактически отработанным временем
//Николишин конец

               break;

      case 601:  // Простои (в школьной версии это 601 алгоритм, а в стандартной 121)
               kod_alg=121;
               RetFlag=3;
               break;

      case 121: /* надбавки в школе 02.2001 */
               /* 22  - административная надбавка      */
               /* 70  - книжный фонд                   */
               /* 121 - классное рук-во                */
               /* 122 - проверка тетрадей в мл.классах */
               /* 124 - кабинет                        */
               /* 125 - метод.об"единение              */
               /* 131 - переполняемость классов        */
               /* 133 - ЗПР                            */
               /* 134 - аттестационная комиссия        */
               /* 138 - новые программы                */
               /* 139 - прочие надбавки                */
               /* 113 - проф.надбавка                  */
               /*-----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                          */
               /* ставка=база * (100+% за категорию) * (100 + % спец.)      */
               /* надбавка = ставка * % надбавки * ФРВ / НРВ                */
               /*-----------------------------------------------------------*/
               // чтение формы 205
               StartRkv(GetCode(crow));
               // % надбавки
               ReadRkv("надбавка",str);
               n6=atof(str);
               // % за категорию
               ReadRkv("неисп",str);   /*катег Изменено ХВМ 15.03.04 */
               n4=atof(str)/100.;
               if (n4==0) n4=1;        /*добавлена ХВМ 15.03.04 */
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n7=1+atof(str)/100.;
               if (n7==0) n7=1;
               FinishRkv();

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */

               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                  r[2]=dney_v_tab(rsimv,calm,z1,z2);
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

               n1=(bz*n4*n5*r[2]*n6*n7)/(norm(1)*100.);

               break;

      case 123:      /* 02.2001 */
               /* надбавка за проверку тетрадей в зависимости от часов */
               /* 123 - в ст.классах               */
               /* 144 - в мл.классах (иностр.язык) */
               /* 143 - надбавка за опекаемых      */
               /*-----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                          */
               /* ставка=база * (100+% за категорию) * (100 + % спец.)      */
               /* надбавка = (ставка * нагрузка * % надб-ки * ФРВ) /        */
               /*          / (норма для тарификации * НРВ * 100.)           */
               /*-----------------------------------------------------------*/
               /*-----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                          */
               /* ставка=база * (100+% за категорию) * (100 + % спец.)      */
               /* надб.за опек.=(ставка * кол-во.опек. * %надб-ки * ФРВ) /  */
               /*         / (норма для тарификации * НРВ * 100.)            */
               /*-----------------------------------------------------------*/
               // n3 - норма для тарификации из сетки 82
               if (Value_For_Table_Cod(82,ikod,data,n3)==EOF) break;
               if (n3==0.) break;
               // чтение формы 205
               StartRkv(GetCode(crow));
               // % надбавки
               ReadRkv("надбавка",str);
               n6=atof(str);
               // нагрузка или кол-во опекаемых
               ReadRkv("нагрузка",str);
               n2=atof(str);
               // % за категорию
               ReadRkv("катег",str);
               n4=1+atof(str)/100.;
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n7=1+atof(str)/100.;
               if (n7==0) n7=1;
               FinishRkv();

               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                  r[2]=dney_v_tab(rsimv,calm,z1,z2);
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

              // if (data>n11) n4=1.0;

               n1=(r[2]*bz*n2*n4*n5*n6*n7)/(n3*norm(1)*100.);

               r[2]=n6;

               break;

      case 126: /* замена */   /* 02.2001 */
               /* 126 - в младших классах */
               /* 127 - в старших классах */
               /* 128 - ГПД30 */
               /* 142 - ГПД25 */
               /* 129 - кружков */
               /*-----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                          */
               /* ставка=база * (100+% за категорию) * (100 + % спец.)      */
               /* оклад = (ставка * часы замены * ФРВ) /                    */
               /*         / (норма для тарификации * НРВ)                   */
               /*-----------------------------------------------------------*/
               // n3 - норма для тарификации из сетки 82
               if (Value_For_Table_Cod(82,ikod,data,n3)==EOF) break;
               if (n3==0.) break;
               // чтение формы 205
               StartRkv(GetCode(crow));
               // % за категорию
               ReadRkv("ставка",str);
               n4=atof(str)/100.;
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
               // % повышения оплаты
               ReadRkv("пов_опл",str);
               n7=1+atof(str)/100.;
               if (n7==0) n7=1;
               FinishRkv();

               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

//               if (data>n11) n4=1.0;

               n1=(r[2]*bz*n4*n5*n7)/n3;

               break;

      case 130: /* надбавка за вредность  */ /* 02.2001 */
               /*-----------------------------------------------------------*/
               /* база(bz) = разряд . % от разряда                          */
               /* ставка=база * (100+% за категорию) * (100 + % спец.)      */
               /* надб. = (ставка * нагрузка * % надб-ки * коэф. * ФРВ) /   */
               /*          / (норма для тарификации * НРВ * 100.)           */
               /*-----------------------------------------------------------*/

 /*    ПОДМЕНА НА ИЗМЕНЕННЫЙ АЛГОРИТМ 116 */

               // n3 - норма для тарификации из сетки 82
               if (Value_For_Table_Cod(82,ikod,data,n3)==EOF) break;
               if (n3==0.) break;
               // чтение формы 205
               StartRkv(GetCode(crow));
               // нагрузка в часах за неделю
               ReadRkv("нагрузка",str);
               n2=atof(str);
               // % за категорию
               ReadRkv("катег",str);
               n4=1+atof(str)/100.;
               // % спец.
               ReadRkv("спец_прц",str);
               n5=1+atof(str)/100.;
               // % повышения оплаты - результат только доплата.
               ReadRkv("пов_опл",str);
               n7=atof(str)/100.;
               if (n7==0) n7=1;
               FinishRkv();

               worktime(crow,b3,0); /* заполнение рабоч.дней в табеле */
               if (nkalend==knorm)
                  /* если строка считается по основному графику ЛС */
                  r[2]=dney_v_tab(rsimv,calm,z1,z2);
               if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
               {
                 RetFlag=code_ReturnCode;
                 break; 
//                 goto return_c;
               }

               if (data>n11) n4=1.0;

               n1=(r[2]*bz*n2*n4*n5*n7)/(n3*norm(1));

               break;

      case 137:   /* Празничные для УО Снежинск 02.2001 */
               if (data<n11)
               {
                {
//                  Struct_Alg Work;
//                  int mes1=0,mes2=0,stolbec=ST_PROCNADB+1;
//                  Get_AlgWithParam(Work,ikod);   // 31.01.1995
                  // Work.Count_Par - число паpаметpов для кода алгоpитма
                  //-- параметр 1 - столбец таблицы входимости (по умолчанию = 18)
//                  if (Work.Count_Par>0)
//                     { i=atoi(Work.List_Par[0]);
//                        if (i>0 && i<=99) stolbec=i; }
                  //-- параметр 2 - месяц начала выборки (относительно расчетного)
                  //   (по умолчанию берется за один текущий месяц)
//                  if (Work.Count_Par>1)
//                     { i=atoi(Work.List_Par[1]);
//                        if (i>=(-PMES) && i<=BMES) mes1=mes2=i; }
                  //-- параметр 3 - месяц конца выборки (относительно расчетного)
                  //   (по умолчанию берется за один месяц, указанный параметром 2)
//                  if (Work.Count_Par>2)
//                     { i=atoi(Work.List_Par[2]);
//                        if (i>=mes1 && i<=BMES) mes2=i; }
//                  n5=0.;
//                  for(m=mes1;m<=mes2;m++)
//                     { s1001("*",d1,d2,m,stolbec-1,r9,4); n5+=r9; }

//                StartRkv(GetCode(crow));
                // нагрузка
//                ReadRkv("нагрузка",str);
//                n2=atof(str);
//                ReadRkv("пр_нормы",str); //признак нормы в доп.парам. "нагрузка"
//                n4=atof(str);
//                n6=bz;             //Если в графике, то в bz- 0, а коэф-нт = 2
//                if (n6==0) n6=2;
//                else
//                 if (n6==2) n6=2;
//                 else n6=1;
//                FinishRkv();

//                if ( (c=korrv(r,t,0,h,flagrow,jf)) != 1 ) 
//                {
//                 RetFlag=code_ReturnCode;
//                 break; 
////                 goto return_c;
//                }


//                  n1=n5*bz*r[2]/n2;
//                }
//                RetFlag=code_MDefault;
                break;
////               goto mdfault;
               }
//               else
//               {
//               if (Value_For_Table_Cod(87,ikod,data,n3)==EOF) break;
//               n1=n3;
               break;

               }



      // конец описания алгоритмов пользователя

      // Пример вызова алгоритма пользователя.

       case 777:
         return UserAlg777(info,r);

       case 778:
         return UserAlg778(info,r);

       case 779:
         return UserAlg779(info,r);

       case 780:
         return UserAlg780(info,r);

       case 616:
         return UserAlg616(info,r);

       case 520:
         return UserAlg520(info,r);

       case 521:
         return UserAlg521(info,r);

       case 522:
         return UserAlg522(info,r);

       case 523:
         return UserAlg523(info,r);

       case 524:
         return UserAlg524(info,r);

       case 525:
         return UserAlg525(info,r);

 // алгоритм процентных надбавок от УДО
       case 526:
         return UserAlg526(info,r);

// Индикатив учителя
       case 527:
         return UserAlg527(info,r);


      case 898:
       return UserAlg898(info,r);


      //case 4:
      //   return UserAlg4(info,r);

      // case 712:
      //   return UserAlg712(info,r);

      default:
         RetFlag=0;
         break;
   }

   if ( RetFlag )
   {
      info.crow            = crow,
      info.b3              = b3,
      info.kod             = kod,
   //   info.koef1            = koef1,
      info.ikod            = ikod,
      info.kod_alg         = kod_alg,
      info.n1              = n1,
      info.d1              = d1,
      info.d2              = d2,
      info.pos             = pos,
      info.mkat            = mkat,
      info.krabot          = krabot,
      info.tip_s9600       = tip_s9600,
      info.flag_propusk0   = flag_propusk0,
      info.z1              = z1,
      info.z2              = z2,
      info.h[0]            = h[0],
      info.h[1]            = h[1],
      info.h[2]            = h[2],
      info.h[3]            = h[3],
      info.bz              = bz;

      if (c<=-4096) c=1;
      info.c               = c;
   }
   return RetFlag;
}


//******************************Начало Индикатива******************
UserAlg527(&info,&r) //Индикатив учителя
{
//объявляем переменные
    char t[20];
    double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;
    
//точный код вида, действующий в mrasch
    double kod=FindValidVid(85);

//определяем коэф. 185 Нагрузка
  StartRkv(85);
  char str[256];
  ReadRkv("koef_1",str);
  double k1=atof(str);
  if (k1==0.000) k1=18.00;
	  FinishRkv();

//Определяем коэф. нагрузки
  double k2=k1/18;

		/*  double koef=k2+k1; 
		  //ограничиваем коэф.
		  if (koef>18.000) koef=18.00;
		  FinishRkv();
		*/

// заполнение рабоч.дней в табеле 
  worktime(info.crow,info.b3,0);
  if(nkalend == knorm)
      r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);
  if ((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1) return code_ReturnCode;

//Вычисляем
		//    round2(n5,2,1,n5); //округляем результат произведения БЗ 
    n4=info.bz*k2;
    info.n1=r[2]*n4/norm(1);

  if(FL_V_ALG && uprc != NO_SCREEN)
  {
      infolist.add_record("Уст.Индикатив",info.bz);
      infolist.add_record("Нагрузка",k1);
      infolist.add_record("Коэф.Нагрузки",k2);
      infolist.add_record("Индикатив",n4);
      infolist.add_record("НРВ",norm(1));
      infolist.add_record("ФРВ",r[2]);
      infolist.add_record("Результат",info.n1);
  }
  return code_Break;
}
//******************************Конец Индикативу******************


UserAlg898(&info,&r) /* Доплата до МРОТ */
{    
   double Epsilon = 0.00001;
   struct Struct_Alg Work;
   //значения параметров по умолчанию: 19,86,0,0,0,0 
   Get_AlgWithParamEx(Work, info.ikod, "19,86,0,0,0,0");
   //-- параметр 1 - столбец таблицы входимости (по умолчанию 19) 
   int stolbec =19;
   int param=atoi(reinterpret_cast_to_string(Work.List_Par[0]));
   if ( param>0 && param<=99 ) stolbec=param;

   //-- параметр 2 - Номер сетки для МРОТ (по умолчанию 86) 
   int numberSet=86;
   param=atoi(reinterpret_cast_to_string(Work.List_Par[1]));
   if ( param>0 ) numberSet = param;

   //-- параметр 3 - Номер строки в сетке (по умолчанию 0) 
   int rowSet=0;
   param=atoi(reinterpret_cast_to_string(Work.List_Par[2]));
   if ( param > 0 && param <= 999) rowSet=param;

   //-- параметр 4 - Тип ФРВ:
   // 0 - в часах (по умолчанию)
   // 1 - в днях
   bool bHours= atoi(reinterpret_cast_to_string(Work.List_Par[3]))==0;
   int idxNorm = bHours?2:1;

   //-- параметр 5 - Увеличить МРОТ на РК и Северные (постановление КС от 07.12.2017 № 38-П)
   // 0 - доплата до "чистого МРОТ" (по умолчанию)
   // 1 - доплата до "МРОТ*(РК + Северные)"
   bool bUseRk=atoi(reinterpret_cast_to_string(Work.List_Par[4]))!=0;

   //-- параметр 6 - Особенности расчета доплаты (флаги):
   // 0x01 - не рассчитывать доплату, если ФРВ/НРВ<1
   // 0x02 - Ограничить ФРВ/НРВ единицей
   // 0x04 - вычислять ФРВ/НРВ через s98()
   // 0x08 - не заполнять табель (заводят вид "навсегда" и не хотят чтобы у уволенных делался расчет)
   // 0x10 - не заполнять РВ в виде (мешается в сводах и выборках)
   int Flag=atoi(reinterpret_cast_to_string(Work.List_Par[5]));
   bool  calcOnlyFullMonth=(Flag & 0x01)!=0;
   bool  limitFrv         =(Flag & 0x02)!=0;   
   bool  useS98           =(Flag & 0x04)!=0; 
   bool  fillTabel        =(Flag & 0x08)==0; 
   bool  fillRv           =(Flag & 0x10)==0;

   double frv_nrv=1.;
   if(fillTabel)		
      worktime(info.crow,info.b3,0); /* заполнение рабоч.дней в табеле */
   //ФРВ
   if (useS98)
      s98(0,frv_nrv);
   else
   {
      if (nkalend==knorm) 
      {
         if (!bHours) r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);
         else skoljko(r[2],data,info.z1,info.z2,rsimv,calm,cht);
      }
      char t[20];
      if(fillRv && (info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)  return code_ReturnCode;
      frv_nrv=r[2]/norm(idxNorm);
   }
   // До 04.2018 было окргуление коэффициента. Убрали его только с 04.2018
   // чтобы у людей не полез пересчет за прошлые месяцы на копейки.
   if ( mrasch<364 ) roundd(frv_nrv, 2, frv_nrv);
   if ( limitFrv && frv_nrv>1+Epsilon ) frv_nrv=1.;   
		 
   //сумма выборки
   double summ=0.;
   s100("н",0,stolbec-1,summ);
   //сумма выборки не может быть отрицательной
   if(summ<-Epsilon) summ=0.;		

   // Коэффициент занятости из КЧ
//char strTemp[11];
//var D = KDateFromInt_WithDay(countday,mrasch);
   //GetKchValue("k_employ",strTemp,10,D);
   //if (Str_Cmp(strTemp," "," ")!=0) k_employ=atof(strTemp);
//double k_employ=GetKoefEmployment(D,0,0x1);


   //"чистый" МРОТ
   double mrot=0.;
   int CodOrg = GetOrgForPodr(GetPodrOfCod(info.kod));
   if (Value_For_Table_CodO(numberSet, CodOrg, rowSet, data, mrot) == EOF) mrot=info.bz; 


   // Определяемся с районными и северными надбавками
   double  rk_sev = 0.;
   if( bUseRk )
   {
      rk_sev= DefineRkFull(data+countday/100.,false);
      //2018.03.20 - процент северных определяем только в том случае, если в ЛС нашли действующую строку вида "северной надбавки"
      //вид является "северной надбавкой", если у его алгоритм один из: "96,97,186,187" 
      if (FindSevNu(mrasch)) rk_sev += DefineSev(mrasch,0.,0.);
   }

   //МРОТ для расчета
double k=info.bz/18;
   double mrot_frv_nrv=mrot*k*frv_nrv*(1 + rk_sev);
   roundd(mrot_frv_nrv, 2, mrot_frv_nrv);

   info.n1 = ( summ>mrot_frv_nrv || 
               calcOnlyFullMonth && frv_nrv+Epsilon<1. ) ? 0.
                                                         : mrot_frv_nrv-summ;
   if( FL_V_ALG && uprc!=NO_SCREEN )
   {
      if( !useS98 )
      {
         infolist.add_record("ФРВ",r[2]);
         infolist.add_record("НРВ",norm(idxNorm));
      }
      if ( limitFrv )
         infolist.add_record("ФРВ/НРВ не больше 1", "да");
      infolist.add_record("ФРВ/НРВ",frv_nrv);
      infolist.add_record("Столбец выборки",stolbec);
      infolist.add_record("Сумма выборки",summ);
      infolist.add_record("-----------------------","------------------------------");
      infolist.add_record("Номер сетки для МРОТ",numberSet);
      infolist.add_record("Номер строки в сетке",rowSet);
      infolist.add_record("МРОТ",mrot);
      infolist.add_record("Коэфф.занятости",k);
		if (bUseRk) infolist.add_record("% РК и Северных", rk_sev*100.);
      infolist.add_record("МРОТ для расчета",mrot_frv_nrv);
      infolist.add_record("-----------------------","------------------------------");
      if (calcOnlyFullMonth && frv_nrv+Epsilon<1. )
      	infolist.add_record("Доплата не нужна", "ФРВ/НРВ<1");
      infolist.add_record("Доплата",info.n1);
   } 
   if (!fillRv) r[2] = 0;

   return code_Break;
}


//*************Начало алгоритмов 2023***************


UserAlg520(&info,&r) // нагрузка, ВнеурочнаяД
{
  char t[20]; 
  char str[256];
  double n2, n5, n4, n9;

	if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
      return code_ReturnCode;

// Добавляем базовое значение вида 918 УДО
      double okl;
      poiskbz(0,818,0,"УДО",okl);
	

//точный код вида, действующий в mrasch
    double kod=FindValidVid(818);

//определяем повышающий коэф. 918 Образование 
  StartRkv(818);
  ReadRkv("спец_к1",str);
  double k1=atof(str);
  if (k1==0) k1=1;

//определяем повышающий коэф. 918 Квалификация
  StartRkv(818);
  ReadRkv("спец_к2",str2);
  double k2=atof(str2);
  if (k2==0) k2=1;

//определяем повышающий коэф. 918 ПедСтаж
  StartRkv(818);
  ReadRkv("спец_к3",str3);
  double k3=atof(str3);
  if (k3==0) k3=1;

//определяем повышающий коэф. 918 специфика
  StartRkv(818);
  ReadRkv("спец_к3",str3);
  double k4=atof(str3);
  if (k4==0) k4=1;

  FinishRkv();

/*
      int stolbec=37;    // Столбец ТВХ по умолчанию
//-- параметр 2 - выборка сумм по месяцу начисления
      s100simv("1","н",0,stolbec-1,n5,0);
*/

// заполнение рабоч.дней в табеле 
  worktime(info.crow,info.b3,0);
  if(nkalend == knorm)
      r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);
  if ((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1) return code_ReturnCode;

//Вычисляем
	n5=okl*k1*k2*k3*1.2;
    info.n1=r[2]*(n5*info.bz)/norm(1);
    if(FL_V_ALG&&uprc!=NO_SCREEN)
        {
          infolist.add_record("Столбец",stolbec);
          infolist.add_record("УДО_БЗ",okl);
          infolist.add_record("Образование",k1);
          infolist.add_record("Квалификация",k2);
          infolist.add_record("ПедСтаж",k3);
          infolist.add_record("Специфика",k4);
          infolist.add_record("Оклад (РУБ)",n5);
          infolist.add_record("Ставка",info.bz);
          infolist.add_record("НРВ",norm(1));
          infolist.add_record("ФРВ",r[2]);
          infolist.add_record("ОкладСт",info.n1);
          }
return code_Break;
}

UserAlg521(&info,&r) // Нагрузка, ВнеурочнаяД
{
   char t[20]; 
   char str[81];
   double n2, n5, n4, n9;

//точный код вида, действующий в mrasch
    double kod=FindValidVid(818);

  	int stolbec=37;    // Столбец ТВХ по умолчанию

  //-- параметр 2 - выборка сумм по месяцу начисления
  	s100simv("1","н",0,stolbec-1,n5,0);

// заполнение рабоч.дней в табеле 
   worktime(info.crow,info.b3,0);
   if(nkalend == knorm)
      r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);
   if ((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1) return code_ReturnCode;

//Вычисляем
	n4=n5/18;
	info.n1=r[2]*((n5/18)*info.bz)/norm(1);
	if(FL_V_ALG&&uprc!=NO_SCREEN)
         {
           infolist.add_record("Столбец",stolbec);
           infolist.add_record("Сумма выборки",n5);
           infolist.add_record("Нагрузка (1час)",n4);
           infolist.add_record("Нагрузка недельная",info.bz);
           infolist.add_record("УстДолОкл (РУБ)",info.n1);
           infolist.add_record("НРВ",norm(1));
           infolist.add_record("ФРВ",r[2]);
          }
 return code_Break;
}

UserAlg522(&info,&r) // замещение нагрузка
{
   char t[20]; 
   char str[81];
   double n2, n5, n4, n9;

  	int stolbec=37;    // Столбец ТВХ по умолчанию

  //-- параметр 2 - выборка сумм по месяцу начисления
  	s100simv("1","н",0,stolbec-1,n5,0);

// заполнение рабоч.дней в табеле 
   worktime(info.crow,info.b3,0);
   if(nkalend == knorm)
      r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);
   if ((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1) return code_ReturnCode;

//Вычисляем
	n4=n5/info.bz;
	info.n1=r[2]*n4;
	if(FL_V_ALG&&uprc!=NO_SCREEN)
         {
           infolist.add_record("Столбец",stolbec);
           infolist.add_record("Сумма выборки",n5);
           infolist.add_record("Коэф.Нагрузки (ср/год)",info.bz);
           infolist.add_record("Нагрузка (час)",n4);
           infolist.add_record("ФРВ",r[2]);
           infolist.add_record("Результат",info.n1);
          }
 return code_Break;
}

UserAlg523(&info,&r) //Индивидуальные домашние часы
{
//объявляем переменные
    char t[20];
    double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;

//Запрос рабочего времени
    if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
    return code_ReturnCode;

// Добавляем значение вида 918 нагрузка
      double okl=0.;
      poiskbz(0,818,0,"Оклад",okl);

//точный код вида, действующий в mrasch
	double kod;
	kod = FindValidVid(818);

//определяем повышающий коэф. 918 Образование 
  StartRkv(818);
  char str[256];
  ReadRkv("спец_к1",str);
  double k1=atof(str);
  if (k1==0) k1=1;

//определяем повышающий коэф. 918 Квалификация
  //StartRkv(818);
  char str2[256];
  ReadRkv("спец_к2",str2);
  double k2=atof(str2);
  if (k2==0) k2=1;

//определяем повышающий коэф. 918 ПедСтаж
  StartRkv(818);
  char str3[256];
  ReadRkv("спец_к3",str3);
  double k3=atof(str3);
  if (k3==0) k3=1;


  double k4=1.2;


/*  double koef=k2+k1; 

  //ограничиваем коэф.
  if (koef>18.000) koef=18.00;
  FinishRkv();
*/

  worktime(info.crow,info.b3,0);

//Вычисляем
    n5=okl*k1*k2*k3*1.2;
    round2(n5,2,1,n5); //округляем результат произведения БЗ 
    n4=n5/info.bz;
    info.n1=r[2]*n4;

  if(FL_V_ALG && uprc != NO_SCREEN)
  {
      infolist.add_record("Оклад",okl);
      infolist.add_record("_Образование",k1);
      infolist.add_record("_Квалификация",k2);
      infolist.add_record("_ПедСтаж",k3);
      infolist.add_record("_Специфика",k4);
      infolist.add_record("ОклИндЗан",n5);
      infolist.add_record("1 час Ср/год",info.bz);
      infolist.add_record("ОклИндЗан (1 час)",n4);
      infolist.add_record("ФРВ",r[2]);
      infolist.add_record("Результат",info.n1);
  }
  return code_Break;
}

UserAlg524(&info,&r) //Индивидуальные домашние часы
{
//объявляем переменные
    char t[20];
    double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;
    
      if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
        return code_ReturnCode;

// Добавляем значение вида 918 нагрузка
      double okl;
      poiskbz(0,818,0,"Оклад",okl);
  
//точный код вида, действующий в mrasch
    double kod=FindValidVid(3);

//определяем повышающий коэф. 918 Образование 
  StartRkv(818);
  char str[256];
  ReadRkv("спец_к1",str);
  double k1=atof(str);

//определяем повышающий коэф. 918 Квалификация
  StartRkv(818);
  char str2[256];
  ReadRkv("спец_к2",str2);
  double k2=atof(str2);

//определяем повышающий коэф. 918 ПедСтаж
  StartRkv(818);
  char str3[256];
  ReadRkv("спец_к3",str3);
  double k3=atof(str3);

  double k4=1;


/*  double koef=k2+k1; 

  //ограничиваем коэф.
  if (koef>18.000) koef=18.00;
  FinishRkv();
*/

  worktime(info.crow,info.b3,0);

//Вычисляем
    n5=okl*k1*k2*k3*1.2;
    round2(n5,2,1,n5); //округляем результат произведения БЗ 
    n4=n5/info.bz;
    info.n1=r[2]*n4;

  if(FL_V_ALG && uprc != NO_SCREEN)
  {
      infolist.add_record("Оклад",okl);
      infolist.add_record("_Образование",k1);
      infolist.add_record("_Квалификация",k2);
      infolist.add_record("_ПедСтаж",k3);
      infolist.add_record("_Специфика",k4);
      infolist.add_record("ОклИндЗан",n5);
      infolist.add_record("1 час Ср/год",info.bz);
      infolist.add_record("ОклИндЗан (1 час)",n4);
      infolist.add_record("ФРВ",r[2]);
      infolist.add_record("Результат",info.n1);
  }
  return code_Break;
}

UserAlg525(&info,&r) //Индивидуальные домашние часы
{
//объявляем переменные
    char t[20];
    double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;
    
      if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
        return code_ReturnCode;

// Добавляем значение вида 918 нагрузка
      double okl;
      poiskbz(0,818,0,"Оклад",okl);
  
//точный код вида, действующий в mrasch
    double kod=FindValidVid(3);

//определяем повышающий коэф. 918 Образование 
  StartRkv(818);
  char str[256];
  ReadRkv("спец_к1",str);
  double k1=atof(str);

//определяем повышающий коэф. 918 Квалификация
  StartRkv(818);
  char str2[256];
  ReadRkv("спец_к2",str2);
  double k2=atof(str2);

//определяем повышающий коэф. 918 ПедСтаж
  StartRkv(818);
  char str3[256];
  ReadRkv("спец_к3",str3);
  double k3=atof(str3);

  double k4=1.2;


/*  double koef=k2+k1; 

  //ограничиваем коэф.
  if (koef>18.000) koef=18.00;
  FinishRkv();
*/

  worktime(info.crow,info.b3,0);

//Вычисляем
    n5=okl*k1*k2*k3;
    round2(n5,2,1,n5); //округляем результат произведения БЗ 
    n4=n5/info.bz;
    info.n1=r[2]*n4;

  if(FL_V_ALG && uprc != NO_SCREEN)
  {
      infolist.add_record("Оклад",okl);
      infolist.add_record("_Образование",k1);
      infolist.add_record("_Квалификация",k2);
      infolist.add_record("_ПедСтаж",k3);
      infolist.add_record("_Специфика",k4);
      infolist.add_record("ОклИндЗан",n5);
      infolist.add_record("1 час Ср/год",info.bz);
      infolist.add_record("ОклИндЗан (1 час)",n4);
      infolist.add_record("ФРВ",r[2]);
      infolist.add_record("Результат",info.n1);
  }
  return code_Break;
}

UserAlg526(&info,&r) // Алгоритм процентных надбавок от УДО
{
  char t[20]; 
  char str[81];
  double n2, n5, n4, n9;

      int stolbec=37;    // Столбец ТВХ по умолчанию
//-- параметр 2 - выборка сумм по месяцу начисления
      s100simv("1","н",0,stolbec-1,n5,0);

	r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);

//Вычисляем
   
    info.n1=r[2]*(n5*(info.bz/100))/norm(1);
    if(FL_V_ALG&&uprc!=NO_SCREEN)
        {
          infolist.add_record("Столбец",stolbec);
          infolist.add_record("УстДолОкл (РУБ)",n5);
          infolist.add_record("%",info.bz);
          infolist.add_record("НРВ",norm(1));
          infolist.add_record("ФРВ",r[2]);
          }
return code_Break;
}

UserAlg616(&info,&r) //Стаж непрерывный учителя
{
 //объявляем переменные
	char t[20];
	double n2,n3,n4,r4,r8,r9,k,udo;

  	int stolbec=37;    // Столбец ТВХ по умолчанию

  // выборка сумм по месяцу начисления
  	s100simv("1","н",0,stolbec-1,n4,0);
    
     if(nkalend == knorm)
     r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);

     if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
     return code_ReturnCode;

 //Определяем Базовое значение вида 105 
      double n5;
      poiskbz(0,5,0,"НагрузкаМК",n5);

 //Определяем Базовое значение вида 106 
      double n6;
      poiskbz(0,6,0,"НагрузкаСрК",n6);

 //Определяем Базовое значение вида 107 
      double n7;
      poiskbz(0,7,0,"НагрузкаСтК",n7);

 //Определяем Базовое значение вида 109 
      double n9;
      poiskbz(0,9,0,"ЭлективМК",n9);

 //Определяем Базовое значение вида 110 
      double n10;
      poiskbz(0,10,0,"ЭлективСрК",n10);

 //Определяем Базовое значение вида 111 
      double n11;
      poiskbz(0,11,0,"ЭлективСтК",n11);

 //Определяем Базовое значение вида 112 
      double n12;
      poiskbz(0,12,0,"ВнеурочМК",n12);

 //Определяем Базовое значение вида 114 
      double n14;
      poiskbz(0,14,0,"ВнеурочСрК",n14);

 //Определяем Базовое значение вида 115 
      double n15;
      poiskbz(0,15,0,"ВнеурочСтК",n15);

//      s1001simv(StrSimv,"*",info.d1,info.d2,m,stolbec-1,r9,4,0);

      double koef1=n5+n6+n7+n9+n10+n11+n12+n14+n15;

   //ограничиваем коэф.
   if (koef1>18.000) koef1=18.00;

   worktime(info.crow,info.b3,0);
	double n16=koef1/18;
	double n17=n16*n4;
	double n18=n17*info.bz/100;
	info.n1=r[2]*(n18/norm(1));

    if(FL_V_ALG && uprc != NO_SCREEN)
   {
      infolist.add_record("УстДолОкл(РУБ)",n4);
      infolist.add_record("Коэф.Нагрузка",koef1);
      infolist.add_record("КоэфРасч",n16);
      infolist.add_record("ДолжОкл",n17);
      infolist.add_record("Стаж (%)",info.bz);
      infolist.add_record("ДолжОклСтаж",n18);
      infolist.add_record("НРВ",norm(1));
      infolist.add_record("РВ",r[2]);
      infolist.add_record("Результат",info.n1);
   }
   return code_Break;
}



UserAlg777(&info,&r) //Непрерывный стаж (нагрузка+факультатив)
{
 //объявляем переменные
	char t[20];
	double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;
    
     if(nkalend == knorm)
         r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);

      if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
         return code_ReturnCode;

// Добавляем значение вида 105 нагрузкаМК
      double okl4;
      poiskbz(0,5,0,"Оклад",okl4);

// Добавляем значение вида 106 нагрузкаСрК
      double okl6;
      poiskbz(0,6,0,"Оклад",okl6);

// Добавляем значение вида 107 нагрузкаСтК
      double okl7;
      poiskbz(0,7,0,"Оклад",okl7);
  
//точный код вида, действующий в mrasch
	double kod=FindValidVid(3);

//определяем повышающий коэф. 103 нагрузки 
//   StartRkv(3);
//   char str[256];
//   ReadRkv("koef1",str);
//   double k1=atof(str);
 

	double koef1=okl4+okl6+okl7; 

   //ограничиваем коэф.
   if (koef1>18.000) koef1=18.00;
   FinishRkv();


   worktime(info.crow,info.b3,0);
   info.n1=r[2]*(info.bz*(okl*koef1/18)/100)/norm(1);
   if(FL_V_ALG && uprc != NO_SCREEN)
   {
      infolist.add_record("Оклад",okl);
      infolist.add_record("Коэф.",koef1);
      infolist.add_record("Коэф.103",k1);
      infolist.add_record("Коэф.105",k2);
      infolist.add_record("Процент",info.bz);
      infolist.add_record("Результат",info.n1);
   }
   return code_Break;
}

UserAlg778(&info,&r) //сложность напряженность (нагрузка БЗ+тетради НК)

{
      //объявляем переменные
	char t[20];
	double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;
    
     if(nkalend == knorm)
         r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);

      if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
         return code_ReturnCode;
   
//точный код вида, действующий в mrasch
   double kod=FindValidVid(3);

   //определяем повышающий коэф.

   StartRkv(23);
   char str[256];
   ReadRkv("koef1",str);
   double k1=atof(str);
   FinishRkv();
   //определяем БЗ 
   double okl=0.;
   poiskbz(0,3,1," ",okl);

   worktime(info.crow,info.b3,0);
   info.n1=r[2]*(info.bz*(okl*k1/18)/100)/norm(1);
   if(FL_V_ALG && uprc != NO_SCREEN)
   {
      infolist.add_record("Нагрузка 103",okl);
      infolist.add_record("Коэф.123",k1);
      infolist.add_record("Процент",info.bz);
      infolist.add_record("Результат",info.n1);
   }
   return code_Break;
}

UserAlg779(&info,&r) //Стаж
{
 //объявляем переменные
	char t[20];
	double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;
    
     if(nkalend == knorm)
         r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);

      if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
         return code_ReturnCode;

// Добавляем значение вида 103 нагрузка
      double okl;
      poiskbz(0,3,0,"Оклад",okl);
  
//точный код вида, действующий в mrasch
	double kod=FindValidVid(3);

//определяем повышающий коэф. 103 нагрузки 
   StartRkv(3);
   char str[256];
   ReadRkv("koef1",str);
   double k1=atof(str);
 
//определяем повышающий коэф. 105 факультатив
   StartRkv(5);
   char str2[256];
   ReadRkv("koef1",str2);
   double k2=atof(str2);

	double koef1=k2+k1; 

   //ограничиваем коэф.
   if (koef1>18.000) koef1=18.00;
   FinishRkv();


   worktime(info.crow,info.b3,0);
   info.n1=(info.bz*(okl*koef1/18))*r[2]/norm(1);
   if(FL_V_ALG && uprc != NO_SCREEN)
   {
      infolist.add_record("Оклад",okl);
      infolist.add_record("Коэф.",koef1);
      infolist.add_record("Коэф.103",k1);
      infolist.add_record("Коэф.105",k2);
      infolist.add_record("Процент",info.bz);
      infolist.add_record("Результат",info.n1);
   }
   return code_Break;
}

UserAlg780(&info,&r) //Индивидуальные занятия
			/* ИндЗан = УДО/КоэфСет(82)*РВ  */
{
 //объявляем переменные
	char t[20];
	double n2,n3,n4,n5,n6,n7,n8,n9,n10,n12,n13,r4,r8,r9,k;
    
     if(nkalend == knorm)
         r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);

      if((info.c=korrv(r,t,0,info.h,flagrow,jf)) != 1)
         return code_ReturnCode;

// Добавляем значение вида 918 
      double okl;
      poiskbz(0,818,0,"Оклад",okl);
  
//точный код вида, действующий в mrasch
	double kod=FindValidVid(3);

//определяем повышающий коэф. 105 нагрузки _Образование
   StartRkv(5);
   char str[256];
   ReadRkv("спец_к1",str);
   double k1=atof(str);
 
//определяем повышающий коэф. 105 нагрузки _Квлификация
   StartRkv(5);
   char str2[256];
   ReadRkv("спец_к2",str2);
   double k2=atof(str2);

//определяем повышающий коэф. 105 нагрузки _Стаж
   StartRkv(5);
   char str3[256];
   ReadRkv("спец_к3",str3);
   double k3=atof(str3);

//определяем повышающий коэф. 105 нагрузки _Специфика
   StartRkv(5);
   char str4[256];
   ReadRkv("спец_к4",str4);
   double k4=atof(str4);

	double udo=okl*k1*k2*k3*k4;

   //ограничиваем коэф.
  // if (koef1>18.000) koef1=18.00;
   FinishRkv();


   worktime(info.crow,info.b3,0);
   info.n1=r[2]*(udo/18);
   if(FL_V_ALG && uprc != NO_SCREEN)
   {
      infolist.add_record("Оклад",okl);
      infolist.add_record("_Образование",k1);
      infolist.add_record("_Квлификация",k2);
      infolist.add_record("_Стаж",k3);
      infolist.add_record("_Специфика",k4);
      infolist.add_record("УДО",udo);
      infolist.add_record("Результат",info.n1);
   }
   return code_Break;
}

//*************Конец алгоритмов 2023****************




UserAlg4(&info,&r)
{
  return SysAlg4(info,r);
}


UserAlg712(&info,&r)
{
   struct Struct_Alg Work;
   var mes1=0;
   var mes2=0;
   var stolbec=ST_MPREM+1;

   // символы для выборки
   // по умолчанию - по всем ненулевым
   char StrSimv[51];
   sprintf(StrSimv,"*");
   Get_AlgWithParam(Work,info.ikod);   // 31.01.1995
   // Work.Count_Par - число паpаметpов для кода алгоpитма
   //-- параметр 1 - столбец таблицы входимости
   if(Work.Count_Par > 0)
   {
      var i=atoi(reinterpret_cast_to_string(Work.List_Par[0]));
      if( i > 0 && i <= 99 ) stolbec=i;
   }

   //-- параметр 2 - месяц начала выборки (относительно расчетного)
   //   (по умолчанию берется за один текущий месяц)
   if(Work.Count_Par > 1)
   {
      var i=atoi(reinterpret_cast_to_string(Work.List_Par[1]));
      if( i >= (- PMES) && i <= BMES )  mes1=mes2=i;
   }

   //-- параметр 3 - месяц конца выборки (относительно расчетного)
   //   (по умолчанию берется за один месяц, указанный параметром 2)
   if(Work.Count_Par > 2)
   {
      var i=atoi(reinterpret_cast_to_string(Work.List_Par[2]));
      if( i >= mes1 && i <= BMES ) mes2=i;
   }

   //-- параметр 4 - символы выборки
   if(Work.Count_Par > 3)
      sprintf(StrSimv,"%.50s",reinterpret_cast_to_string(Work.List_Par[3]));

   var   n5=0.;
   for(var m=mes1; m<=mes2; m++)
   {
      double r9;
      s1001simv(StrSimv,"*",info.d1,info.d2,m,stolbec-1,r9,4,0);
      n5+=r9;
   }


   // Заполним таблицу уже найденными значениями
   if(FL_V_ALG && uprc != NO_SCREEN)
   {
      infolist.add_record("Месяц начала выборки",mes1);
      infolist.add_record("Месяц окончания выборки",mes2);
      infolist.add_record("Столбец выборки",stolbec);
      infolist.add_record("Символы выборки",StrSimv);
      infolist.add_record("Сумма выборки",n5);
   }

   // А теперь пройдемся по полю кадровой части "procPREM"
   // И возьмем оттуда все значения процентов, действовавшие
   // в рассчитываемом месяце
   info.n1=0.;  // обнулили итоговую сумму

   // Дата конца действия очередного значения процента
   // В самом начале она равна последнему дню месяца.
   var DateEnd = CreateObject("KDate");
   DateEnd.SetDateII(countday,mrasch);

   // Найдем дату начала действия очередного значения процента
   char StrD[21];
   GetKchDate("procPREM",StrD,10,DateEnd);
   var Date=CreateObject("KDate");
   Date.SetDate(static_cast_to_string(StrD));
   // Если вдруг дата начала пустая или выходит за рамки расчетного
   // месяца, то установим ее равной первому числу расчетного месяца
   if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.GetAbs()<mrasch )
   {
      Date.SetDateII(1,mrasch);
      sprintf(StrD,"%02d.%02d.%4d",Date.GetDay(),Date.GetMonth(),Date.GetYear());
   }

   // Ну и просматриваем все значения процентов, действовавшие в
   // рассматриваемом месяце
   char StrProc[21];
   while ( 1 )
   {
      // находим очередное значение процента
      double Proc=atof(GetKchValue("procPREM",StrProc,20,DateEnd));

      // определяем коэффициент неполноты для очередного значения процента
      // (неполнота по нормативным дням)
      double KoefNepoln = 1.;
      nepoln(Date.GetDouble(),DateEnd.GetDouble(),info.d1,info.d2,KoefNepoln,2);

      // записываем, если надо, в таблицу найденные значения
      if(FL_V_ALG && uprc != NO_SCREEN)
      {
         infolist.add_record("------------------------","---------------------");
         infolist.add_record("Начало действия процента",StrD);
         sprintf(StrD,"%02d.%02d.%4d",DateEnd.GetDay(),DateEnd.GetMonth(),DateEnd.GetYear());
         infolist.add_record("Конец  действия процента",StrD);
         infolist.add_record("Коэффициент",KoefNepoln);
         infolist.add_record("Процент",Proc);
      }

      // Увеличиваем итоговую сумму на очередную порцию премии
      info.n1 += n5*Proc*KoefNepoln/100.;

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

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

      // Находим дату начала для очередного значения премии
      GetKchDateP("procPREM",StrD,10,Date);
      Date.SetDate(static_cast_to_string(StrD));
      // Если вдруг дата начала пустая или выходит за рамки расчетного
      // месяца, то установим ее равной первому числу расчетного месяца
      if ( Date.IsEqI(INVALID_DATE_VALUE) || Date.GetAbs()<mrasch )
      {
         Date.SetDateII(1,mrasch);
         sprintf(StrD,"%02d.%02d.%4d",Date.GetDay(),Date.GetMonth(),Date.GetYear());
      }
   }

   // выводим в таблицу окончаительный результат
   if(FL_V_ALG && uprc != NO_SCREEN)
   {
      infolist.add_record("------------------------","---------------------");
      infolist.add_record("Результат",info.n1);
   }
   return code_MDefault;
}


UserAlg714(&info,&r)
{
//расчет доплаты до регионального МРОТ;  РВ в днях

//объявляем переменные	
	int m=0;
	double r9,frv,nrv,dopl;
	double kt,kto;         //к-т ФРВ/НРВ,к-т округл.до 4 знаков
	char t[20];
	var k_zan;


// получаем коэфф. занятости по КЧ
	var D=CreateObject("KDate");
	D.SetDateII(countday,mrasch);
	double Proc=atof(GetKchValue("k_employ",k_zan,20,D));
	if (Proc==0) Proc=1;


//Корректируем РВ
	r[2]=dney_v_tab(rsimv,calm,info.z1,info.z2);
	korrv(r,t,0,info.h,flagrow,jf);


//производим расчет
	s100simv("1","н",m,2,r9,0); //получили в r9 сумму по 3-му столбцу ТВХ (сумма за отработанное время)
	nrv = norm(1);    //2 - НРВ в часах
	if (nrv != 0) kt=info.bz/nrv; else kt=0; //получаем коэффициент РВ/НРВ
	kt=kt*r[2];
	roundd(kt,4,kto); //округляем что получилось до 4-х знаков после запятой
	if (r9 < kto) dopl=Proc*kto - r9; else dopl=0; //если насчитанное ранее больше, чем МРОТ*коэфф, то доплаты не будет
	info.n1=dopl; //записываем доплату в Сумму
	
	return code_MDefault;
}


UserAlg715(&info,&r)
{
//расчет доплаты до регионального МРОТ для видов в часах

//объявляем переменные	
	int m=0;
	double r9,frv,nrv,dopl;
	double kt,kto;         //к-т ФРВ/НРВ,к-т округл.до 4 знаков
	char t[20];
	var k_zan;


// получаем коэфф. занятости по КЧ
	var D=CreateObject("KDate");
	D.SetDateII(1,mrasch);
	double Proc=atof(GetKchValue("k_employ",k_zan,20,D));
	if (Proc==0) Proc=1;


//Корректируем РВ
	skoljko(r[2],data,info.z1,info.z2,rsimv,calm,cht);
	korrv(r,t,0,info.h,flagrow,jf);


//производим расчет
	s100simv("1","н",m,2,r9,0); //получили в r9 сумму по 3-му столбцу ТВХ (сумма за отработанное время)
	nrv = norm(2);    //2 - НРВ в часах
	if (nrv != 0) kt=r[2]/nrv; else kt=0; //получаем коэффициент РВ/НРВ
	roundd(kt,4,kto); //округляем что получилось до 4-х знаков после запятой
	if (r9 < Proc*info.bz*kto) dopl=Proc*info.bz*kto - r9; else dopl=0; //если насчитанное ранее больше, чем МРОТ*коэфф, то доплаты не будет
	info.n1=dopl; //записываем доплату в Сумму

   return code_MDefault;
}


