int ColTVXUd = 25;  // Номер столбца ТВХ, по которому делается выборка удержаний (заменяется на значение, указанное в настройке:
                    // Настройки таблиц и форм печати -> 7. Настройки печати формы 0504425 -> Столбец таблицы входимости)
                    
                    // В этом столбце должны стоять символы:
                    // "1" - помечены виды НДФЛ (столбец 3-4)
                    // "2" - виды, которые должны попадать в столбец 10
                    
                    // в столбцах 6-9 печатаются виды удержания по другим символам(по символам отличным от "1" и "2")
                    // названия групп для столбцов 6-9 можно задать в настройке "Настройки таблиц и форм печати -> 7. Настройки печати формы 0504425 -> Задать названия для столб. с удержаниями"
   
   
int AddColForSrc = 1; // 1 - добавлять столбцы на 2 стр. для з/пл по источникам (если кол-во источников >3)
                      // 0 - не добавлять
int countGroopUD=0;   // кол-во столбцов с удержаниями (включая итоговый)
int BreakUd=0;        //Разбивать удержания по группам? 0-не разбивать, 1- разбивать(каждый символ в ТВХ - отдельная группа)

int bItogSum = 0;  // Как выводим итоги: 0 - все суммы включая ЗП, 1 - в итогах только суммы за отпуск
                   // 2 - в таблице и в итогах только суммы за отпуск

double NoPrintSum      = 0.0;
double ItogoNoPrintSum = 0.0;

ClearArrUd(&ArrayUd,CountSrc)
{
   for (int i=0; i   <=countGroopUD+1;  i++)
    for(int src=0;src<=CountSrc;src++)
      ArrayUd[i][src]=.0;
}

GetPath(Resource,NameFile)
{
  // Определяем каталог, куда будем складывать файлы
  char nm[512]; 
  if( Resource=="" )  
    nm = "\\"+NameFile;
  else
    nm = "\\"+Resource+"\\"+NameFile;
  FreeSpaceString(nm,3,"");

  // получим полный путь 
  char NewName[512];
  GetCurrentDirectory(512,NewName);
  NewName = NewName + nm;

  // если версия сетевая...то путь указываем относительно сетевого зпл
  if ( !IsLocalZPL() && ( Resource=="" || IsCommonResource(Resource) ) )
  {
    //берем путь к сетевому ZPL 
    GetCommonZPL(NewName,511);
    NewName = NewName+nm;
  }

  FreeSpaceString(NewName,3,"");
  // Если задан путь относительно текущего каталога (относительно ZPL)
  // то делаем из него абсолютный путь 
  if ( NewName[0]=='.' && NewName[1]=='.' )
  {
    fullpath(NewName,NewName,512);
    FreeSpaceString(NewName,3,"");
  }
  return NewName;
}

ZaprosNameGroopUd()
//===================================================================
// Запрашиваем названия для групп удержаний
//===================================================================
{
  //возьмем номер столбца из настройки
  if ( IsCommonCnfExist("COL_TVH","425") )
  {
    char Buf[81];
    GetCommonCnf("COL_TVH","425",Buf,80);  // Номер столбца ТВХ, по которому делается выборка удержаний
    ColTVXUd = GetCnfCol(Buf,ColTVXUd)+1;
  }
  
  
  //определяем набор символов для групп удержаний
  char strSim[256]; //строка символов в столбце ColTVXUd
  GetStrSim(strSim);
   
  //файл в который сохраним введеные пользователем названия групп удержаний
  char FileName[512];
  FileName=GetPath("\\T_NASTR\\FORMS\\","form425.XML");
  
  //первый параметр - путь до файла XML с настройками 
  //второй параметр - строка ненулевых символов в столбце ТВХ 
  int countParam=3;
  string param[countParam+1];
  param[0]=static_cast_to_string(countParam);
  param[1]=static_cast_to_string(MainWindow());
  param[2]=static_cast_to_string(OemToAnsi(FileName));
  param[3]=static_cast_to_string(OemToAnsi(strSim));

  //запрос названий для групп удержаний
  var NetD=NetDialogs();
  if (!IsObject(NetD))
    return ESC;
  NetD.RequestNameForGroopUd(param);
}

