#include <bits/stdc++.h>
#pragma GCC optimize(3)
#define int long long
#define llu unsigned long long
#define endl "\n"
#define inf 0x3f3f3f3f
#define debug cout << "****************" << endl
#define bit(x) (1LL << x)
using namespace std;
typedef pair<int, int> PII;

const int N = 3e6;

int c[N];
int n;

int lowbit(int x)
{
    return x & (-x);
}

void updata(int i, int k)  //大于等于传入位置的值+1  c[i]记前i个位置人数（1->i）
{                          //使用树状数组便于更新
    while (i <= bit(n))
    {
        c[i] += k;
        i += lowbit(i);
    }
}

int getsum(int i)
{
    int res = 0;
    while (i > 0)
    {
        res += c[i];
        i -= lowbit(i);
    }
    return res;
}

void solve()
{
    int k;
    cin >> n >> k;
    int len = bit(n);
    vector<int> a(len + 7);
    vector<int> g(len + 7);
    for (int i = 1; i <= len; i++)
    {
        cin >> a[i];
        g[a[i]] = i;
    }
    vector<int> res(len + 7);
    for (int i = 1; i <= len; i++)
    {
        int ans = 0; 
        int j = n;
        int st = bit(j) - 1;
        int l = 1, r = len;
        while (l < r)
        {
            int mid = (l + r) / 2;
            int fd = getsum(r) - getsum(l - 1);
            if (fd + k >= st && i - 1 >= st)//由于是按实力便利，当前树状数组里存的数均小于当前数，所以fd（区间人数）+k置换名额就是可胜利次数。胜利j轮需要胜利bit(j)-1次；
            {
                ans = j;
                break;
            }
            j--;
            st = bit(j) - 1;
            if (g[i] >= l && g[i] <= mid)//这个二分恰好卡上二叉树的结构
                r = mid;
            else
                l = mid + 1;
        }
        res[g[i]] = ans;
        updata(g[i], 1);
    }
    for (int i = 1; i <= len; i++)
        cout << res[i] << " ";
    cout << endl;
}

signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int T = 1;
    // cin >> T;
    while (T--)
        solve();
    return 0;
}
// 题解：可以看出对于一个人，他的比赛赢一把，赢两把，赢三把所需要有1个人，3个人，7个人比他小且比他小的在某个区间内（这里有点类似于线段树的分块思想，总共log层），所以对于某个人只需要查询对于某个区间内有多少人比他小，可以使用线段树或者树状数组，这里需要注意的是，使用树状数组要从小到大枚举值所在的位置而不是从左到右枚举位置
// 这段代码是用来解决一个问题的，涉及到比赛获胜人数的统计和区间查询。下面是对各部分的详细讲解：

// 头文件和宏定义：

// 引入标准库和一些宏定义以简化代码，例如 #define int long long 使得 int 变为 long long，避免整数溢出。
// 全局变量：

// c[N]：树状数组，用于维护频率。
// n：输入的比赛人数。
// 低位提取函数 lowbit(int x)：

// 计算 x 的最低位的 1 的值，这在更新树状数组时很重要。
// 更新函数 updata(int i, int k)：

// 在树状数组中更新索引 i，增加值 k。通过不断加上 lowbit 来更新所有相关的父节点。
// 求和函数 getsum(int i)：

// 计算从 1 到 i 的前缀和，通过 lowbit 来累加值。
// 主解题函数 solve()：

// 读取输入 n 和 k。
// 初始化数组 a 和 g，分别存储比赛结果和其索引。
// 对于每个选手，计算能够获胜的最大场数 ans。
// 使用二分查找来确定在某个区间内有多少人比当前选手小，利用 getsum 查询。
// 通过调用 updata 更新当前选手的索引频率。
// 主函数 main()：

// 设置输入输出流以提高效率，运行 solve() 函数。
// 总的来说，这段代码运用树状数组高效地解决了有关人数查询和统计的问题，利用了频率更新和二分查找的策略来优化查询过程。



// 您说：
// for (int i = 1; i <= len; i++) 
//     {
//         int ans = 0;
//         int j = n;
//         int st = bit(j) - 1;
//         int l = 1, r = len;
//         while (l < r)
//         {
//             int mid = (l + r) / 2;
//             int fd = getsum(r) - getsum(l - 1);
//             if (fd + k >= st && i - 1 >= st)
//             {
//                 ans = j;
//                 break;
//             }
//             j--;
//             st = bit(j) - 1;
//             if (g[i] >= l && g[i] <= mid)
//                 r = mid;
//             else
//                 l = mid + 1;
//         }
//         res[g[i]] = ans;
//         updata(g[i], 1);
//     }讲一下这段
// ChatGPT 说：
// ChatGPT
// 这段代码的主要目的是在给定的比赛人数和获胜条件下，计算每个选手能获得的最大比赛胜利场数。下面逐行解析这段代码：

// 循环遍历选手：

