let
  src              = Table.Buffer ( Excel.CurrentWorkbook(){[ Name = "НДС" ]}[Content] ),
  add20            = Table.AddColumn ( src, "20%", each Number.Round ( [Сумма НДС] * 6, 2 ), type number ),
  add0             = Table.AddColumn ( add20, "0%", each [Сумма с НДС] - [#"20%"], type number ),
  needClmns        = Table.SelectColumns ( add0, { "Исходная аналитика", "20%", "0%" } ),
  unpivot          = Table.UnpivotOtherColumns ( needClmns, { "Исходная аналитика" }, "Дискретная ставка НДС", "Сумма с НДС" ),
  typed            = Table.TransformColumnTypes ( unpivot, { { "Дискретная ставка НДС", Percentage.Type } } ),
  addSumWithoutVAT = Table.AddColumn ( typed, "Сумма без НДС", each [Сумма с НДС] / ( 1 + [Дискретная ставка НДС] ), type number ),
  addVAT           = Table.AddColumn ( addSumWithoutVAT, "Сумма НДС", each [Сумма с НДС] - [Сумма без НДС], type number ),
  reorder          = Table.ReorderColumns ( addVAT, { "Исходная аналитика", "Сумма с НДС", "Сумма НДС", "Сумма без НДС", "Дискретная ставка НДС" } )
in
  reorder

let
  keywords = List.Buffer (
    Table.TransformColumns ( Excel.CurrentWorkbook(){[ Name = "keywords" ]}[Content], { "keywords", ( x ) => Text.Lower ( x ) } )[keywords]
  ),
  parameters = Record.FromList (
    Excel.CurrentWorkbook(){[ Name = "parameters" ]}[Content][Значение],
    Excel.CurrentWorkbook(){[ Name = "parameters" ]}[Content][Параметр]
  ),
  src = Excel.Workbook ( File.Contents ( parameters[Путь к файлу] ) ){[ Item = Text.From ( parameters[Лист] ), Kind = "Sheet" ]}[Data],
  split = List.Transform ( List.Split ( Table.Column ( src, Table.ColumnNames ( src ){0} ), 2 ), ( x ) => { Time.From ( x{0} ) } & { x{1} } ),
  toTable = Table.FromRows ( split, type table [ timecode = time, text = text ] ),
  filter = Table.SelectRows (
    toTable,
    each List.Accumulate ( keywords, 0, ( s, c ) => s + Number.From ( Text.Contains ( [text], c, Comparer.OrdinalIgnoreCase ) ) ) > 0
  )
in
  filter

Наибольшая :=
MAXX (
    SUMMARIZE ( ALLSELECTED ( 'Таблица1' ); 'Таблица1'[Регион]; 'Таблица1'[Филиал] );
    [средняя цена]
)

let
  keywords = List.Buffer (
    Table.TransformColumns ( Excel.CurrentWorkbook(){[ Name = "keywords" ]}[Content], { "keywords", ( x ) => Text.Lower ( x ) } )[keywords]
  ),
  parameters = Record.FromList (
    Excel.CurrentWorkbook(){[ Name = "parameters" ]}[Content][Значение],
    Excel.CurrentWorkbook(){[ Name = "parameters" ]}[Content][Параметр]
  ),
  src = Excel.Workbook ( File.Contents ( parameters[Путь к файлу] ) ){[ Item = Text.From ( parameters[Лист] ), Kind = "Sheet" ]}[Data],
  split = List.Transform (
    List.Split ( Table.Column ( src, Table.ColumnNames ( src ){0} ), 2 ),
    ( x ) => { Time.From ( Number.From ( x{0} ) / 60 ) } & { x{1} }
  ),
  toTable = Table.FromRows ( split, type table [ timecode = time, text = text ] ),
  filter = Table.SelectRows (
    toTable,
    each List.Accumulate ( keywords, 0, ( s, c ) => s + Number.From ( Text.Contains ( [text], c, Comparer.OrdinalIgnoreCase ) ) ) > 0
  )
in
  filter

=СЧЁТЕСЛИМН(F$3:F$13;F3;G$3:G$13;"<"&G3)+1

let
  src     = Excel.CurrentWorkbook(){[ Name = "data" ]}[Content],
  filter  = Table.SelectRows ( src, ( x ) => Text.Contains ( Text.From ( Record.FieldValues ( x ){0} ), "Всего" ) ),
  reverse = Table.ReverseRows ( filter )
in
  reverse

let
  keywords = List.Buffer (
    Table.TransformColumns ( Excel.CurrentWorkbook(){[ Name = "keywords" ]}[Content], { "keywords", ( x ) => Text.Lower ( x ) } )[keywords]
  ),
  parameters = Record.FromList (
    Excel.CurrentWorkbook(){[ Name = "parameters" ]}[Content][Значение],
    Excel.CurrentWorkbook(){[ Name = "parameters" ]}[Content][Параметр]
  ),
  src = Excel.Workbook ( File.Contents ( parameters[Путь к файлу] ) ){[ Item = Text.From ( parameters[Лист] ), Kind = "Sheet" ]}[Data],
  split = List.Transform ( List.Split ( Table.Column ( src, Table.ColumnNames ( src ){0} ), 2 ), ( x ) => { Number.From ( x{0} ) / 60 } & { x{1} } ),
  toTable = Table.FromRows ( split, type table [ timecode = time, text = text ] ),
  typed = Table.TransformColumnTypes ( toTable, { { "timecode", type time } } ),
  filter = Table.SelectRows (
    typed,
    each List.ContainsAny (
      Text.SplitAny ( Text.Lower ( [text] ), Text.Remove ( [text], { "0" .. "9", "A" .. "z", "А" .. "я", "[", "]" } ) ),
      keywords
    )
  )
in
  filter

let
  keywords = List.Buffer (
    Table.TransformColumns ( Excel.CurrentWorkbook(){[ Name = "keywords" ]}[Content], { "keywords", ( x ) => Text.Lower ( x ) } )[keywords]
  ),
  src = Excel.CurrentWorkbook(){[ Name = "data" ]}[Content],
  split = List.Transform ( List.Split ( src[data], 2 ), ( x ) => { x{0} / 60 } & { x{1} } ),
  toTable = Table.FromRows ( split, type table [ timecode = time, text = text ] ),
  typed = Table.TransformColumnTypes ( toTable, { { "timecode", type time } } ),
  filter = Table.SelectRows (
    typed,
    each List.Accumulate ( keywords, 0, ( s, c ) => s + Number.From ( Text.Contains ( [text], c, Comparer.OrdinalIgnoreCase ) ) ) > 0
  )
in
  filter

  = Table.ReplaceValue (
    #"Замененное значение", 
    each [price], 
    each if [price] > 0 then "true" else [price], 
    Replacer.ReplaceValue, 
    { "price" }
  )

max :=
VAR curDate =
    MAX ( 'Calendar'[Date] )
VAR maxDateInDataTable =
    MAXX ( ALL ( 'Данные' ); 'Данные'[дата] )
VAR result =
    IF (
        curDate <= maxDateInDataTable;
        CALCULATE ( MAX ( 'Данные'[дата время] ); 'Calendar'[Date] <= curDate )
    )
RETURN
    result

max :=
VAR curDate =
    MAX ( 'Calendar'[Date] )
VAR result =
    IF (
        curDate <= TODAY ();
        CALCULATE ( MAX ( 'Данные'[дата время] ); 'Calendar'[Date] <= curDate )
    )
RETURN
    result

max :=
CALCULATE (
    MAX ( 'Данные'[дата время] );
    FILTER (
        ALL ( 'Calendar'[Date] );
        'Calendar'[Date] <= MAX ( 'Calendar'[Date] )
    )
)

max :=
VAR curMaxDate =
    MAX ( 'Данные'[дата] )
VAR result =
    CALCULATE ( MAX ( 'Данные'[дата время] ); 'Данные'[дата] <= curMaxDate )
RETURN
    curMaxDate

=ВЫБОР(
   ПОИСКПОЗ( F7; {0;0,01;42500,01;63957,01;340850,01;1717850,01} );
   0; F22/0,88; (F22-425)/0,8712; (F22-4250)/0,792; (F22+3400)/0,81; (F22+194650)/0,9
)

  replace = Table.FromRecords (
    Table.TransformRows (
      tbl,
      ( r ) =>
        Record.TransformFields (
          r,
          {
            { "Столбец2", each if r[Столбец1] = "q" or r[Столбец1] = "w" then 7 else _ },
            { "Столбец1", ( x ) => if x = "q" or r[Столбец2] = 5 then x & "!!!" else x }
          }
        )
    ),
    Value.Type ( tbl )
  )

let
  src = Excel.CurrentWorkbook(){[ Name = "stock" ]}[Content] & Excel.CurrentWorkbook(){[ Name = "price" ]}[Content],
  typed = Table.TransformColumnTypes ( src, { { "Дата", type date }, { "Кол-во", Int64.Type }, { "Цена", type number } } ),
  group = Table.Group (
    typed,
    { "Наименование" },
    {
      {
        "table",
        ( eachProduct ) =>
          [
            sort     = Table.Sort ( eachProduct, { { "Дата", Order.Ascending }, { "Кол-во", Order.Ascending } } ),
            fillDown = Table.FillDown ( sort, { "Цена" } ),
            filter   = Table.SelectRows ( fillDown, each ( [#"Кол-во"] <> null ) )
          ][filter]
      }
    }
  ),
  combine = Table.Combine ( group[table] )
in
  combine

let
  src = Table.AddIndexColumn ( Excel.CurrentWorkbook(){[ Name = "stock" ]}[Content], "Индекс", 1, 1 )
    & Excel.CurrentWorkbook(){[ Name = "price" ]}[Content],
  typed = Table.TransformColumnTypes ( src, { { "Дата", type date }, { "Кол-во", Int64.Type }, { "Цена", type number } } ),
  group = Table.Group (
    typed,
    { "Наименование" },
    {
      {
        "table",
        ( eachProduct ) =>
          [
            sort     = Table.Sort ( eachProduct, { { "Дата", Order.Ascending }, { "Кол-во", Order.Ascending } } ),
            fillDown = Table.FillDown ( sort, { "Цена" } ),
            filter   = Table.SelectRows ( fillDown, each ( [#"Кол-во"] <> null ) )
          ][filter]
      }
    }
  ),
  combine = Table.Combine ( group[table] ),
  sort = Table.Sort ( combine, { { "Индекс", Order.Ascending } } ),
  removeIndex = Table.RemoveColumns ( sort, { "Индекс" } )
in
  removeIndex

Мера 2 :=
CALCULATE (
    [Сухой вес остатка];
    ALL ( 'Отпр' );
    INTERSECT ( ALL ( 'Отпр'[Куда остаток] ); VALUES ( 'Отпр'[Номер партии] ) )
)

Количество_:=SUMX (
    VALUES ( categories[Категория] );
    CALCULATE (
        COUNTROWS (
            FILTER (
                'data';
                'data'[Количество] >= MIN ( 'categories'[От] )
                    && 'data'[Количество] < MAX ( 'categories'[До] )
            )
        )
    )
)

Кол-во:=SUMX (
    VALUES ( categories[Категория] );
    CALCULATE (
        COUNTROWS (
            FILTER (
                'data';
                IF (
                    ISBLANK ( MIN ( 'categories'[От] ) );
                    TRUE ();
                    'data'[Количество] >= MIN ( 'categories'[От] )
                )
                    && IF (
                        ISBLANK ( MAX ( 'categories'[До] ) );
                        TRUE ();
                        'data'[Количество] < MAX ( 'categories'[До] )
                    )
            )
        )
    )
)

let
  src = Excel.CurrentWorkbook(){[ Name = "Исходные_данные" ]}[Content],
  addDate = Table.AddColumn (
    src,
    "Дата",
    each List.First (
      List.RemoveNulls (
        List.Transform (
          List.Select ( Text.Split ( [Folder Path], "\" ), ( x ) => Text.Length ( x ) = 10 ),
          ( x ) => try Date.FromText ( x, "RU-ru" ) otherwise null
        )
      )
    ),
    type date
  )
in
  addDate

Мера 2 :=
IF (
    HASONEVALUE ( 'Отпр'[Номер партии] );
    (
        CALCULATE (
            [Сухой вес остатка];
            FILTER ( ALL ( 'Отпр' ); 'Отпр'[Куда остаток] = MAX ( 'Отпр'[Номер партии] ) )
        )
    )
)