FillTitleForGroopUd(&SimForGroopUd,&TitleForGroopUd)
//===================================================================
// Определеем заголовки к столбцам с удержаниями (грузим из XML)
//===================================================================
{
  char FileName[512];
  FileName=GetPath("\\T_NASTR\\FORMS\\","form425.XML");

  //файл не нашли-> выходим
  if (access(FileName,0)==-1) {countGroopUD=0;}//AmbaMessageBox("Указанный файл не найден: " +static_cast_to_string(FileName),"Ошибка!",0,0);};
  else
  {
    var XMLDoc =CreateXMLobj();
    LoadFileXML(XMLDoc,FileName); //грузим данные из XML

    //инициализируем переменные данными из файла
    var XMLRoot=XMLDoc.documentElement; //корневой элемент
    
    var XMLListGroopUd=XMLRoot.getElementsByTagName(OemToAnsi("Группа")); //список групп удержаний
    countGroopUD=XMLListGroopUd.length();  //кол-во групп удержаний в файле

    //цикл по элементам "Группа"
    for(int i=1; i<=countGroopUD; i++ )
    {
      var XMLGroopUd =XMLListGroopUd.item(i-1); //очередная группа из списка XMLListGroopUd
      string sim =XMLGroopUd.getElementsByTagName(OemToAnsi("СимволТВХ")).item(0).text; FreeSpaceString(sim  ,2,"");
      string name=XMLGroopUd.getElementsByTagName(OemToAnsi("НазваниеГруппы")).item(0).text; FreeSpaceString(name  ,2,"");
      SimForGroopUd  [i]=AnsiToOem(sim); 
      TitleForGroopUd[i]=AnsiToOem(name);
    }
  }
  //подстраховываемся - могли в ТВХ  группу пометить "новым" символом, а название для группы не указать --> название группы будет "название для группы с символом  'Х'"
  //определяем набор символов для групп удержаний
  char strSim[256]; //строка символов в столбце ColTVXUd
  GetStrSim(strSim);
  
  //перебираем символы в строке
  for (int i=0; i<strlen(strSim);i++)
  {
    string sim=substr(strSim,i,1); //очередной символ
    int findSim=0; // признак того, что символ sim нашли в SimForGroopUd
    //проверяем - есть ли такой символ в SimForGroopUd, если нет - добавляем новую группу.
    for (int j=1;j<=countGroopUD; j++ )
      if (sim==SimForGroopUd[j]) {findSim=1;break;}
    //символ не найден -> добавляем его в массивы SimForGroopUd и TitleForGroopUd
    if(!findSim)
    {
      countGroopUD++;
      SimForGroopUd  [countGroopUD]=sim;
      TitleForGroopUd[countGroopUD]="название для группы с символом  '" +sim+"'";
    }
  }
}
GetStrSim(&strSim)
{
  if ( IsCommonCnfExist("BreakUd","425") )
  {
    char Buf[81];
    GetCommonCnf("BreakUd","425",Buf,80);  
    BreakUd =atoi(Buf);
  }

  strSim="";
  int idx=0;
  //цикл по видам ТТВХ
  for(int pos=0;pos<cntplus;pos++)
  {
    char sim=Sim_For_Position(pos,ColTVXUd-1);
    if ( sim!='0' &&   //символ не нулевой и
         !IsCodeNach(kodnu1[pos])&&                 //вид является удержанием и
         !reinterpret_cast_to_long(strrchr(strSim,sim)) //символ отсутствует в strSim
        )
    {  
      //если значение в настройке 0 и символ sim не нашли в строке "12", то не добавляем sim в strSim
      if (!BreakUd && !reinterpret_cast_to_long(strrchr("12",sim))) continue;
      //добавляем символ в строку
      strSim[idx]=static_cast_to_string(sim);
      idx++;
    }
  }
  strSim[idx]=0; 
}
FillUd(Month1,Month2,SumOtp,&ArrayUd,CountSrc,StrSrc,SimForGroopUd)
//===================================================================
// Заполнение информации по удержаниям по месяцам [Month1,Month2] 
//===================================================================
{
  var Dat = CreateObject("KMonth");
  Dat.SetDateD(Month1+.01);
  int m1 = Dat.GetAbs();
  Dat.SetDateD(Month2+.01);
  int m2 = Dat.GetAbs();
  int col = ColTVXUd-1;

  var RazbSrc = CreateObject("ParamFuncRW");
  var Src=CreateObject("APropBE");
  RazbSrc.IInitial(static_cast_to_string(StrSrc),",",20);

  double Other=0; 
  //цикл по источникам
  for ( int src=1;src<=CountSrc;src++ )
  {
    // вн код. источника
    Src.LoadFromStr(RazbSrc.Get(src-1));
    unsigned char srcCode =Src.GetSrc();
    
    //вн. код источника не нулевой
    if (srcCode) 
    {
      for ( int m = m1; m<=m2; ++m)
      {
        for (int i=1; i   <=countGroopUD;  i++)
        {
           string sim =SimForGroopUd[i];
           if (sim == "Н")
           {
             NoPrintSum=CollectSummPropSimv(sim,col,m,0,CL_UD|CL_REAL|CL_MTEK,Src);//удержания по группе с символом "Н" по источнику src
           }
           else
           {
             ArrayUd[i][src]+=CollectSummPropSimv(sim,col,m,0,CL_UD|CL_REAL|CL_MTEK,Src);//удержания по группе с символом sim по источнику src
             ArrayUd[i][0]+=CollectSummPropSimv(sim,col,m,0,CL_UD|CL_REAL|CL_MTEK,Src);  //удержания по группе с символом sim по всем источникам
             Other-=CollectSummPropSimv(sim,col,m,0,CL_UD|CL_REAL|CL_MTEK,Src);
           }
        }
        ArrayUd[0][src]+=CollectSummPropSimv("*0",col,m,0,CL_UD|CL_REAL|CL_MTEK,Src);  //Всего удержано (столбец 10) по источнику src
        ArrayUd[0][0]  +=CollectSummPropSimv("*0",col,m,0,CL_UD|CL_REAL|CL_MTEK,Src);  //Всего удержано (столбец 10) по всем источникам
        Other += ArrayUd[0][src];

        ArrayUd[0][src] -= NoPrintSum;
        ArrayUd[0][0] -= NoPrintSum;
        Other -= NoPrintSum;

        ItogoNoPrintSum +=NoPrintSum;
        NoPrintSum = 0.0;

      }
      int KodNegativeKO = GetCommonCnfInt("LST_NU_NKO","отпуск");
      bool bNegativeKOUderg= ( KodNegativeKO && !IsCodeNach(KodNegativeKO));
      if ( SumOtp<0. && bNegativeKOUderg )
      {
        Other += SumOtp;
        ArrayUd[0][src] += SumOtp;
        ArrayUd[0][0]   += SumOtp;
      }
    }
  }
  ArrayUd[countGroopUD+1][0]  +=Other;  //прочие удержания по всем источникам
  
}
GetNameCol(Src)
{
  char str[256];
  char tmp[256];
  // вн код. источника
  unsigned char srcCode =Src.GetSrc();
  //название источника
  if (srcCode) 
  {
    tmp=GetSrcName(Src.GetSrc()); FreeSpaceString(tmp,2,"");
    str+= tmp;
  }  
  else str = "";
  int comb=Src.GetCombine();
  var CL=CreateObject("CombineList");
  //в название столбца добавляем название должности (если сов-во не основное)
  //иначе получим 2 столбца с одним названием 
  if (comb&&comb!=CL.GetBaseID())
  {
    tmp=CL.GetName(comb);FreeSpaceString(tmp,2,"");
    str+="\r\n" + static_cast_to_string(tmp);
  }
  return str;
}

