// 1. dfs 顺序： 枚举可能的 r，h 拼成一层蛋糕 (顺序是层内操作)

// 2. dfs 状态： preR, preH, 当前层，累计体积，累计面经 (状态是分支和给下次的依赖值)

// (为什么穿入preR, preH 而不是 r，h？ 因为r，h不是固定值，是需要遍历的，穿入上层的值也只是作为题目要求的剪枝边界)

// 3. 剪枝：

// 3.1 优化搜索顺序：r，h ，level都从大到小搜索， 因为r^2 权重比h大，所以还有先搜索r

// 3.2 可行性剪枝：

// 3.2.1 & 3.2.2 ：累计超出最大体积；累计超出最小表面积；

// 原理是最小的r和h都是当前层数(1~m)，因为题中要求：当i < M时，要求Ri > Ri+1且 Hi > Hi+1

// 3.2.3 : 上下界 ：curR 上界为 r = Math.min(preR-1, (int)Math.sqrt(n-preV))， 下界为level

// curH 上界为 h = Math.min(preH-1, (n-preV)/r/r) ， 下界为 level

// 原理是 V = r^2 * h

// 3.3 最优化剪枝： 根据 表面积与体积不等式推导而出

// ================================

// 搜索状态：

// 搜索状态可视为一个多元组，每一维都是问题状态空间的一个维度，

// 在题目中，一般在“输入变量”， “限制条件”， “待求解变量”等关键位置体现

//

// 搜索剪枝：

// 1. 针对每个状态进行缩放对边界进行推导 (可行性)

// 2. 对未来的最小代价进行计算 (最优化)

import java.util.*;

public class Main{

void run(){

int n = jin.nextInt();

int m = jin.nextInt();

for(int i = 1 ;i <= m ; i++){

mins[i] = mins[i-1] + i*i*2;

minv[i] = minv[i-1] + i*i*i;

}

System.out.println(solve(n, m));

}

int solve(int n, int m){

// dfs2(n, (int)Math.sqrt(n), m, 0, 0, n, m);

dfs(Integer.MAX_VALUE, Integer.MAX_VALUE, m, 0, 0, n, m);

return res;

}

void dfs(int preR, int preH, int level, int preV, int preS, int n, int m){

if (preV + minv[level] > n) return ;

if (preS + mins[level] > res) return ;

if (preS + 2*(n-preV) / preR >= res) return ;

if (level == 0 ){

if (preV == n){

res = Math.min(res, preS);

}

return ;

}

for (int r = Math.min(preR-1, (int)Math.sqrt(n-preV)); r >= level; r--){

for (int h = Math.min(preH-1, (n-preV)/r/r); h >= level ;h--){

dfs(r, h, level-1, preV+r*r*h, preS+2*r*h+(level==m?r*r:0), n, m );

}

}

return ;

}

void dfs2 (int r, int h, int level, int preV, int preS, int n, int m){

if (level == 0 ){

if (preV == n){

res = Math.min(res, preS);

}

return ;

}

// int curV = r*r*h; // 错误原因是 这个是上一个的值

// int curS = 2*r*h; // 不能开始就认为 r,h 是本层的值，

// 因为本层的值有多种可能需要遍历，最初的时候没法传入，而认为是上一层的值可以传哨兵

// if (level == m-1) curS += r*r;

for (int i = r-1 ;i > 0 ; i--){

for (int j = h-1 ; j>0 ; j--){

// dfs2(i, j, level-1, preV+curV, preS+curS, n, m); // 其实这里传入的也是上一次的值

dfs2(i, j, level-1, preV+i*i*j, preS+2*i*j+(level==m?i*i:0), n,m);

}

}

}

private int[] mins = new int[22];

private int[] minv = new int[22];

private int res = Integer.MAX_VALUE;

private Scanner jin = new Scanner(System.in);

public static void main(String[] args) throws Exception {new Main().run();}

}