let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    from = f("table1"),
    num=Table.FirstValue(f("number")),
    lst=List.Buffer(Table.ToList(from,(x)=>x&{null})),
    spl=List.TransformMany(List.Split(lst,num), (x)=>{{1..List.Count(x)}}&List.Zip(x),(x,y)=>y),
    tbl=Table.FromColumns(spl)
in
    tbl 

let
    Source = Excel.CurrentWorkbook(){[Name="Source"]}[Content],
    trsp = Table.Transpose(Table.DemoteHeaders(Source)),
    nms=List.Skip(Table.ColumnNames(trsp)),
    com=Table.CombineColumns(trsp,nms,(x)=>Text.Combine(List.Transform(x,Text.From), ", "),"Value")
in
    com

let
    f=(x)=>Combiner.CombineTextByEachDelimiter({"01","21"})(Splitter.SplitTextByAnyDelimiter({"(01)","(21)"})(x)),
    Source = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content][text],
    to=List.Transform(Source,f)
in
    to

let
    from = Excel.CurrentWorkbook(){[Name="base"]}[Content],
    dt=Date.From(DateTime.LocalNow()),
    nms=List.Buffer(Table.ColumnNames(from)),
    rec_null=Record.FromList(List.Repeat({null},List.Count(nms)),nms),
    frst=((a)=>if Table.RowCount(a) <60 then a & #table({},List.Repeat({{}},60-Table.RowCount(a))) else a) (Table.FirstN(from,60)),
    skip=Table.Skip(from,60),
    sel=Table.SelectRows(frst,(x)=>Date.From(x[Итог])=dt),  
    rep=Table.ReplaceMatchingRows(frst, List.Zip({Table.ToRecords(sel), List.Repeat({rec_null},Table.RowCount(sel))})),
    to=Table.CombineColumns(Table.AddIndexColumn(rep & sel & skip,"ind",1),{"ind","№ п/п"},(x)=>x{0},"№ п/п")
in
    to

let
    from = Excel.CurrentWorkbook(){[Name="data"]}[Content],
    add1=Table.AddColumn(from,"Доля",(x)=>x[продажи]/List.Sum(from[продажи]),Percentage.Type),
    add2=Table.AddColumn(add1,"Месячный план",(x)=>mpl*x[Доля],type number),
    add3=Table.AddColumn(add2,"Отклонение",(x)=>x[Стратег план]-x[Месячный план]),
    rec=((a)=>[#"dif(+)"=List.Sum(List.Select(a,(x)=>x>0)), 
              #"dif(-)"=List.Sum(List.Select(a,(x)=>x<0)),
              pr=- #"dif(-)"/#"dif(+)"])(add3[Отклонение]),
    add4=Table.AddColumn(add3,"Коррекция",(x)=>if x[Отклонение]<0 then x[Стратег план] else x[Отклонение]*rec[pr]+x[Месячный план]),
    to=Table.RemoveColumns(add4,"Отклонение")
in
    to 

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(x)=>Table.FillDown(Table.Sort(x,{"Дата",{"Дата окончания",Order.Descending}}),List.LastN(nms,4)),
    sale = Table.TransformColumnTypes(f("sales"),{{"Дата", type date}}),
    act = Table.RenameColumns(Table.TransformColumnTypes(f("data"),{{"Дата начала", type date}, {"Дата окончания", type date}}),{"Дата начала","Дата"}),
    gr_data= Table.Group(act,{"SKU Код","Дата"},{"tmp",(x)=>Table.Max(x,"Дата окончания")}),
    rec=Table.FromRecords(gr_data[tmp]) & sale,
    nms=Table.ColumnNames(rec),
    gr=Table.Group(rec,"SKU Код",{"tmp",g}),
    com=Table.RemoveColumns(Table.SelectRows(Table.Combine(gr[tmp]),(i)=>i[Дата окончания]=null),"Дата окончания")
in
    com

let
    f=(x)=>(y)=>List.Sum(Table.Column(y,x)),
    lst=List.Transform({"Цена","кол-во ","сумма"},(x)=>{x,f(x)}),
    from = Excel.CurrentWorkbook(){[Name="Таблица13"]}[Content],
    gr= Table.Group(from,{"ID","наименование"},lst)
in
    gr

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(x)=>List.Transform(List.RemoveMatchingItems(Text.Split(x??"","#(lf)"),{""}), f_txtTrim),
    h=(x)=>List.Zip({List.Difference(x{0},x{1}),List.Difference(x{1},x{0})}),
    
    tr_new=Table.TransformColumns(f("table_new"),{"Шифр",g}),
    exp_new =Table.Buffer(Table.ExpandListColumn(tr_new, "Шифр")),
    tr_old=Table.TransformColumns(f("table_old"),{"Шифр",g}),
    exp_old =Table.Buffer(Table.ExpandListColumn(tr_old, "Шифр")),
    gr_new=Table.Group(exp_new,"Номер Этапа",{"Этап",(x)=>x[Шифр]}),
    gr_old=Table.Group(exp_old,"Номер Этапа",{"Этап",(x)=>x[Шифр]}),
    join=Table.NestedJoin(gr_new,"Номер Этапа",gr_old,"Номер Этапа","tmp"),
    exp = Table.ExpandTableColumn(join, "tmp", {"Этап"}, {"tmp"}),
    com=Table.CombineColumns(exp,{"Этап","tmp"},h,"tmp"),
    sel=Table.SelectRows(com,(x)=>x[tmp]<>{}),
    tbl =Table.FromColumns(sel[tmp],sel[Номер Этапа]),
    acc=List.Accumulate(List.Buffer(sel[Номер Этапа]),tbl,(s,c)=>Table.SplitColumn(s,c,(x)=>x??{},{c&" new",c&" old"}) )
in
    acc

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(x)=>List.Transform(List.RemoveMatchingItems(Text.Split(x??"","#(lf)"),{""}), f_txtTrim),
    tr_new=Table.TransformColumns(f("table_new"),{"Шифр",g}),
    exp_new =Table.ExpandListColumn(tr_new, "Шифр"),
    tr_old=Table.TransformColumns(f("table_old"),{"Шифр",g}),
    exp_old =Table.ExpandListColumn(tr_old, "Шифр"),
    gr_new=Table.Buffer(Table.Group(exp_new,"Номер Этапа",{"Этап",(x)=>x[Шифр]})),
    gr_old=Table.Buffer(Table.Group(exp_old,"Номер Этапа",{"Этап",(x)=>x[Шифр]})),
    nms_new=List.Buffer(List.Transform(gr_new[Номер Этапа],(x)=>x&" new")),
    nms_old=List.Buffer(List.Transform(gr_old[Номер Этапа],(x)=>x&" old")),
    to=Table.FromColumns(gr_new[Этап]&gr_old[Этап],nms_new&nms_old),
    nms=List.Combine(List.Zip({nms_new,nms_old})),
    sel=Table.SelectColumns(to,nms)
in
    sel 

let
    f=(x)=> Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(x)=>[tb=Table.Sort(x,"Дата"),
            rec=List.Buffer(Table.ToRecords(tb)),
            gen=List.Generate(
                ()=>[i=0,r=rec{i},ost_mon=Record.FieldOrDefault(dict,r[Товар],0),ost=ost_mon+r[Поступление]-r[Выбытие]],
                (x)=>x[i]<List.Count(rec),
                (x)=>[i=x[i]+1,r=rec{i},ost_mon=x[ost], ost=ost_mon+(r[Поступление]??0)-(r[Выбытие]??0)],
                (x)=>x[r] & [остаток на начало дня=x[ost_mon], остаток на конец дня=x[ost]])][gen],
    from=Table.TransformColumns(Table.Buffer(f("data")),{"Дата",Date.From},(x)=>x??0),                         
    dict=((a)=>Record.FromList(a[Остаток],a[Товар]))(f("dict")),
    gr=Table.Group(from,"Товар",{"tmp",g}),
    nms=((a)=>List.FirstN(a,2)&{"остаток на начало дня"}&List.Skip(a,2)&{"остаток на конец дня"})(Table.ColumnNames(from)),
    to=Table.FromRecords(List.Combine(gr[tmp]),nms)
in
    to

let
    f=(x)=> Excel.CurrentWorkbook(){[Name=x]}[Content],
    g=(optional x)=>[i=if x=null then 0 else x[i]+1,
                    dict=if x=null then dict else x[new_dict], 
                    r=rec{i},
                    ost=Record.FieldOrDefault(dict,r[Товар],0),
                    new_ost=ost + r[Поступление] - r[Выбытие],
                    new_dict=if Record.HasFields(dict,r[Товар]) 
                            then Record.TransformFields(dict,{r[Товар],(x)=>new_ost})
                            else Record.AddField(dict,r[Товар],new_ost) ],
    dict=((a)=>Record.FromList(a[Остаток],a[Товар]))(f("dict")),
    from = Table.Sort(Table.TransformColumns(Table.Buffer(f("data")),{"Дата",Date.From},(x)=>x??0),{"Дата"}),
    n=List.Count(rec),
    rec=List.Buffer(Table.ToRecords(from)),
    gen=List.Generate(g,(x)=>x[i] < n,g,(x)=>x[r] &[остаток на начало дня=x[ost], остаток на конец дня=x[new_ost]]),
    nms=((a)=>List.FirstN(a,2)&{"остаток на начало дня"}&List.Skip(a,2)&{"остаток на конец дня"})(List.Buffer(Table.ColumnNames(from))),
    tb=Table.FromRecords(gen,nms)
in
    tb

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    from=List.Buffer(Table.ToColumns(f("event"))),
    dt=Table.FirstValue(f("date")),
    lst=List.Transform(List.FirstN(from,2),(x)=>List.PositionOf(x,dt,Occurrence.All)),
    to=((pos)=>if pos={} 
               then "нет" 
               else Text.Combine(List.Distinct(List.Transform(List.Buffer(pos),(i)=>List.Last(from){i})),", "))
                    (List.Combine(lst))
in
   to

let
    f=(x)=>Excel.CurrentWorkbook(){[Name=x]}[Content],
    from=List.Buffer(Table.ToList(f("event"),(x)=>List.Transform(x,Text.From))),
    dt=Table.FirstValue(f("date")),
    fnd=List.FindText(from,Text.From(dt)),
    to=if fnd={} then "нет" else Text.Combine(List.Distinct(List.Transform(fnd,List.Last)),", ")
in
    to

let
    f=(x)=>((n)=>List.Repeat({null},n) & lst{x[row]-1})
            (Number.IntegerDivide(x[порядок]-1,3)*4),
    from = Excel.CurrentWorkbook(){[Name="data"]}[Content],
    typ=List.Zip({{"поле 1","поле 2","поле 3","поле 4"},List.Repeat({Text.Type},4)}),
    tr=Table.TransformColumnTypes(from,typ),
    lst= List.Buffer(Table.ToList(tr,(x)=>List.RemoveLastN(List.Skip(x),1)&List.FirstN(x,1))),
    add=Table.AddColumn(tr,"x", f),
    to=Table.SplitColumn(add,"x",(x)=>x,21)
in
    to

Источник = Excel.Workbook(File.Contents("S:\B2C\МАРКЕТИНГ\Аналитика\Проекты и разработки\Категорийный анализ\2025\4 кв 2025\Автоматизация\Отчет (4 квартал 2025 г.).xlsx"), null, true),
   #"База по группам_Sheet" = Источник{[Item="База по группам",Kind="Sheet"]}[Data],

#"Повышенные заголовки" = Table.PromoteHeaders(#"База по группам_Sheet", [PromoteAllScalars=true]),

#"Измененный тип" = Table.TransformColumnTypes(#"Повышенные заголовки",{{"Группа", type text}, {"Подгруппа ", type text}, {"Номер артикула", type text}, {"Номенклатура", type text}, {"Статус товара", type text}, {"Поставщик", type text},}}),

 #"Удаленные столбцы" = Table.RemoveColumns(#"Измененный тип",{"Подгруппа ", "Номер артикула", "Статус товара", "Поставщик",}),

 #"Removed Other Columns" = Table.SelectColumns(#"База по группам_Sheet",{"Группа", "Номенклатура", "АВС 4 кв 2025", "XYZ 4 кв. 2025", "Индекс Х-Х 4 кв. 2025"}),

f=(x)=>Table.FromColumns(List.Transform(Table.ToColumns(x),List.RemoveNulls),{"X","y","Z"}),

#"Сгруппированные строки" = Table.Group(#"Удаленные столбцы1", 
                              {"Группа", "АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"}, 
                              {"tmp",(x)=>((tbl)=>Table.FromColumns(List.Transform(Table.ToColumns(tbl),List.RemoveNulls),{"X","Y","Z"}))
                              (x[[X],[Y],[Z]])})

let
  Источник = Excel.Workbook(File.Contents("S:\B2C\МАРКЕТИНГ\Аналитика\Проекты и разработки\Категорийный анализ\2025\4 кв 2025\Автоматизация\Отчет (4 квартал 2025 г.).xlsx"),true),
  #"База по группам_Sheet" = Источник{[Item="База по группам",Kind="Sheet"]}[Data],
  #"Removed Other Columns" = Table.SelectColumns(#"База по группам_Sheet",{"Группа", "Номенклатура", "АВС 4 кв 2025", "XYZ 4 кв. 2025", "Индекс Х-Х 4 кв. 2025"}),
  #"Добавлен пользовательский объект" = Table.AddColumn(#"Removed Other Columns", "new", (x)=>Record.FromList({x[Номенклатура]},{x[XYZ 4 кв. 2025]})),
  #"Развернутый элемент new" = Table.ExpandRecordColumn(#"Добавлен пользовательский объект", "new", {"Z", "Y", "X"}),
  #"Удаленные столбцы1" = Table.RemoveColumns(#"Развернутый элемент new",{"Номенклатура","XYZ 4 кв. 2025"}),
  #"Сгруппированные строки" = Table.Group(#"Удаленные столбцы1", 
                              {"Группа", "АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"}, 
                              {"tmp",(x)=>((tbl)=>Table.FromColumns(List.Transform(Table.ToColumns(tbl),List.RemoveNulls),{"X","Y","Z"}))
                              (x[[X],[Y],[Z]])})
in
    #"Сгруппированные строки"

let
    Source = Excel.CurrentWorkbook(){[Name="table1"]}[Content],
    gr=Table.Group(Source,"ИСХОДНИК",{"count",Table.RowCount})
in
    gr

let
    lst=(x)=>List.Buffer(Table.ToList(x,(x)=>List.Skip(x))),
    f=(x)=>Text.Combine({Text.From(Table.FirstValue(x))} & List.Transform(lst(x),(y)=>Text.Format("-#{0}(#{1})",y))),
    from = Excel.CurrentWorkbook(){[Name="Таблица1"]}[Content],
    sel=Table.SelectRows(from,(x)=>List.RemoveNulls(Record.FieldValues(x))<>{}),
    max =List.Max(List.Transform(gr[tmp],List.Count)),
    nms=List.TransformMany({1..max/2},(x)=>{"Диаметр","Длина"},(x,y)=>y& Text.From(x)),
    gr=Table.Group(sel,"Номер",{{"tmp",(x)=>List.Combine(lst(x))},{"txt",f}}),
    spl=Table.SplitColumn(gr,"tmp",(x)=>x,nms)
in
    spl

let
    from = Excel.CurrentWorkbook(){[Name="Smart_BD_status"]}[Content],
    skip=Table.SelectRows(Table.Skip(from,(x)=>x[Статус] is number),(x)=>x[ID_idei]<>null),
    gr=Table.Group(skip,"ID_idei",{"tmp",(x)=>Table.Last(x)}),
    to=Table.FromRecords(gr[tmp]),
    sel=Table.SelectRows(to,(x)=>x[Статус]=status)
in
    sel

let
    f=(x)=>Table.FromColumns(List.Transform(Table.ToColumns(x),List.RemoveNulls),{"X","y","Z"}),

    from = Excel.Workbook(File.Contents(fParam("Path")),true){[Name="База по группам"]}[Data],
    sel = Table.SelectColumns(from,{"Группа", "Номенклатура", "АВС 4 кв 2025", "XYZ 4 кв. 2025", "Индекс Х-Х 4 кв. 2025"}),
    add=Table.AddColumn(sel,"new",(x)=>Record.FromList({x[Номенклатура]},{x[XYZ 4 кв. 2025]})),
    exp = Table.ExpandRecordColumn(add, "new", {"Z", "Y", "X"}),
    rem = Table.RemoveColumns(exp,{"Номенклатура", "XYZ 4 кв. 2025"}),
    gr=Table.Buffer(Table.Group(rem,{"Группа","АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"},{"tmp",(x)=>f(x[[X],[Y],[Z]])})),
    to =Table.Sort(Table.ExpandTableColumn(gr, "tmp", {"X", "y", "Z"}),{"АВС 4 кв 2025", "Индекс Х-Х 4 кв. 2025"})
in
    to