PrintUd_Wsh_3(ArrayUd,CountSrc,StrSrc,SimForGroopUd,TitleForGroopUd,flPrintSrc,realCountSrc,ItogSumOtp)
{
  int cntColForStlb=2 ;//кол-во колонок в столбце с суммами по источникам
  int firstStlbUd  =10;//номер первого столбца с удержаниями
  int firstStlbIst =4 ; //номер первого столбца с исчтониками
  int cntStlbUd=4;      //кол-во столбцов с удержаниями  
 
  int AddColSrc_Wh3=0;
   if ( IsCommonCnfExist("AddColSrc3","425") )
    AddColSrc_Wh3= GetCommonCnfInt("AddColSrc3","425");// добавлять столбцы для источников на странице 3

  int bPrintNdflForIst=0; //1-печатаем НДФЛ в разрезе источников, 0 - выводим общей суммой в первом столбце
  if (AddColSrc_Wh3||realCountSrc<3) bPrintNdflForIst=1;  
  
  // добавляем столбцы для источников (если источников >3)
  if ( AddColSrc_Wh3 && realCountSrc>3 )
  {
    for ( int j=4; j<=realCountSrc ; j++ )
    {
       tInsertColumns(firstStlbUd,cntColForStlb);
       tCopyColumns(firstStlbUd,cntColForStlb);
    }
  }

  int idxNDFL=0; //индекс для данных с НДФЛ
  int idxVidano=0;//индекс для столбца 10 - Выплаченная заработная плата
  int cntSkipStlb=0; //кол-во "пропущенных" столбцов (для "НДФЛ" и "Выдано" данные выводим вне группы "Другие удержания"

  //перебираем все символы в SimForGroopUd пока не найдем "1" - это и есть НДФЛ
  for (int i=1; i   <=countGroopUD;  i++)
  {
    string sim =SimForGroopUd[i];
    //группа "НДФЛ"
    if(atoi(sim)==1) {idxNDFL=i;cntSkipStlb++;continue;}
    //группа "Выдано"
    if(atoi(sim)==2) {idxVidano=i;cntSkipStlb++;continue;}
    //сумма по группе нулевая - не будем выводить 
    if (nabs(ArrayUd[i][0]<0.00001)) {cntSkipStlb++;continue;}
  }
  
  //резервируем место для "прочих отчислений"
  if  (nabs(ArrayUd[countGroopUD+1][0])>0.00001) cntSkipStlb--;
  
  //countGroopUD-cntSkipStlb-реальное кол-во групп для печати(группы по которым ненулевая сумма+ резерв под "прочие")
  if(countGroopUD-cntSkipStlb>4)
  {
    //добавляем столбцы для удержаний (если групп >4)
    int firstCol=(realCountSrc<3)?firstStlbIst+3*cntColForStlb : firstStlbIst+realCountSrc*cntColForStlb;
    for ( int j=5; j<=countGroopUD-cntSkipStlb ; j++ )
    {
       tInsertColumns(firstCol,cntColForStlb);
       tCopyColumns(firstCol,cntColForStlb);
       cntStlbUd++;
    }
  }
  double ItogoVed =0;
  //названия источников
  var RazbSrc = CreateObject("ParamFuncRW");
  RazbSrc.IInitial(static_cast_to_string(StrSrc),",",CountSrc);
  
  int MaxLenToH=14; //максимальная длина строки названия колонки (используется для определения высоты строки)
  int LenToH=12;   //кол-во символов, которые входят в колонку
  char str[256];
  if( bPrintNdflForIst ) 
  {
     var mapSrc=CreateObject("Map");
     //цикл по источникам
     for ( int src=0, column=0; src<CountSrc; src++, column++ )
     {
        if ( flPrintSrc[src] )
        {
           var Src=CreateObject("APropBE");
           Src.LoadFromStr(RazbSrc.Get(src));
      
           str=GetNameCol(Src);
           if (strlen(str)>MaxLenToH) MaxLenToH=strlen(str);
      
           tWriteStringToCell2(5,firstStlbIst+column*cntColForStlb,OemToAnsi(str));   //название источника
           if(idxNDFL) sprintf(str,"%.2f",ArrayUd[idxNDFL][src+1]);
                  else sprintf(str,"%.2f",0.);
           tWriteStringToCell2(7,firstStlbIst+column*cntColForStlb,str);  //НДФЛ по источнику     

           Src.ClearNotBalanceProps();
           bool exist = false;
           for(mapSrc.InitIterator(); !mapSrc.IsEnd(); mapSrc.Next())
           if (mapSrc.GetCurValue().IsExactEQ(Src))
           {
              exist = true;
              break;
           }
           if (exist) continue;
           mapSrc.Add(src,Src);
      
           double ved= GetOtpVedProp(Src); 
           ItogoVed+=ved;
           // В случае задолженности человека в ведомость 0, все встает
           // в долг следующего месяца
           if ( nabs(ved)<0.00001 )
              ItogoVed += -CollectSummProp(200,mtek+1,0,CL_SOURCE|CL_M|CL_UD,Src);       
        }
        else column--;

     }
  }
  else
  {
    tWriteStringToCell2(5,firstStlbIst,OemToAnsi("НДФЛ")); 
    if(idxNDFL) sprintf(str,"%.2f",ArrayUd[idxNDFL][0]);
    else sprintf(str,"%.2f",0.);
    tWriteStringToCell2(7,firstStlbIst,str);  //НДФЛ общей суммой
  }
  if (realCountSrc<3) realCountSrc=3;
  tMergeCells2         (4,firstStlbIst,4,firstStlbIst+cntColForStlb*realCountSrc-1,1);
  tHorizontalAlignment2(4,firstStlbIst,4,firstStlbIst+cntColForStlb*realCountSrc-1,2); 
  
  int cntStrInStlb=MaxLenToH/LenToH+1;
  tRowHeight2(5,12.75*cntStrInStlb);
  
  //выводим информацию по удержаниям
  firstStlbUd=firstStlbIst+cntColForStlb*realCountSrc; 

  for ( int j=1,stlb=0; j<=countGroopUD; j++ )
  {
    //информацию по НДФЛ  уже распечатали ранее - пропускаем
    if ((idxNDFL)&&(idxNDFL==j)) continue;
    //Выплаченная заработная плата будем печатать позднее
    if ((idxVidano)&&(idxVidano==j)) continue;
    //сумма по группе нулевая - не будем выводить 
    if (nabs(ArrayUd[j][0]<0.00001)) continue;
     
    tWriteStringToCell2(5,firstStlbUd+(stlb)*cntColForStlb,OemToAnsi(TitleForGroopUd[j]));
    sprintf(str,"%.2f",ArrayUd[j][0]);
    tWriteStringToCell2(7,firstStlbUd+(stlb)*cntColForStlb,str);
    stlb++;
  }
  
  if (nabs(ArrayUd[countGroopUD+1][0])>0.00001)
  {
    tWriteStringToCell2(5,firstStlbUd+(countGroopUD-cntSkipStlb-1)*cntColForStlb,OemToAnsi("Прочие удержания"));
    sprintf(str,"%.2f",ArrayUd[countGroopUD+1][0]);
    tWriteStringToCell2(7,firstStlbUd+(countGroopUD-cntSkipStlb-1)*cntColForStlb,str);
  }
  tMergeCells2         (4,firstStlbUd,4,firstStlbUd+cntStlbUd*cntColForStlb-1,1);
  tHorizontalAlignment2(4,firstStlbUd,4,firstStlbUd+cntStlbUd*cntColForStlb-1,2); 
  
  //Выплаченная заработная плата
  if(idxVidano) sprintf(str,"%.2f",ArrayUd[idxVidano][0]);
  else sprintf(str,"%.2f",0.);
  tWriteStringToCell2(7,firstStlbIst+(realCountSrc+cntStlbUd+0)*cntColForStlb,str);
  //Всего
  sprintf(str,"%.2f",ArrayUd[0][0]);
  tWriteStringToCell2(7,firstStlbIst+(realCountSrc+cntStlbUd+1)*cntColForStlb,str);

  int N=3;
  // нумерация столбцов
  if (realCountSrc<3) realCountSrc=3;
  if (countGroopUD<4) countGroopUD=4;
  for ( int j=0; j<realCountSrc+cntStlbUd; j++ )
  {
     tWriteStringToCell2(6,firstStlbIst+j*cntColForStlb,static_cast_to_string(N));
     N++;
  }
  tWriteStringToCell2(6,firstStlbIst+(realCountSrc+cntStlbUd+0)*cntColForStlb,static_cast_to_string(N));  //Выплаченная заработная плата
  tWriteStringToCell2(6,firstStlbIst+(realCountSrc+cntStlbUd+1)*cntColForStlb,static_cast_to_string(N+1));//Всего  */

  return ItogoVed;
}