// cpp
// 复制代码
// for (int i = 1; i <= len; i++) 
// 遍历每个选手，从 1 到 len。

// 初始化变量：

// cpp
// 复制代码
// int ans = 0;
// int j = n;
// int st = bit(j) - 1;
// int l = 1, r = len;
// ans 用于存储当前选手能够获胜的最大场数。
// j 初始化为 n，表示当前可能的最大获胜场数。
// st 为当前 j 值对应的区间长度减一，表示所有可能的胜利场次。
// l 和 r 是二分查找的边界。
// 二分查找：

// cpp
// 复制代码
// while (l < r)
// 开始二分查找，寻找在某个区间内的胜利条件。

// 计算中间值：

// cpp
// 复制代码
// int mid = (l + r) / 2;
// int fd = getsum(r) - getsum(l - 1);
// 计算中间值 mid，用于分割区间。
// fd 表示在 [l, r] 区间内的选手数量，使用 getsum 计算前缀和。
// 检查胜利条件：

// cpp
// 复制代码
// if (fd + k >= st && i - 1 >= st)
// {
//     ans = j;
//     break;
// }
// 如果区间内的选手数量加上允许的额外胜利 k 大于等于 st，且当前选手的索引 i - 1 也大于等于 st，则说明当前选手可以在最大场数 j 下获胜，更新 ans 并跳出循环。
// 调整查找范围：

// cpp
// 复制代码
// j--;
// st = bit(j) - 1;
// if (g[i] >= l && g[i] <= mid)
//     r = mid;
// else
//     l = mid + 1;
// 减少 j，以查看更小的可能获胜场数。
// 更新 st 为新的 j 值对应的区间长度减一。
// 根据当前选手的索引 g[i] 调整二分查找的范围：
// 如果 g[i] 在 l 和 mid 之间，说明当前选手可能在这个区间内，因此缩小右边界 r。
// 否则，将左边界 l 移动到 mid + 1。
// 存储结果和更新频率：

// cpp
// 复制代码
// res[g[i]] = ans;
// updata(g[i], 1);
// 将当前选手的最大获胜场数 ans 存入结果数组 res。
// 调用 updata 更新树状数组，记录当前选手的胜利状态。
// 通过这段代码，程序实现了根据选手的表现和查询条件，动态计算并更新每个选手的最大获胜场数。


// 2/2

// 您说：
// 帮我讲一下所有变量含义
// ChatGPT 说：
// ChatGPT
// 这段代码中的变量用于处理比赛中选手的获胜情况。下面是所有变量的含义及作用的详细解释：

// 全局变量：

// int c[N];
// 树状数组，用于记录每个位置上有多少个选手胜利。
// int n;
// 比赛选手的人数。
// solve() 函数中的局部变量：

// int k;

// 题目中输入的一个值，通常用于控制在某些情况下允许的额外胜利次数或胜利的某些限制条件。
// int len = bit(n);

// bit(n) 相当于 2^n，len 表示比赛的总长度，即所有可能的状态数量。
// vector<int> a(len + 7);

// 存储输入数据的数组，大小为 len + 7，比实际 len 稍大一些，方便边界操作。
// vector<int> g(len + 7);

// 该数组用于存储选手 a 的排名索引，即 g[a[i]] = i 表示值为 a[i] 的选手在第 i 个位置。
// vector<int> res(len + 7);

// 存储每个选手可以获胜的最大场次的数组。res[g[i]] 表示第 i 个选手能够取得的最大获胜场数。
// int ans = 0;

// 当前选手能取得的最大获胜场数。初始值为 0，最终结果会存储在 res 中。
// int j = n;

// 当前选手可能的最大获胜场数，初始值设为 n。在每次计算失败后会递减，用于探索不同的胜利场数。
// int st = bit(j) - 1;

// 表示在 j 场胜利时，所需有的比当前选手弱的选手数量。bit(j) 相当于 2^j，st 代表 2^j - 1，即选手需要至少比该值更多的人数要比他小。
// int l = 1, r = len;

// 用于二分查找的左右边界，初始为整个选手范围。
// int mid = (l + r) / 2;

// 二分查找中的中点，用于调整查找范围。
// int fd = getsum(r) - getsum(l - 1);

// fd 表示在 [l, r] 区间内的选手数量，通过树状数组 getsum() 函数计算。
// 辅助函数中的变量：

// int lowbit(int x)

// x & (-x)，返回 x 最低位的 1 的值，用于树状数组中快速定位更新范围。
// void updata(int i, int k)

// i 表示要更新的位置，k 为更新的值。
// 在树状数组中增加索引 i 的值 k，并更新其父节点，直到超过范围。
// int getsum(int i)

// i 表示要查询的前缀和的终点位置。
// 通过树状数组，返回从 1 到 i 的前缀和，用于计算特定区间内选手的数量。
// 这些变量的组合和操作，形成了一种高效的基于树状数组的动态查询机制，用于确定在比赛中每个选手能够取得的最大获胜场数。