PrintWsh_3(ArrayUd,CountSrc,StrSrc,SimForGroopUd,TitleForGroopUd,flPrintSrc,realCountSrc,ItogSumOtp)  
{
  double ItogoVed =0;
  if ( bItogSum!=2 ) 
  {
     ItogoVed = PrintUd_Wsh_3(ArrayUd,CountSrc,StrSrc,SimForGroopUd,TitleForGroopUd,flPrintSrc,realCountSrc,ItogSumOtp);
  }
  else
  {
     tMergeCells2(4,4,4,9,1); tHorizontalAlignment2(4,4,4,9,2); 
     tMergeCells2(4,10,4,17,1); tHorizontalAlignment2(4,10,4,17,2); 
  }

  //копируем подножие(12 строк с 12 по 23) для страницы 3 с шаблонного листа(лист 4) 
  tCopyRowsWsh(4,3,12,12,12);
  
  //скрываем шаблонный лист
  tGetWshByIndex(4); // получаем ссылку на лист (worksheet)
  tWshSelect(); tWshHide();

  tGetWshByIndex(3); // получаем ссылку на лист (worksheet)
  tWshSelect();
  
  // К выплате (D12)
  //double ItogoVed = GetOtpVedSrc(CLL_TOTAL_SRC);

  bool negative=(ItogoVed<-0.001)?true:false;
  if (ItogoNoPrintSum !=0)
  {
    ItogoVed=nabs(ItogoVed+ItogoNoPrintSum);
    negative = false;
  }
  else ItogoVed=nabs(ItogoVed);

  // Что выводить в подписи "К выплате" 
  if (bItogSum) { ItogoVed = ItogSumOtp; negative = false; }

  char str[256], strRub[256], strKop[256];
  long Rub = static_cast_to_long(ItogoVed + ((ItogoVed>0)?1.:-1)*0.00001);
  long Kop = static_cast_to_long((ItogoVed - Rub)*100.+((ItogoVed>0)?1.:-1)*0.00001);
  Long_Text(str,Rub,12); strRub = (negative)?OemToAnsi("минус ")+str:str;
  sprintf(strKop,"%0*ld",Kop<0.?3:2,static_cast_to_long(Kop));


  // используем "ответственного" за налоговые карточки как работника кадровой службы
  char dolgnBuh[256], fioBuh[256], fioRukGr[256];
  GetEnterpriseVar("ДОЛЖОТВНАЛ", dolgnBuh,127);  // Должность ответственного за ведение налоговых карточек
  GetEnterpriseVar("ОТВНАЛ", fioBuh,127);     // ответственный за ведение налоговых карточек

  //должность исполнителя 
  if ( IsCommonCnfExist("dolgnBuh3","425") )
  {
     GetCommonCnf("dolgnBuh3","425",str,80);  FreeSpaceString(str,2,""); 
     if(strlen(str)) dolgnBuh = str;
  }
  //расшифровка подписи "бухгалтер"
  if ( IsCommonCnfExist("FIOBuh3","425") )
  {
    GetCommonCnf("FIOBuh3","425",str,80);  FreeSpaceString(str,2,""); 
    if(strlen(str)) fioBuh = str;
  }
  //расшифровка подписи "руководитель группы учета" 
  if ( IsCommonCnfExist("FIORukUch3","425") )
  {
    char fioBuh[81];
    GetCommonCnf("FIORukUch3","425",str,80);  FreeSpaceString(str,2,""); 
    if(strlen(str)) fioRukGr = str;
  }

  tWriteStringToCell2(12,3,strRub);
  tWriteStringToCell2(12,7,strKop);
  tWriteStringToCell2(18,3,OemToAnsi(dolgnBuh));
  tWriteStringToCell2(18,11,OemToAnsi(fioBuh));
  tWriteStringToCell2(21,11,OemToAnsi(fioRukGr));

  tWshCellSelect(1,1);

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

  // Подпись для 2-ого листа 
  int sign2Sheet = 0;
  if ( IsCommonCnfExist("Sign2Sheet","425") )
  {
     GetCommonCnf("Sign2Sheet","425",str,20); sign2Sheet = atoi(str);
  }
  if ( sign2Sheet )
  {
     tWriteStringToCell2(24,3,strRub);
     tWriteStringToCell2(24,6,strKop);
     tWriteStringToCell2(30,3,OemToAnsi(dolgnBuh));
     tWriteStringToCell2(30,8,OemToAnsi(fioBuh));
     tWriteStringToCell2(33,8,OemToAnsi(fioRukGr));
  }
  else tDeleteRows(24,12);

  tWshCellSelect(1,1);

} 

 
Print0504425_UV(&otp,tip_ras,CountDay,&Month,&Sum,CountMonth,RvSr,
         &SumO,&SumOR,&SumOtherN,CountSrc,&StrSrc)
//===================================================================
// Печать формы 0504425. Параметры:
// double otp[2] - дата начала и дата конца отпуска
// int tip_ras   - значение от 0 до 9 - тип расчета отпуска
// double CountDay - количество дней компенсации отпуска
// double SumO[CountSrc+1]  - суммы по видам отпускных по месяцам отпуска
// double SumOR[CountSrc+1] - суммы по видам р/к и северных отпускных
// double SumOtherN[CountSrc+1]  - суммы по прочим видам начислений
// int CountMonth - количество месяцев для расчета среднего + 1
// long Month[CountMonth] - месяцы среднего в виде ГГГГММ
// double Sum[CountMonth] - суммы для расчета среднего (по месяцам)
// double RvSr - рабочее время для расчета среденго
//===================================================================
{
   int CountMonthO=1;
   double CountDay1[CountMonthO];
   long MonthO1[CountMonthO];
   CountDay1[0]=CountDay;
   var DateUv1 = CreateObject("KDate");
   DateUv1.SetDateD(otp[0]);
   MonthO1[0]=DateUv1.GetSysForm();
   
   return Print0504425(otp,tip_ras,4,CountDay1,Month,Sum,CountMonth,RvSr,
          MonthO1,SumO,SumOR,SumOtherN,CountMonthO,CountSrc,StrSrc);
}
PrintHeadAndFooter_Wsh1(NumberD,StrDat1,StrDat2,CntDayOtp,bFormOtp,tip_otp,otp,&absmbeg,formCombine)
{
  // Дата составления и номер документа
  tWriteStringToCell2(1,82,OemToAnsi(NumberD));
  // текущая дата
  char Str[256],day[256],monthName[256],year[256];
  R_SYS_DATA("6",Str,20,0);
  tWriteStringToCell2(5,150,Str);
  var Date = CreateObject("KDate");  Date.SetDate(static_cast_to_string(Str));
  sprintf(day,"%02d",Date.GetDay());
  sprintf(monthName,"%.10s",OemToAnsi(Date.NameMonth(RODIT_PADEG,1)));
  sprintf(year,"%04d",Date.GetYear());
 
  tWriteStringToCell2(5,60,day);
  tWriteStringToCell2(5,67,monthName);
  tWriteStringToCell2(5,87,year);

  // --- 1. Заполняем информацию относящуюся к организации
  GetEnterpriseVar("ИМЯП", Str,255); // Наименование предприятия или отделения иностранной организации
  tWriteStringToCell2(6,12,OemToAnsi(Str));

  GetEnterpriseVar("ОКПО", Str,127); 
  tWriteStringToCell2(6,150,OemToAnsi(Str));
 
  GetEnterpriseVar("ИНН", Str,127); 
  tWriteStringToCell2(8,109,OemToAnsi(Str));
  GetEnterpriseVar("КОДПОСУЧ", Str,127); 
  tWriteStringToCell2(8,150,OemToAnsi(Str));
  //Орган, осуществляющий функции и полномочия учредителя
  if ( IsCommonCnfExist("Organ","425") )
  {
    char Organ[256];
    GetCommonCnf("Organ","425",Organ,255);  FreeSpaceString(Organ,2,""); 
    if(strlen(Organ)) tWriteStringToCell2(10,38,OemToAnsi(Organ));
  }  
  // тип отпуска
  string vidotp="";
  if      (tip_otp==0) vidotp = "Ежегодный основной оплачиваемый отпуск";
  else if (tip_otp==1) vidotp = "Учебный отпуск";
  else if (tip_otp==2) vidotp = "Дополнительный отпуск";
  else if (tip_otp==4) vidotp = "Компенсация за отпуск при увольнении";

  tWriteStringToCell2(12,37,OemToAnsi(vidotp));
  // Основание
  tWriteStringToCell2(13,11,OemToAnsi("Приказ"));
  //Глава по БК
  if ( IsCommonCnfExist("GlavaPoBK","425") )
  {
    char glavaPoBK[81];
    GetCommonCnf("GlavaPoBK","425",glavaPoBK,80);  FreeSpaceString(glavaPoBK,2,""); 
    if(strlen(glavaPoBK)) tWriteStringToCell2(10,150,OemToAnsi(glavaPoBK));
  }  
  // Подразделение
  GetKchValue("podr",Str,10,Date);
	int podr=atoi(Str);
	if(formCombine && formCombine!=GetGeneralCombineLS()) //печатаем форму не по основной должности
	{
		var CL=CreateObject("CombineList");
		int combinePodr=CL.GetPodr(formCombine);
		if(combinePodr>0) // подразделение должности
			podr=CL.GetPodr(formCombine);
	}	
  string NameP = GetOtdName(podr);
  tWriteStringToCell2(9,26,OemToAnsi(NameP));
  // ФИО
  tWriteStringToCell2(11,23,OemToAnsi(GetFioFromKch())); 
  
  var Razb = CreateObject("ParamFuncRW");
  if ( CntDayOtp )
  {
    var Razb = CreateObject("ParamFuncRW");
    Razb.IInitial(static_cast_to_string(DatWithNameMonth(StrDat1)),"\" ",5);
    Str = Razb.Get(0)+" "+Razb.Get(1)+" "+Razb.Get(2)+" г.";
    tWriteStringToCell2(16,27,OemToAnsi(Str));

    Razb.IInitial(static_cast_to_string(DatWithNameMonth(StrDat2)),"\" ",5);
    Str = Razb.Get(0)+" "+Razb.Get(1)+" "+Razb.Get(2)+" г.";
    tWriteStringToCell2(16,57,OemToAnsi(Str));

    if ( bFormOtp )
       sprintf(Str,"%.0f",CntDayOtp);
    else
       sprintf(Str,"%.2f",CntDayOtp);

    if ( tip_otp!=2 )                      // основной отпуск 0, учебный 1
       tWriteStringToCell2(19,87,Str);
    else                                  // дополнительный 2
       tWriteStringToCell2(19,107,Str);

    tWriteStringToCell2(19,150,Str);
  }
  // дата начала отпуска (дата увольнения)
  Date.SetDateD(otp[0]);
  absmbeg=Date.GetAbs();
  string DatS = Date.GetStr();
  Razb.IInitial(static_cast_to_string(DatWithNameMonth(DatS)),"\" ",5);
  Str = Razb.Get(0)+" "+Razb.Get(1)+" "+Razb.Get(2)+" г.";
  tWriteStringToCell2(19,27,OemToAnsi(Str));

  // дата окончания отпуска
  if ( bFormOtp )
  {
    Date.SetDateD(otp[1]);
    DatS = Date.GetStr();
    Razb.IInitial(static_cast_to_string(DatWithNameMonth(DatS)),"\" ",5);
    Str = Razb.Get(0)+" "+Razb.Get(1)+" "+Razb.Get(2)+" г.";
    tWriteStringToCell2(19,57,OemToAnsi(Str));
  } 
  
  //Подножие:
  GetEnterpriseVar("ГЛБУХ", Str,127); // ФИО гл.бухгалтера
  tWriteStringToCell2(33,36,OemToAnsi(Str));
  //должность "бухгалтера" 
  if ( IsCommonCnfExist("dolgnBuh","425") )
  {
    char dolgnBuh[81];
    GetCommonCnf("dolgnBuh","425",dolgnBuh,80);  FreeSpaceString(dolgnBuh,2,""); 
    if(strlen(dolgnBuh)) tWriteStringToCell2(33,1,OemToAnsi(dolgnBuh));
  }
  //расшифровка подписи "бухгалтер"
  if ( IsCommonCnfExist("FIOBuh","425") )
  {
    char fioBuh[81];
    GetCommonCnf("FIOBuh","425",fioBuh,80);  FreeSpaceString(fioBuh,2,""); 
    if(strlen(fioBuh)) tWriteStringToCell2(33,36,OemToAnsi(fioBuh));
  }
  //должность "исполнитель" 
  if ( IsCommonCnfExist("dolgnExec","425") )
  {
    char dolgnExecutor[81];
    GetCommonCnf("dolgnExec","425",dolgnExecutor,80);  FreeSpaceString(dolgnExecutor,2,""); 
    if(strlen(dolgnExecutor)) tWriteStringToCell2(33,95,OemToAnsi(dolgnExecutor));
  }
  //расшифровка подписи "исполнитель"
  if ( IsCommonCnfExist("FIOExec","425") )
  {
    char fioExecutor[81];
    GetCommonCnf("FIOExec","425",fioExecutor,80);  FreeSpaceString(fioExecutor,2,""); 
    if(strlen(fioExecutor)) tWriteStringToCell2(33,127,OemToAnsi(fioExecutor));
  }
  
  tWriteStringToCell2(36,3,day);
  tWriteStringToCell2(36,10,monthName);
  tWriteStringToCell2(36,30,year);
    
  tWriteStringToCell2(36,79,day); 
  tWriteStringToCell2(36,86,monthName);
  tWriteStringToCell2(36,106,year); 
}


Print0504425(&otp,tip_ras,tip_otp,&CountDay,&Month,&Sum,CountMonth,_RvSr,
         &MonthO,&SumO,&SumOR,&SumOtherN,CountMonthO,CountSrc,&StrSrc)
//===================================================================
// Печать формы 0504425. Параметры:
// double otp[2] - дата начала и дата конца отпуска (дата начала увольнения)
// int tip_ras   - значение от 0 до 9 - тип расчета отпуска
// tip_otp   - вид отпуска
// int CountMonthO - количество месяцев, на которые распространяется отпуск + 1(для итоговых сумм)
// если CountMonthO=0 - форма для увольнения
// double CountDay[CountMonthO] - количество дней отпуска в каждом месяце
// long MonthO[CountMonthO]  - месяцы отпуска в виде ГГГГММ
// double SumO[CountMonthO*(CountSrc+1)]  - суммы по видам отпускных по месяцам отпуска
// double SumOR[CountMonthO*(CountSrc+1)] - суммы по видам р/к и северных отпускных по месяцам отпуска
// double SumOtherN[CountMonthO*(CountSrc+1)]  - суммы по прочим видам начислений по месяцам отпуска
// int CountMonth - количество месяцев для расчета среднего + 1
// long Month[CountMonth] - месяцы среднего в виде ГГГГММ
// double Sum[CountMonth*(CountSrc+1)] - суммы для расчета среднего (по месяцам)  
// double _RvSr[CountMonth] - рабочее время для расчета среденго
// CountSrc - кол-во истончиков
// StrSrc - источники
//===================================================================
{
	//определяем должность, по которой был запущен расчет
	int formCombine=GetGeneralCombineLS();          //внутренний код исп. должности, по который был расчет отпуска (по умолчанию: основная должность)
	var aPropArray=CreateObject("APropArray");   aPropArray.LoadFromStr(to_string(StrSrc));
	var listCombine=aPropArray.GetCombines();   //список исп. должностей
	int cntCombine = GetUBound(listCombine)+1;  //количество должностей в массиве
	if (cntCombine==1) //если расчет был по единственной должности - используем код этой должности для определения названия должности в к.ч.
		formCombine=listCombine[0];
					
   double RvSr = 0.;
   int bRv = 1;
   try
   {
      RvSr = _RvSr[CountMonth-1];
   }
   catch(...)
   {
      RvSr = _RvSr; bRv = 0;
   }
   var CFile = CreateObject("CurPrnFile");

   var Caption=OemToAnsi("Форма 0504425");

   string NameXLT = GetPathXLT("","425.xlt");

   char Str[256],Str1[256];
   var Date = CreateObject("KDate"), DateBegR=CreateObject("KDate");

   // Определим период за который предоставлен отпуск
   GetKchValue("data_rb",Str,10,Date);
   DateBegR.SetDate(static_cast_to_string(Str));
   Date.SetDateD(otp[0]);
   Date.Dec();
   char StrDat1[81], StrDat2[81], NumberD[81];
   StrDat2 = Date.GetStr();
   Date.SetDateD(otp[0]);
   Date.SetDateII(Date.GetDay(),Date.GetAbs()-12);
   // учитываем при определении даты начала дату приема на работу
   StrDat1 = (DateBegR.GE(Date))?DateBegR.GetStr():Date.GetStr();
   NumberD = "      1";

   try 
   {
     if (ScriptCheckName("OrderDocumentNumber") && VarHasValue(OrderDocumentNumber))
       NumberD = to_string(OrderDocumentNumber);

     Date.SetDateD(otp[2]); //проверяем не передали ли нам явные даты периода из КП
     if (!Date.IsEQI(INVALID_DATE_VALUE))
       StrDat1 = Date.GetStr();
     Date.SetDateD(otp[3]); 
     if (!Date.IsEQI(INVALID_DATE_VALUE))
       StrDat2 = Date.GetStr();
   }
   catch(...)
   {
   }
 
   if (ESC==Panel_Zapros("        Введите дополнительные данные       ",
                         "Отпуск предоставлен за период",
                         "                            с",StrDat1,10, 
                         "                           по",StrDat2,10,
                         "              Номер документа",NumberD,7
                         ))
      return;

   if ( IsCommonCnfExist("COL_TVH","425") )
   {
      char Buf[81];
      GetCommonCnf("COL_TVH","425",Buf,80);  // Номер столбца ТВХ, по которому делается выборка удержаний
      ColTVXUd = GetCnfCol(Buf,ColTVXUd)+1;
   }
   if ( IsCommonCnfExist("AddColSrc","425") )
      AddColForSrc= GetCommonCnfInt("AddColSrc","425");// добавлять столбцы для источников если не хватает в форме
  
   bItogSum = GetCommonCnfInt("ItogSum","425"); // Как выводим итоги

   tPrepereOfficeForWork(); // определяем работать на Excel или на Calc (определяем какой из офисов (MS Office или OpenOffice) установлен и какой предпочтительнее)
   tCreateXlsObjects(static_cast_to_string(NameXLT),"Форма 425"); // создание основных объектов
   //tMakeXlsVisible();
   try
   {
    tGetWshByIndex(1); // получаем ссылку на лист (worksheet)
    tWshSelect();
  
   // информация об отпуске (тип отпуска, кол-во дней, даты)
   bool bFormOtp = CountMonthO>1;
   //double CntDayOtp = CountDay[CountMonthO-1];
   double CntDayOtp = 0;
   int i=0;
   //заменил цикл, т.к. значение "Дней компенсации" должно стоять в таблице "Количество расчётных дней" в графе "Основного отпуска" На стр.1 (по просьбе blig)
   do {
     CntDayOtp += CountDay[i];
     i++;
   }
   while (i<CountMonthO-1);
   //for (int i=0; i<CountMonthO-1; i++) CntDayOtp += CountDay[i];
 
   int absmbeg=0;
   PrintHeadAndFooter_Wsh1(NumberD,StrDat1,StrDat2,CntDayOtp,bFormOtp,tip_otp,otp,absmbeg,formCombine);
 
   // информация о заработке за последние 12 месяцев
   double It=0.;
   int ItRV=0;
   int mend=0, mbeg=0;
   //Date.SetDateD(otp[0]);

   int idxcol[12];
   idxcol[0]=17,idxcol[1]=27,idxcol[2]=37,idxcol[3]=47, idxcol[4]=57,  idxcol[5]=67,
   idxcol[6]=77,idxcol[7]=87,idxcol[8]=97,idxcol[9]=107,idxcol[10]=117,idxcol[11]=127;

   int row = 27;//строка "Год"
   // int CountMonth - количество месяцев для расчета среднего + 1
   if ( CountMonth>=2 )
   //if ( CountMonth>3 )
   {
      var month = CreateObject("KMonth");
      for ( int i=CountMonth-2,idx=0; i>=0; --i,idx++ )
      {
         month.SetDateD(Month[i]+.01);

         sprintf(Str,"%.10s",month.NameMonth(IMENIT_PADEG,1));
         tWriteStringToCell2(row,idxcol[idx],month.GetYear());
         tWriteStringToCell2(row+1,idxcol[idx],OemToAnsi(Str));
         if( bRv )
         {  
            sprintf(Str,"%.2f",_RvSr[i]);
            tWriteStringToCell2(row+2,idxcol[idx],Str);
         }

         sprintf(Str,"%.2f",Sum[i]);
         tWriteStringToCell2(row+3,idxcol[idx],Str);
         It+=Sum[i];
      }

      sprintf(Str,"%.2f",RvSr);
      tWriteStringToCell2(row+2,137,Str);
      sprintf(Str,"%.2f",It);
      tWriteStringToCell2(row+3,137,Str);
    }
   
   tGetWshByIndex(2); // получаем ссылку на лист (worksheet)
   tWshSelect();

   if ( AddColForSrc && CountSrc>80 ) CountSrc = 80;
   if ( !AddColForSrc && CountSrc>3 ) CountSrc = 3;

   // Заполняем сумму отпускных

   double SumO1 = SumO[0]+SumOR[0];
   // По источникам   
   double SumO1Src[CountSrc];
   for ( int j=0; j<CountSrc; j++ ) SumO1Src[j] = 0;
   for ( int j=0; j<CountSrc; j++ )
   {
      int idx = CountMonthO*(j+1);
      SumO1Src[j] += SumO[idx]+SumOR[idx];
   }
   
   double DayO1 = CountDay[0];
   long MonthO1 = MonthO[0];
   row = 16;//19;
   bool NeedSecondRow=true;

   double ItogSum = 0;
   double ItogSumOtp = 0;
   double SumMes =0;
   //double ItogDay = CountDay[CountMonthO-1];
   double ItogDay = 0;
   i=0;
   do 
   {
     ItogDay += CountDay[i];
     i++;
   }
   while (i<CountMonthO-1);
   //for ( int i = 0; i<CountMonthO-1; ++i ) ItogDay += CountDay[i];

   for ( int i = 0; i<CountMonthO; ++i )
   {
      ItogSum += SumO[i]+SumOR[i]+SumOtherN[i];
      ItogSumOtp += SumO[i]+SumOR[i];
      SumMes += SumOtherN[i];
   }
   // По источникам
   double ItogSumOtpSrc[CountSrc];
   double ItogSumSrc[CountSrc];
   double SumMesSrc[CountSrc];
   for ( int j=0; j<CountSrc; j++ ) 
   {
      ItogSumOtpSrc[j] = 0;
      ItogSumSrc[j] = 0;
      SumMesSrc[j] = 0;
   }
   for ( int j=0; j<CountSrc; j++ )
   {
     for ( int i = 0; i<CountMonthO; ++i )
     {
       int idx = i+CountMonthO*(j+1);
       ItogSumOtpSrc[j] += SumO[idx]+SumOR[idx];
       ItogSumSrc[j]    += SumO[idx]+SumOR[idx]+SumOtherN[idx];
       SumMesSrc[j]     += SumOtherN[idx];
     }
   }

   // Флаг печати источников (если не было сумм в расчетном периоде по этому источнику, 
   // то выводить столбец с ним не нужно)
   bool flPrintSrc[CountSrc];
   double eps = 0.001;
   int realCountSrc = 0;
   for ( int j=0; j<CountSrc; j++ ) 
   {
      if ( nabs(ItogSumOtpSrc[j])<eps && nabs(ItogSumSrc[j])<eps 
          && nabs(Sum[CountMonth*(j+2)-1])<eps ) 
          // в Sum сначала итоговые суммы по всем источникам, затем отдельно по источникам 
         flPrintSrc[j] = false;
      else 
      {
         flPrintSrc[j] = true;
         realCountSrc++;
      }
   }

   // Добавление столбцов (источники с нулевыми суммами печатать не будем)
   int ColItog = 11;//43; // столбец "Всего"
   int N = 9;
   if ( AddColForSrc && realCountSrc>3 )
   {
      // добавить столбцы
      for ( int j=3; j<realCountSrc ; j++ )
      {
         tInsertColumns(ColItog,2);
         tCopyColumns(ColItog,2);
         ColItog += 2;
         tBordersCell2(4,10,4,10,1,1,0,0,0); 
         tBordersCell2(27,11,34,11,1,1,1,1,0); 
      }
      // нумерация
      for ( int j=0; j<realCountSrc-3 ; j++ )
      {
         tWriteStringToCell2(7,11+2*j,static_cast_to_string(N));
         tWriteStringToCell2(7,12+2*j,static_cast_to_string(N+1));
         N += 2; 
      }
      tWriteStringToCell2(7,11+2*(CountSrc-3),static_cast_to_string(N));//всего
   }

   var DateBegOtp = KDateFromD(otp[0]);
   var DateEndOtp = KDateFromD(otp[1]);
   string strMonthOtp="Сумма за отпуск за текущий\n месяц("+KDateFromInt(mtek).GetStr()+")";
   if ( absmbeg>mtek || CountMonthO<=2)
   {
      if ( absmbeg>mtek )
      {
         tWriteStringToCell2(row,1,OemToAnsi(strMonthOtp));
         row = 17;
         if ( CountMonthO>2 )
            strMonthOtp="Сумма за отпуск за будущие\n месяцы("+KDateFromInt(DateBegOtp.GetAbs()).GetStr()+"-"+KDateFromInt(DateEndOtp.GetAbs()).GetStr()+")";
         else
            strMonthOtp="Сумма за отпуск за будущий\n месяц("+KDateFromInt(DateBegOtp.GetAbs()).GetStr()+")";

      }
      SumO1 = ItogSumOtp;
      for ( int j=0; j<CountSrc; j++ ) SumO1Src[j] = ItogSumOtpSrc[j];
      DayO1 = ItogDay;
      MonthO1=MonthO[0];
      NeedSecondRow = false;
   }

   sprintf(Str,"%.2f",SumO1);
   tWriteStringToCell2(row,ColItog,Str);
   if ( bFormOtp )
      sprintf(Str,"%.0f",DayO1);
   else
      sprintf(Str,"%.2f",DayO1);

   tWriteStringToCell2(row,1,OemToAnsi(strMonthOtp));
   for ( int j=0, column=0; j<CountSrc; j++,column++ )
   {
      if ( flPrintSrc[j] )
      {
         sprintf(Str1,"%.2f",SumO1Src[j]);
         tWriteStringToCell2(row,6+2*column,Str1);
         tWriteStringToCell2(row,5+2*column,Str);
      }
      else column--;
   }

      
   if ( NeedSecondRow )
   {
      if ( CountMonthO>3 )
         strMonthOtp="Сумма за отпуск за будущие\n месяцы("+KDateFromInt(DateBegOtp.GetAbs()+1).GetStr()+"-"+KDateFromInt(DateEndOtp.GetAbs()).GetStr()+")";
      else
         strMonthOtp="Сумма за отпуск за будущий\n месяц("+KDateFromInt(DateEndOtp.GetAbs()).GetStr()+")";
      tWriteStringToCell2(17,1,OemToAnsi(strMonthOtp));
      double SumO2 = ItogSumOtp-SumO1;
      double DayO2 = ItogDay-DayO1;
      double SumO2Src[CountSrc];

      long MonthO2 = MonthO[CountMonthO-2];
      sprintf(Str,"%.2f",SumO2);
      tWriteStringToCell2(17,ColItog,Str);

      if ( bFormOtp )
         sprintf(Str,"%.0f",DayO2);
      else
         sprintf(Str,"%.2f",DayO2);

      for ( int j=0,column=0; j<CountSrc; j++,column++ )
      {
         if ( flPrintSrc[j] )
         {
            SumO2Src[j] = ItogSumOtpSrc[j]-SumO1Src[j];
            sprintf(Str1,"%.2f",SumO2Src[j]);
            tWriteStringToCell2(17,6+2*column,Str1);
            tWriteStringToCell2(17,5+2*column,Str);
         }
         else column--;
      }

   }
   sprintf(Str,"%.2f",ItogSumOtp);
   tWriteStringToCell2(18,ColItog,Str);
   sprintf(Str,"%.2f",bItogSum==2?ItogSumOtp:ItogSum);
   tWriteStringToCell2(20,ColItog,Str);
   if ( bItogSum!=2 )
   {
      sprintf(Str,"%.2f",SumMes);
      tWriteStringToCell2(19,ColItog,Str);
   }
   if ( bFormOtp )
      sprintf(Str,"%.0f",ItogDay);
   else
      sprintf(Str,"%.2f",ItogDay);

   if ( bItogSum!=2 )
   {
      string strMonthZrpl = "Зарплата за текущий месяц ("+KDateFromInt(mtek).GetStr()+")";
      tWriteStringToCell2(19,1,OemToAnsi(strMonthZrpl));
   }

   for ( int j=0, column=0; j<CountSrc; j++, column++ )
   {
      if ( flPrintSrc[j] )
      {
         sprintf(Str1,"%.2f",ItogSumOtpSrc[j]);
         tWriteStringToCell2(18,6+2*column,Str1);
         tWriteStringToCell2(18,5+2*column,Str);

         sprintf(Str1,"%.2f",bItogSum==2?ItogSumOtpSrc[j]:ItogSumSrc[j]);
         tWriteStringToCell2(20,6+2*column,Str1);

         if ( bItogSum!=2 )
         {
            sprintf(Str1,"%.2f",SumMesSrc[j]);
            tWriteStringToCell2(19,6+2*column,Str1);
         }
      }
      else column--;
   }

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

   countGroopUD=999; 
   string TitleForGroopUd[countGroopUD+1]; // заголовки к столбцам с удержаниями  
   string   SimForGroopUd[countGroopUD+1]; // символы для группы удержаний
   double ArrayUd[countGroopUD+2][CountSrc+1];  // в первом индексе со значением 0              - Всего удержано,
                                                //                               countGroopUD+1 - Прочие удержания
                                                //во втором индексе со значением 0              - сумма по всем источникам
   if (bItogSum!=2)
   {
      //определяем названия колонок для удержаний
      FillTitleForGroopUd(SimForGroopUd,TitleForGroopUd);     
      ClearArrUd(ArrayUd,CountSrc);
      
      FillUd(MonthO1,MonthO1,SumO1,ArrayUd,CountSrc,StrSrc,SimForGroopUd);
   }
 
   PrintWsh_3(ArrayUd,CountSrc,StrSrc,SimForGroopUd,TitleForGroopUd,flPrintSrc,realCountSrc,ItogSumOtp); 

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

   // Ну и теперь можно заполнить строчки, касающиеся расчета среднего заработка
   if ( CountMonth>3 )
   {
      for ( int i=CountMonth-1; i>3; --i )
      {
         // вставляем пустую строку
         tInsertRows(12,1);
         tCopyRow(12);       
         sprintf(Str,"%02d",i);
         tWriteStringToCell2(12,4,Str);
      }
      tWshCellSelect(1,1);       
   }
   row = 8;
   var month = CreateObject("KMonth");

   // Вывод месяцев и сумм всего
   for ( int i=CountMonth-2; i>=0; --i )
   {
      month.SetDateD(Month[i]+.01);
      int rowm = (i==CountMonth-2)?(row+1):row;
      tWriteStringToCell2(rowm,1,OemToAnsi(month.GetStr()));
      sprintf(Str,"%.2f",Sum[i]);
      tWriteStringToCell2(row,ColItog,Str);
      row += (i==CountMonth-2) ? 2:1;
   }

   var RazbSrc = CreateObject("ParamFuncRW");
   var Src=CreateObject("APropBE");
   RazbSrc.IInitial(static_cast_to_string(StrSrc),",",20);

   // Вывод сумм по источникам
   for ( int j=0, column=0; j<CountSrc; j++, column++ )
   {
      if ( flPrintSrc[j] )
      {
         // Наименование источника
         Src.LoadFromStr(RazbSrc.Get(j));
         if ( Src.GetSrc() ) 
            Str = GetSrcName(Src.GetSrc());
         else
            Str = "";
         tWriteStringToCell2(5,6+2*column,OemToAnsi(Str));

         row = 8;
         for ( int i=CountMonth-2; i>=0; --i )
         {  
            int idx = i+CountMonth*(j+1);
            sprintf(Str,"%.2f",atof(Sum[idx])); // 1-ый источник
            tWriteStringToCell2(row,6+2*column,Str);

            if( bRv )
            {  // РВ
               sprintf(Str,"%.2f",_RvSr[i]);
               tWriteStringToCell2(row,5+2*column,Str);
            }
            row += (i==CountMonth-2) ? 2:1;
         }
      }
      else column--;
   }

   double cnt = CountMonth-1;
   if ( cnt!=-1 )
   {
      if ( cnt==1 ) row += 2;

      sprintf(Str,"%.2f",Sum[cnt]);
      tWriteStringToCell2(row,ColItog,Str);

      double SrMes = Sum[cnt]/cnt;
      sprintf(Str,"%.3f",SrMes);
      tWriteStringToCell2(row+1,ColItog,Str);

      double Sr =0;
      if(nabs(static_cast_to_double(RvSr))>0.00001) Sr=Sum[cnt]/static_cast_to_double(RvSr);
			
			bool SrChanged=false;//признак того, что фактический средний ограничили снизу МРОТ
			if (GetCommonCnfInt("FLAG_MIN","отпуск")==1) //Признак, что среднее не меньше МЗП
			{
				double mrot=0.; //сумма мрот
				Value_For_Table_Cod(86,0, data, mrot);
				var d=KDateFromStr(otp[0]);//на какую дату брать ставку?? решил привязаться к дате начала отпуска..
				double srByMrot=mrot*DefineKEmploy(formCombine,d)/29.3;
				if (srByMrot>Sr)
				{
					SrChanged=true;
					Sr=srByMrot;
				}
			}
		  sprintf(Str,"%.3f",Sr);
      tWriteStringToCell2(row+3,ColItog,Str);

      sprintf(Str,"%.2f",RvSr);

			var totalSr=Sr;
			var notDistributedSr=Sr;
      for ( int j=0, column=0; j<CountSrc; j++, column++ )
      {
         if ( flPrintSrc[j] )
         {
            tWriteStringToCell2(row,5+2*column,Str);
            sprintf(Str1,"%.2f",Sum[cnt+CountMonth*(j+1)]);
            tWriteStringToCell2(row,6+2*column,Str1);

            SrMes = Sum[cnt+CountMonth*(j+1)]/cnt;
            sprintf(Str1,"%.3f",SrMes);
            tWriteStringToCell2(row+1,6+2*column,Str1);

            Sr =0;
            if(nabs(static_cast_to_double(RvSr))>0.00001) Sr=Sum[cnt+CountMonth*(j+1)]/static_cast_to_double(RvSr);
						//подгоняем результат...
						//если расчет по нескольким источникам и сработало ограничение не меньше МРОТ, то ставим "дельту"(разница между фактическим средним и средним из мрот) в последний источник
						if(SrChanged)
						{
							if(j==CountSrc-1)
								Sr=notDistributedSr;
							else //берем "средний МРОТ" пропорционально доходу на источнике.
								Sr=(Sum[cnt+CountMonth*(j+1)]/Sum[cnt])*totalSr;
						}	
            sprintf(Str1,"%.3f",Sr);
            tWriteStringToCell2(row+3,6+2*column,Str1);
						notDistributedSr-=Sr;
         }
         else column--;
      }
   }

   }
   catch(object err)
   {
      tEndXlsWork(1);
      SayError(err);
      return 1;
   }
   catch(...)
   {
      SayUndefinedScriptError();
      tEndXlsWork(1);
      return 1;
   }

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

   tAutoSaveOneLSReport("b425_","425",-1);
   tEndXlsWork(1); 
   return 0;
}

DatWithNameMonth( &Dat )
//=============================================================================
// Дата с названием месяца (для подножия справок)
//=============================================================================
{
   char StrDat[21]; 
   R_DATA_PROPIS(Dat,StrDat,20,0);
   FreeSpaceString(StrDat,2," ");
   if ( !Str_Cmp(Dat," "," .\\/ ") ) Dat = " ";
   else
   {
      Dat=StrDat+" года";
   }
   return Dat;
}

CreateXMLobj()
// Создание XML файла
{   
   UnloadScriptModule("msxml");
   LoadScriptModule("msxml");
   var XMLDoc = CreateXML("");
   return XMLDoc;
}